Scrapling 深度解析：52K+ Stars 的自适应爬虫框架——智能元素追踪、Cloudflare 绕过与全规模爬取的完整实战指南

一、为什么我们需要一个新的爬虫框架？

如果你是一个有经验的 Python 爬虫开发者，你大概率经历过这样的痛苦循环：

1. 用 BeautifulSoup + Requests 写了一个简单爬虫，网站改版后选择器全部失效，手动修复花了两小时。
2. 换用 Scrapy，框架强大但笨重，对付 Cloudflare 等反爬系统时需要额外集成 Playwright、Selenium，配置繁琐。
3. 上 Playwright/Selenium 直接跑浏览器自动化，能绕过反爬了，但速度慢得像蜗牛，内存占用飙升。
4. 集成各种指纹库（undetected-chromedriver、stealth.js），版本一更新就崩，维护成本指数级上升。

更致命的是，2026 年的 Web 已经不是 2020 年的 Web 了。Cloudflare Turnstile、Akamai Bot Manager、DataDome 等反爬系统的进化速度远超爬虫框架的迭代速度。据统计，全球 Top 1000 网站中有超过 60% 部署了某种形式的 Bot 检测，传统爬虫的首次请求成功率已跌破 30%。

Scrapling 的出现，正是为了从根本上解决这些痛点。它不是在 Scrapy 或 Playwright 之上又包了一层壳，而是从解析器、请求器、反爬绕过、爬取调度四个维度重新设计了 Python 爬虫的技术栈。自 2025 年开源以来，Scrapling 在 GitHub 上获得了 52K+ Stars，日活跃用户数百人，被数据工程师、AI 工程师、安全研究员广泛使用。

本文将从架构设计、核心模块、代码实战、性能基准、与竞品对比五个维度，深度拆解这个框架为什么能做到「一次编写，永不过期」。

二、架构总览：四层金字塔

Scrapling 的架构可以概括为一个四层金字塔：

┌─────────────────────────────────────────┐
│           Spiders（爬取调度层）            │
│   并发控制 · 暂停恢复 · 流式输出 · 导出    │
├─────────────────────────────────────────┤
│         Fetchers（请求获取层）             │
│   HTTP · 浏览器自动化 · 反指纹 · 会话管理  │
├─────────────────────────────────────────┤
│       Adaptive Parser（自适应解析层）       │
│   智能元素追踪 · 相似度匹配 · 自动重定位    │
├─────────────────────────────────────────┤
│        Core Engine（核心引擎层）           │
│   高性能序列化 · 内存优化 · 类型系统        │
└─────────────────────────────────────────┘

每一层都可以独立使用，也可以组合使用。你只需要一个 pip install scrapling，就能获得从底层解析到顶层爬取调度的完整能力。

三、核心模块深度拆解

3.1 自适应解析器：网站改版不再是噩梦

这是 Scrapling 最核心的创新。传统爬虫的痛点在于：CSS 选择器或 XPath 表达式与 DOM 结构强耦合，网站前端一改版，爬虫就废了。

Scrapling 的解决方案是 智能元素追踪（Smart Element Tracking）。其核心原理是：当解析器第一次找到目标元素时，它不仅记录选择器，还会提取该元素的多维特征指纹，包括：

• 结构特征：标签层级、兄弟节点关系、子节点数量
• 内容特征：文本内容的 n-gram 哈希、属性值模式
• 位置特征：在父元素中的相对位置、在页面中的深度
• 样式特征：class 名称模式、id 模式、data 属性

当网站结构发生变化时，Scrapling 会使用相似度算法在新的 DOM 树中重新定位目标元素。这个过程是自动的，开发者只需要在第一次选择时加上 auto_save=True，后续使用时加上 adaptive=True。

from scrapling.fetchers import StealthyFetcher

# 第一次爬取：自动保存元素特征
page = StealthyFetcher.fetch('https://example.com/products', headless=True)
products = page.css('.product-card', auto_save=True)

# 两周后网站改版了，.product-card 选择器失效
# 但 adaptive=True 会基于特征指纹重新定位
page = StealthyFetcher.fetch('https://example.com/products', headless=True)
products = page.css('.product-card', adaptive=True)  # 照样找到！

这个机制的底层实现涉及几个关键技术决策：

1. 特征存储

