# HN/Reddit Pain Point Miner (`ianymu/hn-reddit-pain-miner`) Actor

Scrape Hacker News + Reddit for posts where developers complain about AI coding agents (Claude / Cursor / Copilot / Cline). Ranks each post 0-100 by pain signal so founders and PMs get a fast list of validated MVP ideas without manually browsing for hours.

- **URL**: https://apify.com/ianymu/hn-reddit-pain-miner.md
- **Developed by:** [Yanlong Mu](https://apify.com/ianymu) (community)
- **Categories:** AI, Developer tools
- **Stats:** 2 total users, 1 monthly users, 100.0% runs succeeded, NaN bookmarks
- **User rating**: No ratings yet

## Pricing

Pay per usage

This Actor is paid per platform usage. The Actor is free to use, and you only pay for the Apify platform usage, which gets cheaper the higher subscription plan you have.

Learn more: https://docs.apify.com/platform/actors/running/actors-in-store#pay-per-usage

## What's an Apify Actor?

Actors are a software tools running on the Apify platform, for all kinds of web data extraction and automation use cases.
In Batch mode, an Actor accepts a well-defined JSON input, performs an action which can take anything from a few seconds to a few hours,
and optionally produces a well-defined JSON output, datasets with results, or files in key-value store.
In Standby mode, an Actor provides a web server which can be used as a website, API, or an MCP server.
Actors are written with capital "A".

## How to integrate an Actor?

If asked about integration, you help developers integrate Actors into their projects.
You adapt to their stack and deliver integrations that are safe, well-documented, and production-ready.
The best way to integrate Actors is as follows.

In JavaScript/TypeScript projects, use official [JavaScript/TypeScript client](https://docs.apify.com/api/client/js.md):

```bash
npm install apify-client
```

In Python projects, use official [Python client library](https://docs.apify.com/api/client/python.md):

```bash
pip install apify-client
```

In shell scripts, use [Apify CLI](https://docs.apify.com/cli/docs.md):

````bash
# MacOS / Linux
curl -fsSL https://apify.com/install-cli.sh | bash
# Windows
irm https://apify.com/install-cli.ps1 | iex
```bash

In AI frameworks, you might use the [Apify MCP server](https://docs.apify.com/platform/integrations/mcp.md).

If your project is in a different language, use the [REST API](https://docs.apify.com/api/v2.md).

For usage examples, see the [API](#api) section below.

For more details, see Apify documentation as [Markdown index](https://docs.apify.com/llms.txt) and [Markdown full-text](https://docs.apify.com/llms-full.txt).


# README

### What does HN/Reddit Pain Point Miner do?

**HN/Reddit Pain Point Miner** scrapes **Hacker News** (via the public Algolia API) and **Reddit** (via the anonymous JSON API across r/programming, r/MachineLearning, r/LocalLLaMA, r/ClaudeAI, r/ChatGPTCoding, r/aipromptprogramming and any subreddits you add) for posts where developers complain about AI coding agents — Claude Code, Cursor, GitHub Copilot, Cline, Aider, Windsurf, Devin, Replit Agent, v0, ChatGPT, GPT-4/5 and friends. Every post is scored **0-100** by a transparent pain heuristic (keyword match + engagement + recency + product mention) and the dataset is sorted from "loudest complaint" to "background noise" so you can use the top rows as **validated MVP wedge ideas**.

Try it from the Apify Console **Try for free** button at the top of this page, or call it via API, schedule it as a daily cron, and pipe results into Slack / Notion / Linear via Apify's [integrations](https://apify.com/integrations). The platform handles proxy rotation, retries, monitoring, and dataset export for you.

This Actor is part of **Ian Mu's** ([github.com/ianymu](https://github.com/ianymu)) 100-Actor portfolio. It pairs naturally with [claude-verify-before-stop](https://github.com/ianymu/claude-verify-before-stop), the open-source hook that keeps Claude Code from declaring victory on broken builds — both ship the same philosophy: turn vague developer pain into auditable signal.

### Why use HN/Reddit Pain Point Miner?

Manual Reddit/HN browsing is slow and biased toward whatever's on the front page today. This Actor:

- **Saves hours of manual research per idea cycle.** What used to take an afternoon of tab-juggling now takes 60-120 seconds.
- **Validates startup ideas with real complaints, not hypotheses.** Every row is a public post with upvotes and comments — actual humans expressing actual frustration.
- **Surfaces under-the-radar pain.** The scoring rewards *engagement density*, not just upvotes, so high-comment-count "me too" threads with low scores still float to the top.
- **Builds a longitudinal feedback database.** Schedule it weekly; over 6 months you'll see which complaints persist (real product gaps) vs which fade (one-off rants).
- **Feeds product teams, founders, devrel, and content marketers.** Same dataset, three different read patterns: PMs find roadmap items, founders find wedges, devrel finds talking points, marketers find headline hooks.

### How to use HN/Reddit Pain Point Miner to find AI coding agent complaints

1. Click **Try for free** at the top of this page (or hit **Start** if you're already on the Actor page).
2. Open the **Input** tab. Default queries already cover the major AI coding agents — you can leave them as-is.
3. *(Optional)* Adjust **subreddits**, **daysBack** (default 90), or **minScore** (default 30 — raise to 60 for only the loudest pains).
4. Click **Save & Start**. The run takes roughly 1-3 minutes depending on rate-limit waits.
5. Open the **Output** tab when the run finishes — rows are pre-sorted by `painScore` descending. Use the **Export** button to grab JSON / CSV / Excel.
6. *(Optional)* Open the **Key-value store** tab → `pain-digest.md` for a human-readable Markdown digest you can paste into Notion or a weekly review doc.

### Input

The Actor accepts six optional fields (all have sensible defaults — you can hit **Start** with no edits):

```json
{
  "queries": ["claude code", "cursor ai", "github copilot", "ai coding agent", "llm coding"],
  "sources": ["hn", "reddit"],
  "subreddits": ["programming", "MachineLearning", "LocalLLaMA", "ClaudeAI", "ChatGPTCoding", "aipromptprogramming"],
  "maxResultsPerSource": 100,
  "daysBack": 90,
  "minScore": 30
}
````

Open the **Input** tab in Apify Console for an interactive form with descriptions for each field.

### Output

Each row in the dataset represents one pain-point post. You can download the dataset in various formats such as **JSON, HTML, CSV, or Excel**.

```json
{
  "source": "reddit",
  "title": "Claude Code keeps deleting my tests — anyone else?",
  "url": "https://www.reddit.com/r/ClaudeAI/comments/xyz/claude_code_keeps_deleting_my_tests/",
  "author": "frustrated_dev_42",
  "createdAt": "2026-05-12T18:34:00.000Z",
  "score": 184,
  "commentsCount": 76,
  "subredditOrTag": "ClaudeAI",
  "painKeywordsMatched": ["doesn't work", "annoying"],
  "productsMentioned": ["claude code", "claude"],
  "painScore": 90,
  "excerpt": "Every time I run claude code on my Next.js repo it silently strips my Vitest files and replaces them with `// TODO: add tests`. This doesn't work for any serious codebase..."
}
```

A Markdown digest (`pain-digest.md`) is also written to the run's key-value store so you can paste a ranked table straight into a doc.

### Data table

| Field | Type | Description |
|---|---|---|
| `painScore` | number | 0-100 composite signal. Higher = louder, more recent, more agreed-on complaint. |
| `source` | text | `"hn"` (Hacker News) or `"reddit"`. |
| `title` | text | Original post title. |
| `url` | link | Canonical permalink. Click to read the full thread. |
| `author` | text | Original poster's username. |
| `createdAt` | ISO date | Post creation timestamp. |
| `score` | number | Upvotes (HN points or Reddit score). |
| `commentsCount` | number | Number of comments — strong proxy for "me too" agreement. |
| `subredditOrTag` | text | Subreddit name (Reddit) or `"ask_hn"` (HN). |
| `painKeywordsMatched` | array | Which pain words triggered (e.g. `["broken", "frustrating"]`). |
| `productsMentioned` | array | AI tools detected via regex (e.g. `["cursor", "claude code"]`). |
| `excerpt` | text | First 300 chars of the post body or title. |

### Pricing / Cost estimation — how much does it cost to scrape HN + Reddit pain points?

On a typical run with the defaults (5 queries × 6 subreddits + 5 HN queries, ~90-day window), the Actor finishes in **1-3 minutes** of compute time. That fits comfortably inside Apify's **$5/month free tier**, so most users will run it for free. Cost scales linearly with query count and `maxResultsPerSource`; respect the built-in rate limits (1 req/sec to Reddit, 50-call cap on HN Algolia) to keep runs cheap and friendly to the upstream APIs.

### Tips and advanced options

- **Tighten `daysBack` to 14-30** when you want only fresh complaints (e.g. tracking how the community reacts to a recent Claude Code release).
- **Raise `minScore` to 60** for executive-summary mode — fewer rows, only the unambiguous pains.
- **Add niche subreddits** like `LangChain`, `OpenAI`, `Anthropic`, `selfhosted` to widen the funnel.
- **Schedule it weekly.** Open the Actor's **Schedules** tab → cron `0 9 * * 1`. Pipe the dataset into Slack/Notion via Apify integrations to get a Monday-morning pain dashboard.
- **Combine with an LLM step.** Feed the top 20 rows into an Apify [LLM Dataset Processor](https://apify.com/store/categories/ai) Actor to auto-cluster complaints into MVP themes.

### FAQ, disclaimers, and support

**Is this legal?** This Actor only reads **publicly accessible** posts via official endpoints (Algolia HN's open API and Reddit's public JSON endpoints). No login, no scraping past auth walls, no personal data beyond the public username field. Respect [Reddit's content policy](https://www.redditinc.com/policies/content-policy) and [HN's terms](https://news.ycombinator.com/newsguidelines.html) when reusing the data.

**Why are some Reddit results missing?** Reddit's anti-bot occasionally serves HTML instead of JSON for anonymous requests. The Actor detects this and skips gracefully with a warning — re-run a few minutes later and the missing subreddit usually comes back. For 100% coverage, layer Apify's Reddit Scraper or an authenticated proxy on top.

**Why are my queries returning nothing for HN?** HN's Algolia index drops very low-engagement story posts. Broaden the query (e.g. `"claude"` instead of `"claude code"`) or extend `daysBack`.

**Found a bug or want a feature?** Open an issue at the Actor's **Issues** tab in Apify Console, or ping [@ianymu on GitHub](https://github.com/ianymu). Custom builds (e.g. mining a different category — design tools, devops, finance) are available — see [github.com/ianymu](https://github.com/ianymu) for contact.

**Built by Ian Mu.** Part of the [100-Actor portfolio](https://github.com/ianymu) shipping useful Apify Actors for solopreneurs and product teams. MIT-licensed. Cross-link: [claude-verify-before-stop](https://github.com/ianymu/claude-verify-before-stop) — the verify-before-stop hook for Claude Code.

# Actor input Schema

## `queries` (type: `array`):

Search terms used against Hacker News (Algolia) and Reddit. Pick queries that match the product / category you want to mine pain for.

## `sources` (type: `array`):

Which platforms to mine. Allowed values: "hn", "reddit".

## `subreddits` (type: `array`):

Subreddits to search when "reddit" is in sources. Omit r/ prefix.

## `maxResultsPerSource` (type: `integer`):

Per-query hit cap for HN, and per-(subreddit, query) cap for Reddit. Reddit search caps at 100 regardless.

## `daysBack` (type: `integer`):

Only include posts created within this window (days). Older complaints rarely map to current product state.

## `minScore` (type: `integer`):

Filter out rows with painScore below this threshold (0-100). 30 = signal, 60 = strong signal.

## Actor input object example

```json
{
  "queries": [
    "claude code",
    "cursor ai",
    "github copilot",
    "ai coding agent",
    "llm coding"
  ],
  "sources": [
    "hn",
    "reddit"
  ],
  "subreddits": [
    "programming",
    "MachineLearning",
    "LocalLLaMA",
    "ClaudeAI",
    "ChatGPTCoding",
    "aipromptprogramming"
  ],
  "maxResultsPerSource": 100,
  "daysBack": 90,
  "minScore": 30
}
```

# Actor output Schema

## `results` (type: `string`):

No description

# API

You can run this Actor programmatically using our API. Below are code examples in JavaScript, Python, and CLI, as well as the OpenAPI specification and MCP server setup.

## JavaScript example

```javascript
import { ApifyClient } from 'apify-client';

// Initialize the ApifyClient with your Apify API token
// Replace the '<YOUR_API_TOKEN>' with your token
const client = new ApifyClient({
    token: '<YOUR_API_TOKEN>',
});

// Prepare Actor input
const input = {};

// Run the Actor and wait for it to finish
const run = await client.actor("ianymu/hn-reddit-pain-miner").call(input);

// Fetch and print Actor results from the run's dataset (if any)
console.log('Results from dataset');
console.log(`💾 Check your data here: https://console.apify.com/storage/datasets/${run.defaultDatasetId}`);
const { items } = await client.dataset(run.defaultDatasetId).listItems();
items.forEach((item) => {
    console.dir(item);
});

// 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/js/docs

```

## Python example

```python
from apify_client import ApifyClient

# Initialize the ApifyClient with your Apify API token
# Replace '<YOUR_API_TOKEN>' with your token.
client = ApifyClient("<YOUR_API_TOKEN>")

# Prepare the Actor input
run_input = {}

# Run the Actor and wait for it to finish
run = client.actor("ianymu/hn-reddit-pain-miner").call(run_input=run_input)

# Fetch and print Actor results from the run's dataset (if there are any)
print("💾 Check your data here: https://console.apify.com/storage/datasets/" + run["defaultDatasetId"])
for item in client.dataset(run["defaultDatasetId"]).iterate_items():
    print(item)

# 📚 Want to learn more 📖? Go to → https://docs.apify.com/api/client/python/docs/quick-start

```

## CLI example

```bash
echo '{}' |
apify call ianymu/hn-reddit-pain-miner --silent --output-dataset

```

## MCP server setup

```json
{
    "mcpServers": {
        "apify": {
            "command": "npx",
            "args": [
                "mcp-remote",
                "https://mcp.apify.com/?tools=ianymu/hn-reddit-pain-miner",
                "--header",
                "Authorization: Bearer <YOUR_API_TOKEN>"
            ]
        }
    }
}

```

## OpenAPI specification

```json
{
    "openapi": "3.0.1",
    "info": {
        "title": "HN/Reddit Pain Point Miner",
        "description": "Scrape Hacker News + Reddit for posts where developers complain about AI coding agents (Claude / Cursor / Copilot / Cline). Ranks each post 0-100 by pain signal so founders and PMs get a fast list of validated MVP ideas without manually browsing for hours.",
        "version": "0.1",
        "x-build-id": "mEduphojloqVRqbgU"
    },
    "servers": [
        {
            "url": "https://api.apify.com/v2"
        }
    ],
    "paths": {
        "/acts/ianymu~hn-reddit-pain-miner/run-sync-get-dataset-items": {
            "post": {
                "operationId": "run-sync-get-dataset-items-ianymu-hn-reddit-pain-miner",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for its completion, and returns Actor's dataset items in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        },
        "/acts/ianymu~hn-reddit-pain-miner/runs": {
            "post": {
                "operationId": "runs-sync-ianymu-hn-reddit-pain-miner",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor and returns information about the initiated run in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK",
                        "content": {
                            "application/json": {
                                "schema": {
                                    "$ref": "#/components/schemas/runsResponseSchema"
                                }
                            }
                        }
                    }
                }
            }
        },
        "/acts/ianymu~hn-reddit-pain-miner/run-sync": {
            "post": {
                "operationId": "run-sync-ianymu-hn-reddit-pain-miner",
                "x-openai-isConsequential": false,
                "summary": "Executes an Actor, waits for completion, and returns the OUTPUT from Key-value store in response.",
                "tags": [
                    "Run Actor"
                ],
                "requestBody": {
                    "required": true,
                    "content": {
                        "application/json": {
                            "schema": {
                                "$ref": "#/components/schemas/inputSchema"
                            }
                        }
                    }
                },
                "parameters": [
                    {
                        "name": "token",
                        "in": "query",
                        "required": true,
                        "schema": {
                            "type": "string"
                        },
                        "description": "Enter your Apify token here"
                    }
                ],
                "responses": {
                    "200": {
                        "description": "OK"
                    }
                }
            }
        }
    },
    "components": {
        "schemas": {
            "inputSchema": {
                "type": "object",
                "properties": {
                    "queries": {
                        "title": "Search queries",
                        "type": "array",
                        "description": "Search terms used against Hacker News (Algolia) and Reddit. Pick queries that match the product / category you want to mine pain for.",
                        "default": [
                            "claude code",
                            "cursor ai",
                            "github copilot",
                            "ai coding agent",
                            "llm coding"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "sources": {
                        "title": "Sources",
                        "type": "array",
                        "description": "Which platforms to mine. Allowed values: \"hn\", \"reddit\".",
                        "default": [
                            "hn",
                            "reddit"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "subreddits": {
                        "title": "Subreddits (Reddit only)",
                        "type": "array",
                        "description": "Subreddits to search when \"reddit\" is in sources. Omit r/ prefix.",
                        "default": [
                            "programming",
                            "MachineLearning",
                            "LocalLLaMA",
                            "ClaudeAI",
                            "ChatGPTCoding",
                            "aipromptprogramming"
                        ],
                        "items": {
                            "type": "string"
                        }
                    },
                    "maxResultsPerSource": {
                        "title": "Max results per source",
                        "minimum": 10,
                        "maximum": 200,
                        "type": "integer",
                        "description": "Per-query hit cap for HN, and per-(subreddit, query) cap for Reddit. Reddit search caps at 100 regardless.",
                        "default": 100
                    },
                    "daysBack": {
                        "title": "Days back",
                        "minimum": 1,
                        "maximum": 730,
                        "type": "integer",
                        "description": "Only include posts created within this window (days). Older complaints rarely map to current product state.",
                        "default": 90
                    },
                    "minScore": {
                        "title": "Min pain score",
                        "minimum": 0,
                        "maximum": 100,
                        "type": "integer",
                        "description": "Filter out rows with painScore below this threshold (0-100). 30 = signal, 60 = strong signal.",
                        "default": 30
                    }
                }
            },
            "runsResponseSchema": {
                "type": "object",
                "properties": {
                    "data": {
                        "type": "object",
                        "properties": {
                            "id": {
                                "type": "string"
                            },
                            "actId": {
                                "type": "string"
                            },
                            "userId": {
                                "type": "string"
                            },
                            "startedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "finishedAt": {
                                "type": "string",
                                "format": "date-time",
                                "example": "2025-01-08T00:00:00.000Z"
                            },
                            "status": {
                                "type": "string",
                                "example": "READY"
                            },
                            "meta": {
                                "type": "object",
                                "properties": {
                                    "origin": {
                                        "type": "string",
                                        "example": "API"
                                    },
                                    "userAgent": {
                                        "type": "string"
                                    }
                                }
                            },
                            "stats": {
                                "type": "object",
                                "properties": {
                                    "inputBodyLen": {
                                        "type": "integer",
                                        "example": 2000
                                    },
                                    "rebootCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "restartCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "resurrectCount": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "computeUnits": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "options": {
                                "type": "object",
                                "properties": {
                                    "build": {
                                        "type": "string",
                                        "example": "latest"
                                    },
                                    "timeoutSecs": {
                                        "type": "integer",
                                        "example": 300
                                    },
                                    "memoryMbytes": {
                                        "type": "integer",
                                        "example": 1024
                                    },
                                    "diskMbytes": {
                                        "type": "integer",
                                        "example": 2048
                                    }
                                }
                            },
                            "buildId": {
                                "type": "string"
                            },
                            "defaultKeyValueStoreId": {
                                "type": "string"
                            },
                            "defaultDatasetId": {
                                "type": "string"
                            },
                            "defaultRequestQueueId": {
                                "type": "string"
                            },
                            "buildNumber": {
                                "type": "string",
                                "example": "1.0.0"
                            },
                            "containerUrl": {
                                "type": "string"
                            },
                            "usage": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "integer",
                                        "example": 1
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            },
                            "usageTotalUsd": {
                                "type": "number",
                                "example": 0.00005
                            },
                            "usageUsd": {
                                "type": "object",
                                "properties": {
                                    "ACTOR_COMPUTE_UNITS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATASET_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "KEY_VALUE_STORE_WRITES": {
                                        "type": "number",
                                        "example": 0.00005
                                    },
                                    "KEY_VALUE_STORE_LISTS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_READS": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "REQUEST_QUEUE_WRITES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_INTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "DATA_TRANSFER_EXTERNAL_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_RESIDENTIAL_TRANSFER_GBYTES": {
                                        "type": "integer",
                                        "example": 0
                                    },
                                    "PROXY_SERPS": {
                                        "type": "integer",
                                        "example": 0
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
}
```