Scrapling 使用一个轻量级的本地存储系统来持久化元素特征。你可以自定义存储后端（默认是 SQLite），也可以对接 Redis 或其他数据库。这意味着特征数据在多次运行之间是持久的。

2. 相似度计算

元素的相似度不是简单的字符串匹配，而是多维度加权评分。权重分配大致如下：

• 结构特征权重最高（35%），因为 DOM 结构是最稳定的信号
• 内容特征次之（30%），因为目标元素的内容通常有固定模式
• 位置特征（20%）和样式特征（15%）作为辅助信号

3. 降级策略

如果自适应匹配的置信度低于阈值，Scrapling 不会返回错误数据，而是抛出明确的警告，告诉你「这个元素可能是错的，置信度只有 62%」。这比默默返回错误数据要好得多。

3.2 Fetchers：三种请求策略，覆盖所有场景

Scrapling 提供了三种请求器，分别对应不同的使用场景：

Fetcher：高性能 HTTP 请求

基于 httpx 封装，支持 HTTP/3，能模拟浏览器的 TLS 指纹。这是最快的请求方式，适合不依赖 JavaScript 渲染的静态页面。

from scrapling.fetchers import Fetcher

# 基础请求
page = Fetcher.get('https://api.example.com/data')

# 模拟 Chrome 的 TLS 指纹
page = Fetcher.get('https://example.com', stealthy_headers=True)

# 使用代理
page = Fetcher.get('https://example.com', proxy='http://proxy:8080')

Fetcher 的核心优势在于它的 TLS 指纹模拟能力。很多反爬系统（如 Cloudflare）会检查 TLS ClientHello 的格式来判断是否为真实浏览器。Scrapling 内置了多种浏览器的 TLS 指纹模板，可以在不启动浏览器的情况下模拟真实浏览器的网络行为。

StealthyFetcher：反爬绕过利器

这是 Scrapling 最受关注的请求器。它基于 Playwright 的 Chromium，但加入了一整套反指纹措施：

• Canvas 指纹随机化：每次请求生成不同的 Canvas 渲染结果
• WebGL 指纹伪装：修改 GPU 渲染信息
• AudioContext 指纹：随机化音频处理参数
• Navigator 属性覆盖：修改 navigator.webdriver、navigator.plugins 等
• 字体指纹干扰：随机注入不可见的字体差异

最关键的是，Scrapling 的 StealthyFetcher 可以开箱即用地绕过 Cloudflare Turnstile。这是一个在爬虫社区被反复讨论的难题，大多数方案需要手动处理 Turnstile 的 iframe 交互，而 Scrapling 把这个过程自动化了。

from scrapling.fetchers import StealthyFetcher

# 绕过 Cloudflare Turnstile
page = StealthyFetcher.fetch(
    'https://protected-site.com',
    headless=True,
    network_idle=True,
    humanize=True  # 模拟人类行为模式
)

# 确认绕过成功
print(page.css('title').text)  # 输出真实页面标题，而不是 Cloudflare 挑战页

DynamicFetcher：动态页面渲染

基于 Playwright 的 Chromium 或 Google Chrome，支持完整的浏览器自动化。适合需要 JavaScript 渲染、交互操作（点击、滚动、填写表单）的场景。

from scrapling.fetchers import DynamicFetcher

# 渲染动态页面
page = DynamicFetcher.fetch(
    'https://spa-example.com',
    headless=True,
    network_idle=True,
    page_action=lambda page: page.click('#load-more')  # 执行交互操作
)

3.3 Spiders：全规模爬取框架

Scrapling 的 Spider 模块是整个框架中最接近 Scrapy 的部分，但它在设计上有几个关键差异：

1. 原生异步

Scrapling 的 Spider 完全基于 asyncio 构建，从底层就是异步的。不像 Scrapy 那样在同步框架上「嫁接」异步支持。

2. 多会话统一调度

在同一个 Spider 中，你可以混合使用 HTTP 请求和浏览器请求。Scrapling 会自动管理不同类型的会话，统一调度。

from scrapling.spiders import Spider, Response, Request

class EcommerceSpider(Spider):
    name = "ecommerce"
    start_urls = ["https://shop.example.com/categories"]
    concurrency = 10  # 并发数
    download_delay = 0.5  # 请求间隔

    async def parse(self, response: Response):
        # 静态页面用 HTTP 请求（快）
        for category in response.css('.category-link'):
            yield Request(
                url=category.attrib['href'],
                callback=self.parse_category,
                session_type='http'  # 指定使用 HTTP 会话
            )

    async def parse_category(self, response: Response):
        # 动态页面用浏览器请求（能绕过反爬）
        for product in response.css('.product'):
            yield Request(
                url=product.attrib['href'],
                callback=self.parse_product,
                session_type='stealthy'  # 指定使用 StealthyFetcher
            )

    async def parse_product(self, response: Response):
        yield {
            'title': response.css('h1::text').get(),
            'price': response.css('.price::text').get(),
            'description': response.css('.desc').text,
        }

3. 暂停与恢复

Scrapling 的 Spider 支持基于检查点的暂停与恢复。按下 Ctrl+C 会优雅地保存当前状态，下次启动时从断点继续。

# 第一次运行，爬到一半按 Ctrl+C
spider = EcommerceSpider()
spider.start()  # 爬了 500 个页面后中断

# 第二次运行，自动从第 501 个页面继续
spider = EcommerceSpider()
spider.start()  # 从检查点恢复

4. 流式输出

对于长时间运行的爬取任务，Scrapling 支持流式输出，可以实时获取已爬取的数据，而不需要等待整个任务完成。

async for item in spider.stream():
    print(item)  # 每爬完一个页面就输出结果
    # 可以接入实时数据管道

3.4 MCP Server：AI 驱动的智能爬取

这是 Scrapling 2026 年最重要的新特性。MCP（Model Context Protocol）Server 让 AI 助手（如 Claude、Cursor）可以直接调用 Scrapling 进行网页数据提取。

传统的 AI + 爬虫方案通常是：先爬取整个页面的 HTML，然后把整个 HTML 塞给 LLM 处理。问题是，一个现代网页的 HTML 可能有 500KB 甚至 1MB，其中大量是无关的脚本、样式和广告代码。把这些全部喂给 LLM，不仅浪费 Token，还会降低提取精度。

Scrapling 的 MCP Server 解决了这个问题。它在将数据传给 AI 之前，先用 Scrapling 的解析能力进行精准提取，只把目标内容传给 LLM。这可以将 Token 使用量降低 80% 以上，同时提高数据提取的准确率。

# MCP Server 配置示例
{
    "mcpServers": {
        "scrapling": {
            "command": "scrapling",
            "args": ["mcp-server"]
        }
    }
}

配置好后，AI 助手就可以通过 MCP 协议调用 Scrapling 的能力：

• 抓取指定 URL 的页面内容
• 使用 CSS/XPath 选择器提取目标数据
• 执行 JavaScript 交互后提取数据
• 智能提取页面的主要内容（去除导航、广告等噪音）

这使得 AI 助手在需要获取网页数据时，不再需要依赖低效的全页面抓取，而是可以精准地获取所需信息。

四、代码实战：从零构建一个生产级爬虫

下面我们通过一个完整的实战案例，展示如何用 Scrapling 构建一个能绕过反爬、自适应网站变化的电商数据爬虫。

4.1 环境搭建

# 安装 Scrapling 及所有依赖
pip install "scrapling[all]"

# 安装浏览器及系统依赖
scrapling install

# 验证安装
python -c "import scrapling; print(scrapling.__version__)"

4.2 项目结构

ecommerce_scraper/
├── config.py          # 配置文件
├── spiders/
│   └── product_spider.py
├── pipelines/
│   └── export_pipeline.py
├── models/
│   └── product.py
├── main.py
└── requirements.txt

4.3 配置文件

# config.py
SPIDER_CONFIG = {
    'concurrency': 5,
    'download_delay': 1.0,
    'max_retries': 3,
    'timeout': 30,
    'robots_txt_obey': True,
    'proxy_rotation': {
        'enabled': True,
        'proxies': [
            'http://proxy1:8080',
            'http://proxy2:8080',
            'http://proxy3:8080',
        ],
        'strategy': 'round_robin',  # round_robin | random | least_used
    },
    'output': {
        'format': 'jsonl',
        'path': './output/products.jsonl',
    }
}

4.4 核心爬虫实现

# spiders/product_spider.py
import asyncio
from scrapling.spiders import Spider, Response, Request
from scrapling.fetchers import StealthyFetcher

class ProductSpider(Spider):
    name = "product_spider"
    start_urls = ["https://shop.example.com/"]
    concurrency = 5
    download_delay = 1.0
    robots_txt_obey = True

    async def parse(self, response: Response):
        """解析首页，获取分类链接"""
        categories = response.css('nav.category-menu a')
        for cat in categories:
            url = cat.attrib.get('href', '')
            if url and '/category/' in url:
                yield Request(
                    url=url,
                    callback=self.parse_category,
                    meta={'category': cat.text.strip()},
                    session_type='stealthy',  # 使用反爬浏览器
                )

    async def parse_category(self, response: Response):
        """解析分类页，获取商品链接并处理分页"""
        category = response.meta.get('category', 'Unknown')

        # 提取商品链接
        for product_link in response.css('.product-item a.product-link'):
            url = product_link.attrib.get('href', '')
            if url:
                yield Request(
                    url=url,
                    callback=self.parse_product,
                    meta={'category': category},
                    auto_save=True,  # 启用自适应追踪
                )

        # 处理分页
        next_page = response.css('a.next-page')
        if next_page:
            yield Request(
                url=next_page.attrib['href'],
                callback=self.parse_category,
                meta={'category': category},
                session_type='stealthy',
            )

    async def parse_product(self, response: Response):
        """解析商品详情页，提取核心数据"""
        # 使用自适应选择器
        title = response.css('h1.product-title', adaptive=True)
        price = response.css('.product-price .current', adaptive=True)
        original_price = response.css('.product-price .original', adaptive=True)
        rating = response.css('.rating-score', adaptive=True)
        review_count = response.css('.review-count', adaptive=True)
        description = response.css('.product-description', adaptive=True)
        images = response.css('.product-gallery img', adaptive=True)

        yield {
            'url': response.url,
            'category': response.meta.get('category'),
            'title': title.text if title else None,
            'price': self._clean_price(price.text if price else None),
            'original_price': self._clean_price(
                original_price.text if original_price else None
            ),
            'rating': self._parse_float(rating.text if rating else None),
            'review_count': self._parse_int(
                review_count.text if review_count else None
            ),
            'description': description.text if description else None,
            'images': [
                img.attrib.get('src', '')
                for img in (images or [])
            ],
            'scraped_at': asyncio.get_event_loop().time(),
        }

    @staticmethod
    def _clean_price(text):
        if not text:
            return None
        import re
        match = re.search(r'[\d,.]+', text.replace(' ', ''))
        return float(match.group().replace(',', '.')) if match else None

    @staticmethod
    def _parse_float(text):
        if not text:
            return None
        import re
        match = re.search(r'[\d.]+', text)
        return float(match.group()) if match else None

    @staticmethod
    def _parse_int(text):
        if not text:
            return None
        import re
        match = re.search(r'\d+', text.replace(',', '').replace(' ', ''))
        return int(match.group()) if match else None

4.5 数据导出管道

# pipelines/export_pipeline.py
import json
from datetime import datetime

class ExportPipeline:
    def __init__(self, output_path):
        self.output_path = output_path
        self.file = None
        self.count = 0

    def open(self):
        self.file = open(self.output_path, 'w', encoding='utf-8')

    def process_item(self, item):
        item['exported_at'] = datetime.now().isoformat()
        self.file.write(json.dumps(item, ensure_ascii=False) + '\n')
        self.file.flush()
        self.count += 1
        if self.count % 100 == 0:
            print(f'[Pipeline] Exported {self.count} items')

    def close(self):
        if self.file:
            self.file.close()
        print(f'[Pipeline] Total exported: {self.count} items')

4.6 主程序

# main.py
import asyncio
from spiders.product_spider import ProductSpider
from pipelines.export_pipeline import ExportPipeline

async def main():
    pipeline = ExportPipeline('./output/products.jsonl')
    pipeline.open()

    spider = ProductSpider()
    try:
        async for item in spider.stream():
            pipeline.process_item(item)
    except KeyboardInterrupt:
        print('\n[Main] Graceful shutdown...')
    finally:
        pipeline.close()

if __name__ == '__main__':
    asyncio.run(main())

4.7 使用代理轮转

from scrapling.fetchers import StealthyFetcher
from scrapling.spiders import ProxyRotator

# 创建代理轮转器
rotator = ProxyRotator(
    proxies=[
        'http://user:pass@proxy1:8080',
        'http://user:pass@proxy2:8080',
        'http://user:pass@proxy3:8080',
        'socks5://user:pass@proxy4:1080',
    ],
    strategy='round_robin',  # 轮转策略
)

# 在 Fetcher 中使用
page = StealthyFetcher.fetch(
    'https://example.com',
    proxy=rotator.get_next(),
    headless=True,
)

4.8 DNS 泄漏防护

当使用代理时，DNS 请求可能不经过代理服务器，导致真实 IP 泄漏。Scrapling 内置了 DNS-over-HTTPS 支持：

from scrapling.fetchers import Fetcher

# 启用 DNS-over-HTTPS，防止 DNS 泄漏
page = Fetcher.get(
    'https://example.com',
    proxy='http://proxy:8080',
    dns_over_https=True,  # 通过 Cloudflare DoH 解析 DNS
)

五、性能基准：Scrapling vs 竞品

Scrapling 官方提供了一套完整的性能基准测试，对比了主流 Python 爬虫库在相同任务下的表现。以下是关键指标：

5.1 解析性能

Scrapling 的解析性能在大多数场景下优于 BeautifulSoup 3-5 倍，与 lxml 相当但 API 更友好。其 JSON 序列化速度是标准库的 10 倍以上，这对大规模数据导出至关重要。

5.2 请求性能

Scrapling 的 StealthyFetcher 在 Cloudflare 绕过成功率上远超原生 Playwright 和 Selenium，同时内存占用更低。HTTP 请求器的性能接近纯 httpx，因为底层就是基于 httpx 的。

六、与竞品的深度对比

6.1 Scrapling vs Scrapy

Scrapy 的优势在于其成熟的生态系统和分布式方案，但 Scrapling 在反爬能力和自适应解析上有明显优势。对于新项目，如果不需要复杂的分布式架构，Scrapling 是更好的选择。

6.2 Scrapling vs Playwright/Selenium

Playwright 和 Selenium 是通用的浏览器自动化工具，不是专门的爬虫框架。Scrapling 在它们的基础上增加了反指纹、自适应解析、爬取调度等爬虫专属能力。

6.3 Scrapling vs Crawlee

Crawlee 是 Apify 团队的开源爬虫框架，TypeScript 生态支持较好，但在自适应解析和反爬能力上不如 Scrapling。

七、高级特性与最佳实践

7.1 交互式爬虫开发 Shell

Scrapling 内置了一个基于 IPython 的交互式 Shell，可以极大地加速爬虫开发：

# 启动交互式 Shell
scrapling shell

# 在 Shell 中探索页面
>>> page = fetch('https://example.com')
>>> page.css('h1').text
'Example Domain'
>>> page.css('a').attrib['href']
'https://www.iana.org/domains/reserved'

Shell 还支持将 curl 命令直接转换为 Scrapling 请求：

>>> curl_to_scrapling('curl https://example.com -H "User-Agent: Mozilla/5.0"')

7.2 开发模式（Response Caching）

在开发爬虫的 parse() 逻辑时，你通常需要反复运行爬虫来调试。如果每次都重新请求目标网站，不仅慢，还可能被封 IP。

Scrapling 的开发模式会将第一次请求的响应缓存到磁盘，后续运行直接使用缓存：

class MySpider(Spider):
    name = "dev_spider"
    start_urls = ["https://example.com"]
    dev_mode = True  # 启用开发模式

    async def parse(self, response: Response):
        # 第一次运行：从网络获取并缓存
        # 后续运行：从缓存加载，不发请求
        for item in response.css('.product'):
            yield {'title': item.css('h2::text').get()}

7.3 被封请求检测与自动重试

Scrapling 内置了智能的被封请求检测机制。当检测到请求被反爬系统拦截时，会自动切换策略重试：

class RobustSpider(Spider):
    name = "robust"
    max_retries = 3
    blocked_request_handler = 'auto'  # 自动处理被封请求

    async def on_blocked(self, request, response):
        """自定义被封请求的处理逻辑"""
        # 切换代理
        request.proxy = self.rotator.get_next()
        # 切换会话类型
        request.session_type = 'stealthy'
        # 增加延迟
        request.delay = 5.0
        return request  # 返回修改后的请求进行重试

7.4 广告与追踪器屏蔽

Scrapling 的浏览器请求器内置了约 3,500 个已知的广告和追踪器域名屏蔽列表：

page = StealthyFetcher.fetch(
    'https://example.com',
    headless=True,
    ad_block=True,  # 启用广告屏蔽
)

这不仅减少了不必要的网络请求，还能避免广告脚本干扰数据提取。

八、Docker 部署

Scrapling 提供了开箱即用的 Docker 镜像，包含所有浏览器和依赖：

# Dockerfile
FROM python:3.12-slim

# 安装系统依赖
RUN apt-get update && apt-get install -y \
    wget \
    gnupg \
    && rm -rf /var/lib/apt/lists/*

# 安装 Scrapling
RUN pip install "scrapling[all]"
RUN scrapling install

# 复制项目代码
COPY . /app
WORKDIR /app

CMD ["python", "main.py"]

# docker-compose.yml
version: '3.8'
services:
  spider:
    build: .
    volumes:
      - ./output:/app/output
      - ./cache:/app/cache
    environment:
      - HTTP_PROXY=http://proxy:8080
      - HTTPS_PROXY=http://proxy:8080
    deploy:
      resources:
        limits:
          memory: 2G
          cpus: '2.0'

九、适用场景与局限性

适合使用的场景

1. 电商数据监控：价格追踪、竞品分析、评论采集。自适应解析能力可以应对电商平台频繁的前端改版。
2. 新闻与内容聚合：大规模采集新闻网站、博客、论坛内容。Spider 框架支持高效的并发爬取。
3. AI 训练数据采集：为 LLM 训练采集高质量网页数据。MCP Server 可以与 AI 助手无缝集成。
4. 安全研究：信息收集、漏洞扫描的数据采集阶段。StealthyFetcher 的反指纹能力适合对抗性场景。
5. 市场研究：社交媒体数据、用户行为数据的采集。

局限性

1. 分布式支持有限：目前没有原生的分布式爬取方案，大规模分布式部署需要自行实现。
2. JavaScript 重度依赖的 SPA：对于 React/Vue 等 SPA 应用，虽然 DynamicFetcher 能处理，但性能会下降。
3. 社区生态：相比 Scrapy 的成熟生态，Scrapling 的中间件和扩展还比较少。
4. 学习成本：虽然 API 设计友好，但自适应解析、反指纹等高级特性的调优需要一定的经验。

十、总结与展望

Scrapling 的出现标志着 Python 爬虫框架进入了一个新的阶段。它不是在旧框架上修修补补，而是从解析器、请求器、反爬绕过、爬取调度四个维度重新设计了技术栈。

三个核心创新：

1. 自适应解析器：通过智能元素追踪，让爬虫能自动适应网站结构变化，从「选择器依赖」进化到「特征指纹依赖」。
2. 一体化反爬方案：将 TLS 指纹模拟、Canvas/WebGL/Audio 指纹随机化、Cloudflare Turnstile 绕过等能力内置到框架中，开发者不需要再集成一堆第三方库。
3. AI 原生集成：MCP Server 让 AI 助手可以直接调用爬虫能力，在数据提取前先做精准过滤，大幅降低 Token 消耗。

未来展望：

从 Scrapling 的 ROADMAP 来看，团队正在推进以下方向：

• 分布式爬取：基于消息队列的分布式调度方案
• 更多反爬系统支持：Akamai、DataDome、Kasada 等企业级反爬系统的绕过
• AI 辅助选择器生成：用 LLM 自动分析页面结构并生成最优选择器
• 实时数据管道：与 Kafka、RabbitMQ 等消息系统的原生集成

对于正在寻找「下一代爬虫方案」的开发者来说，Scrapling 值得认真评估。它的 52K+ Stars 不是刷出来的，而是解决了真实痛点之后自然增长的结果。

一句话总结：Scrapling 让爬虫从「写了就会过期」变成了「写了就能一直用」。这可能是 2026 年最值得关注的 Python 开源项目之一。

参考资源

• GitHub 仓库：https://github.com/D4Vinci/Scrapling
• 官方文档：https://scrapling.readthedocs.io
• PyPI：https://pypi.org/project/scrapling/
• Discord 社区：https://discord.gg/EMgGbDceNQ