acceptodds
Under review as a conference paper at ICLR 2027

Generative Curation Yields Bigger and Better Data for Pretraining LLMs

Abstract

Modern large language models (LLMs) are pretrained largely on data curated from the internet. Because of the web's vast scale, pretraining relies on inexpensive curation: heuristic rules and classifiers to extract text from HTML and filter documents. We introduce **Generative Curation with LLMs** (GC-LLM), which replaces both stages with an LLM and a natural language specification of useful training data. The LLM follows the spec to transform raw HTML into training text or discard unsuitable documents. On a fixed pool of Common Crawl data, GC-LLM yields – as many training tokens as DCLM-baseline and Nemotron-CC. Across models with 157M, 1B, & 2.9B parameters and two LM evaluation suites, models pretrained on these tokens achieve –% lower bits per byte (bpb) than those trained on either baseline. To make this approach practical at web scale, we distill GC-LLM into a fast cascade comprising FastText, a 26M-param transformer, and a 68M-param BERT model, which we call **Generative Curation with Cascade** (GC-Cascade). GC-Cascade agrees with the LLM curator on % of filtering decisions and further reduces best observed bpb by –% on 1B and 2.9B models. We use this cascade to begin constructing Atlantic-CC, a projected 20T-token dataset, and release code and models to reproduce our data.

Primary area:
foundation or frontier models, including LLMs
Keywords:
data curation, pretraining, common crawl, large language models, web data, data filtering, data selection

Reviews

Among:
Shape:
1234this paper, Top 30%
Figure 1. Mean review rating of the reviewed papers at ICLR 2027. This paper averages 2.67 over 3 reviews, above 70% of the others.
Reviewer_ePF3OpenReview ↗
Rating
2(+1)
Confidence
4
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper proposes Generative Curation with LLMs (GC-LLM), a pipeline that uses natural-language specifications to select web pages and extract their content as Markdown. The deployed pipeline uses a fine-tuned Qwen3-8B in two stages. It first makes a keep/drop decision from Resiliparse text, then extracts content from script-stripped HTML for the pages it keeps. To reduce the cost of running the 8B model at Common Crawl scale, the authors develop GC-Cascade, which pairs an agent-modified Resiliparse fork with three classifiers trained on the LLM's keep/drop labels. The cascade achieves 0.871 filtering F1 against its teacher at a reported 921× higher throughput. On the DCLM-400M-1x pool, GC-Cascade retains 91.7B tokens, compared with 7.3B for DCLM-baseline and 10.1B for Nemotron-CC. After each corpus is reweighted with Olmix, GC-Cascade achieves 7.5–17% lower best-observed bits per byte (bpb) on the 51-task Olmix suite across three model sizes. The paper also evaluates extraction quality, topic coverage, cross-document repetition, and hallucinations.

Critical strengths
  • The pretraining sweep is substantial. The authors run more than 500 experiments across three model sizes and twelve compute budgets. Using the same AdamH recipe throughout removes per-run optimizer tuning as one explanation for differences between runs. Including unfiltered Resiliparse is also a good choice because it gives readers a direct reference point for assessing whether curation helps.

  • The throughput results make the cascade a practical engineering contribution. I also appreciated the analysis showing that WRAP-style rewriting increases cross-document 4-gram repetition by 1.6–3.3× while spec-based extraction stays close to rule-based extractors. The hallucination audit and the HumanEval fence-stripping caveat make it easier to understand where the pipeline fails.

Critical weaknesses
  1. The main claim and the evaluated pipeline are misaligned. The abstract and Sec. 2 describe a generative transformation that takes raw HTML and handles both selection and extraction. In Sec. 3.2, however, the keep/drop decision is made from text already extracted by Resiliparse. Any content lost at that stage is unavailable to the filter. This matters for the example in Figure 2, which motivates the method in part through content that conventional extraction can miss. The deployed extraction spec also asks for faithful transcription into Markdown. The math-page rewrite shown in Figure 2 is evaluated in the continued-pretraining study in App. J, separately from the main pretraining experiments. Finally, the system that produces the strongest results, GC-Cascade, uses a rule-based extractor and classifiers trained on LLM labels. LLMs contribute to building that system offline. The paper needs to identify what this offline contribution adds beyond the LLM-labeling recipes it already discusses in Sec. 2, and tie that contribution to the reported gains.

  2. The experiments do not identify which part of the pipeline improves pretraining. With Olmix, GC-LLM and unfiltered Resiliparse reach similar minimum validation loss in Figure 1 and similar bpb at the largest budgets shown for 1B and 2.9B in Figure 4. GC-Cascade, meanwhile, outperforms GC-LLM by 5.0–7.3% in best-observed bpb at those two sizes. The teacher-to-cascade comparison changes both the retained documents and their extracted text. The cascade keeps 91.7B tokens versus 111.3B for its teacher, and the fork has fewer audited hallucinations than the Qwen extractor. Either difference could matter, and the two may interact. The stricter single-spec corpus in App. I is competitive at small and moderate budgets, which gives another reason to investigate the retained subset, although that experiment changes multiple factors. A crossed filter-by-extractor ablation is needed to attribute the cascade's gains. A matched-size comparison against a filter trained on an existing quality signal would also help establish whether the LLM labels themselves add value.

  3. The headline comparison combines corpus quality, corpus size, and deduplication. The headline reports each corpus's best observed bpb across budgets. GC-Cascade has far more unique tokens available, so this comparison captures how well a larger corpus can sustain training as the smaller corpora start to repeat. At budgets below 7.3B tokens, the GC-Cascade and DCLM-baseline curves in Figure 4 are close across all three model sizes. The larger gaps appear mainly at higher budgets, where differences in repeated exposure become important. There is also a construction asymmetry in Sec. 5.1.2. The GC corpora and unfiltered Resiliparse are deduplicated inside the experimental WARC pool, while DCLM-baseline and Nemotron-CC are slices of releases deduplicated over a larger pool. A page may be absent from a baseline slice because its retained duplicate lies outside the sampled WARCs. The paper does not quantify this effect. A comparison with the same source pool, deduplication scope, unique-token count, and training budget would make it possible to assess data quality separately from the amount of data available.

  4. Olmix makes it hard to tell what the curator contributes and how well the result generalizes. Every corpus is reweighted over topic and external quality bins, and the mixtures are optimized for the same 51-task suite used for the headline comparison. Applying the same procedure to all corpora is reasonable if the goal is to compare the best mixture each pool can produce. It does not establish that permissive curation helps independently of the quality signal used to construct those mixtures. Olmix can upweight high-scoring documents from a lightly filtered pool, so part of the selection is happening at the mixing stage. App. K is relevant here because its experiments without Olmix favor the stricter spec in the fitted compute-optimal regime, although they use older specs and cannot settle the question for the deployed system. Uncheatable Eval is a useful independent outcome, but it still evaluates models trained on the quality-binned mixtures. I would like to see the main comparison on the corpora's natural distributions and an intermediate condition that mixes by topic alone.

  5. The extraction evidence is too weak for the claims made about extraction quality. On WebMainBench, the human-annotated benchmark in Table 2, the GC extractors score 0.646–0.708 F1 versus 0.900 for MinerU-HTML. MinerU-HTML's co-development with the benchmark is a reasonable caveat. The gap still needs analysis because it appears in both precision and recall. In particular, the paper should show whether the lower recall comes from different definitions of main content or from missing text that the method also intends to keep. The in-house devset is closer to the authors' intended output, but its gold extractions are LLM-produced and some of its categories explicitly reward content requested by the extraction spec, such as comment attributions. Even there, the deployed Qwen extractor scores 0.805 F1 versus 0.817 for vanilla Resiliparse and 0.815 for MinerU-HTML. The fork reaches 0.828, with no uncertainty intervals reported for these differences. The stronger GLM-5.3 result demonstrates what another extractor can achieve on this devset. Its relevance to the training corpora is limited because it did not build them. Table 1 also excludes a substantial share of examples that exceed 32k tokens, leaving a gap in the model-selection evidence for the long pages that require chunking in deployment.

  6. The cost comparison omits work needed to build the deployed pipeline. The reported 5.3e21 FLOPs for GC-Cascade describes the cost of running the cascade. The pipeline also requires labeling with the 8B teacher, training the classifiers, and developing the extractor through 179 agent cycles. The pretraining results rely on an additional mixture search. From the numbers in App. F, the 363 proxy runs at 3e18 FLOPs each total about 1.1e21 FLOPs per corpus, before document-level topic and quality scoring. Reporting build, inference, and mixture-search costs separately would let readers see which costs are incurred once and which recur when the corpus or specification changes. The paper should also reconcile Figure 1's operation order with Sec. 4's description of the text-input FastText classifier, since the order determines how many pages incur extraction cost.

  7. The paper has not demonstrated spec-level controllability for the cascade. A natural-language spec is an appealing interface for GC-LLM. GC-Cascade approximates a fixed spec using trained classifiers and a rule-based extractor. A change to the filtering policy may require relabeling and classifier retraining, while a change to extraction may require modifying the fork. The paper does not show how much of that work is required for a realistic spec change or whether the rebuilt cascade follows the new spec. Since the scalable system is the one most users would run, controllability should be evaluated there. One targeted edit, with an evaluation of both the intended behavior change and the effect on unrelated pages, would make this claim much easier to assess.

Questions for authors
  1. At 1B, can you cross the Qwen and cascade filters with the Qwen and fork extractors under the same mixing procedure and matched training budgets? For each filter, can the two extractor runs use identical document IDs? Can you also compare the LLM-derived filter against an existing quality-score filter at the same retention rate?

  2. Can you rerun DCLM-baseline on the same WARC pool under the same deduplication scope, then compare at matched unique-token counts and training budgets? If rerunning the baseline is infeasible, can you estimate how many documents the release slice loses because the retained copy lies outside the pool and report the actual repeated-token fraction at each budget?

  3. How do the main corpora compare under their natural distributions, topic-only mixing, and topic-plus-quality mixing? Can you report all three conditions on an evaluation suite excluded from mixture fitting?

  4. Can you break down the WebMainBench precision and recall gaps by error type? Which prompt produced the in-house gold extractions, and why does Sec. 6.1 evaluate 412 pages when Sec. 3.3 and the AI-use statement mention 420?

  5. What is included in the 5.3e21 FLOPs estimate? In the deployed system, which text does FastText see, which input does the pooled transformer use, and how many pages pass through the fork?

  6. Can you demonstrate one realistic spec change, such as retaining more substantive forum replies, and report the relabeling and retraining required, how often the desired decision changes, and how often unrelated decisions change?

  7. Can you make Figure 1 and the abstract explicit about the systems used for the main pretraining results and indicate where the Figure 2 rewrite example was actually evaluated?

4 comments
AuthorsOpenReview ↗

Response to Reviewer ePF3 (1/2)

Thank you for taking the time to review our paper. We appreciate your recognition of the extensiveness of our experiments and the engineering contribution of our GC-Cascade. We will address your comments in order:

W1. Evaluated pipeline misaligned. We adjusted our Figure 1 to make it clearer that we are discussing an LLM as part of a harness. Figure 2 was an accurate representation of how our system performed on those pages, taken verbatim from the outputs, so we did not run into the same problems as DCLM; however, we recognize that it is confusing that we showed the spec for Appendix J in Figure 2, so we modified the figure to showcase one filtering failure and one extraction failure and to only use our main paper spec. We were very upfront about our system in Section 3.2, and we hope the clearer Figure 1 and Figure 2 address your concern.

W2. A crossed filter-by-extractor ablation is needed. We provide this experiment in Appendix J, “Data Curation Ablations”. Our summarized finding is that both filtering and extraction matter for GC-Cascade outperforming baselines, but GC-Cascade wins over GC-LLM due to extraction. This appears consistent with findings that GC-Cascade avoids extraction errors.

W3. A comparison with the same source pool, deduplication scope, unique-token count, and training budget. We primarily address this in the shared response, but we ran this experiment and included the results in Appendix H, “Impact of Data Mixing.” As we discussed in the shared response, this has not significantly impacted scores, but we agree it is a more sound way to run our evals, so when everything is complete in about a week, we will update it for the camera-ready version.

W4. Olmix makes it hard to tell what the curator contributes. We address this with Appendix H, “Impact of Data Mixing,” and find that without any mixing, our data remains the best even at matched unique tokens and compute. However, as we discussed with reviewer cZRK, we stand by our evaluation setting. Downstream, when training models, it is standard practice to mix data [1][2]. Other papers argue that you should filter your data far less than current pretraining data curation methods dictate [3][4]. For far too long, pretraining data curation filtering has overstepped and tried to support what should be the role of data mixing. It is great for most evals to filter out literature in favor of more code/math data, but this is not a tradeoff you want to make if you want your pretraining data to be useful for both training models good at coding and good at creative writing. We stand by this evaluation setting because it is faithful to how models should be trained and the true purpose of pretraining data curation. Data filtering should not assume the role of data mixing, and we hope more researchers will follow this lead.

W5. Cannot claim better extraction. We ran an error analysis on WebMainBench to break down where the precision and recall gap between our LLM extractors and MinerU-HTML comes from.

We used Gemini 3.8 Flash to label extraction gaps using a 14-category codebook (page furniture, metadata, main text, text not on the page, etc.). We validated Gemini against blind labels from Opus 5.5 with 95.6% agreement on held-out spans. The recall gap is almost entirely formatting. For Qwen3-8B Distill (the GC-LLM extractor), formatting is 16.4 of the 19.2 points, and it is 76–94% of the gap across our extractors. The precision gap is part formatting and part extra text. Formatting is 10.1 of the 27.9 points for Qwen3-8B Distill. Of the extra text, page furniture (menus, footers, related links) is 10.4 points for the 8B model and about 4 for the larger models. Metadata is another 3–5 points, including the "Author -- date" line on every post, which our spec requires and WebMainBench excludes. Text with no basis on the page is under 0.3 points.

If we score on words only (ROUGE-1, dropping whitespace, punctuation and markdown marks), GLM-5.3 and Qwen3-8B Distill match MinerU-HTML on recall:

SystemROUGE-5 F1 (Table 2)ROUGE-1 PROUGE-1 RROUGE-1 F1
MinerU-HTML0.9000.9120.9600.917
GLM-5.30.7080.8450.9610.873
GPT-OSS-120B0.6580.8390.9340.855
Qwen3-8B Distill0.6460.7810.9550.822

GLM-5.3's F1 gap shrinks from 19.2 to 4.4 points. The remaining gap is primarily the metadata and spec differences described above.

AuthorsOpenReview ↗

Response to Reviewer ePF3 (2/2)

W6. The cost comparison omits work needed to build the deployed pipeline. We include a more thorough breakdown of costs in Appendix F, “Compute Cost”; however, it is worth noting that building GC-Cascade costs about 4E+22 FLOPs, and because the fine-tuned Qwen3-8B can be reused, rebuilding it for a new spec costs about 8E+21 FLOPs, comparable to running it on the full Common Crawl. We updated this throughout the draft and the limitations section to clarify the cost.

W6.1. The paper should also reconcile Figure 1's operation order with Sec. 4's description of the text-input FastText classifier, since the order determines how many pages incur extraction cost. The order in Section 4 and Figure 1 has always matched. Text extraction comes before FastText, Pooled Transformer, and ModernBERT. Please clarify if anything remains confusing.

W7. The paper has not demonstrated spec-level controllability for the cascade. Although we don’t rerun distillation for GC-Cascade, we do show several examples of swapping the spec for GC-LLM throughout the Appendix (we offer more than 5 different spec ablations). Even though we haven’t distilled this into GC-Cascade, there is no indication that this wouldn’t work for other specs. We prioritized other experiments because the confidence that this would work is quite high, but can consider running this as other higher-priority experiments conclude.

Q1. At 1B, can you cross the Qwen and cascade filters with the Qwen and fork extractors under the same mixing procedure and matched training budgets? Yes! We ran this experiment and included it in Appendix J. The filtering and extraction both help, but extraction is what sets GC-Cascade and GC-LLM apart.

Q2. Can you rerun DCLM-baseline on the same WARC pool under the same deduplication scope, then compare at matched unique-token counts and training budgets? Done! We address this in the shared response, but the difference in tokens was minimal: 7.3B -> 9.5B tokens, with very minor shifts in eval results. We agree that this is the version that should be reported in the camera-ready version.

Q3. How do the main corpora compare under their natural distributions? We report this in Appendix H. At matched unique tokens and compute budgets under natural mixes, our GC-Cascade is still the best data available, but in this setting it is tied with DCLM.

Q4. Can you break down the WebMainBench precision and recall gaps by error type? Yes, see the above analysis for W5! The 420 vs 412 gap is because we removed documents that Miner-U-HTML produced empty extractions, but we will update our AI-Use statement to address this.

Q5. What is included in the 5.3e21 FLOPs estimate? In the deployed system, which text does FastText see, which input does the pooled transformer use, and how many pages pass through the fork? The 5.3e21 FLOPs estimate is based on running on the Common Crawl; however, we added Appendix F with detailed cost calculations. To your second point, FastText and PooledTransformer both use the extracted text, so every page runs through the fork.

Q6. Can you demonstrate one realistic spec change? We show this in the appendix with our Budget Aware Curation, where we modify the definition of what quality documents look like. We chose not to run this with the cascade to save compute for higher-priority experiments; however, adapting to a new spec is on the order of 8E+21 FLOPs, and training the classifiers alone is under 1E+20 FLOPs.

Q7. Can you make Figure 1 and the abstract explicit about the systems used for the main pretraining results and indicate where the Figure 2 rewrite example was actually evaluated? We redesigned Figure 1 to make it clear that we are using a Harness with the LLM, and we updated Figure 2 with only the main paper examples. Please let us know if anything here is unclear.

Thanks for your helpful comments!

References
[1] Will Held. Curating 25 Trillion Tokens for LLM Pretraining. Open Athena Blog, 2026. https://www.openathena.ai/blog/marin-data-pipeline-overview/
[2] Aaron Grattafiori et al. The Llama 3 Herd of Models. arXiv:2407.21783, 2024.
[3] Christopher Mohri, John Duchi, and Tatsunori Hashimoto. A Bitter Lesson for Data Filtering. arXiv:2605.19407, 2026.
[4] Sachin Goyal, Pratyush Maini, Zachary C. Lipton, Aditi Raghunathan, and J. Zico Kolter. Scaling Laws for Data Filtering—Data Curation Cannot be Compute Agnostic. CVPR 2024.

Thank you for the detailed rebuttal and additional experiments. I appreciate that several of my concerns have been addressed. However, the performance advantage remains less convincing under matched data and compute conditions, and the spec-level controllability of GC-Cascade has not been demonstrated. I also remain concerned about the distinct contribution of LLM-based curation over existing approaches. Considering the additional evidence, I have decided to raise my rating to 2, although my main concerns remain.

Thank you for your feedback. We appreciate your acknowledgment that we addressed several of your concerns and your corresponding score adjustment.

We maintain that the data mixed setting is the correct way to compare the datasets (due to matching the deployment setting of these datasets), so we are undeterred that the performance improvements are less pronounced (yet still present!) in the unmixed setting. However, we understand how this can be a point of contention given the departure from traditional dataset evaluation and will keep the unmixed results in the appendix.

We greatly appreciate your time and suggestions that made our paper better!

Reviewer_cZRKOpenReview ↗
Rating
2
Confidence
4
Informativeness
2
Presentation
2
Soundness
1
Read review
Paper summary

The paper proposes Generative Curation with LLMs (GC-LLM): a fine-tuned Qwen3-8B, given a natural-language spec, decides whether to keep a web page and writes kept pages out as Markdown. As deployed (Sec. 3.2), this runs in two stages: a filter spec judges the page's Resiliparse plain text with reasoning on, and an extraction spec transcribes the script-stripped HTML in 18k-token chunks with reasoning off, wrapped in four repair guardrails. Because running the 8B model over all of Common Crawl is estimated at 1.78e26 FLOPs, the authors distill it into GC-Cascade: an agent-modified Rust fork of Resiliparse for extraction, plus a FastText / 25.9M pooled transformer / 68M Ettin cascade trained on GC-LLM's keep/drop labels (0.871 F1 agreement at 921× throughput). On the DCLM-400M-1x pool, GC-LLM and GC-Cascade keep 111.3B and 91.7B tokens, versus 7.3B for DCLM-baseline and 10.1B for Nemotron-CC. After every corpus is reweighted with Olmix, models at 157M, 1B and 2.9B trained on GC-Cascade reach 7.5–17% lower best-observed bpb on the 51-task Olmix suite than the baselines. Sec. 6 adds extraction benchmarks (WebMainBench and an LLM-labelled devset), topic coverage, a self-repetition analysis and a hallucination audit.

Critical strengths
  1. 500+ runs over three model sizes and twelve compute budgets, all using one closed-form AdamH recipe with no per-run tuning (App. G), so at a given size and budget the differences come from the data and its mixture. The paper is also open about negative findings, e.g. the hallucination audit (Table 4) and the HumanEval fence-stripping caveat (App. J).

  2. The pooled transformer (3,932 docs/s/chip at 8k context, Table 6) and the resulting cascade at 921× the throughput of the 8B system; the self-repetition comparison showing that WRAP-style rephrasing raises cross-document 4-gram repetition by 1.6–3.3× while spec-based extraction stays close to rule-based extractors (Table 3); and the over-epoching term added to the data-constrained scaling law (App. K).

Critical weaknesses

My recommendation rests mainly on points 1–3; points 4 and 5 are additional concerns.

  1. What is deployed is not the generative curation the paper describes. The abstract and Sec. 2 present a single LLM transformation from raw HTML to training text that replaces both extraction and filtering. The deployed system splits this into two specs (the single-call design appears only in App. I and K) and differs from the description in three ways. (a) GC-LLM's filter judges the page's Resiliparse text (Sec. 3.2, App. D.1), the same extractor DCLM uses (Sec. 5.1.1). Content that Resiliparse drops, which is the kind of loss Figure 2 (left) attributes to DCLM's extraction, is therefore invisible to the keep/drop decision. (b) The extraction spec asks only for transcription ("Think of it as retyping the page's own writing in markdown ... nothing gets invented", App. D.1), and Sec. 6.3 credits the method precisely for not rewriting. The question/reasoning/answer rewrite shown for the math page in Figure 2 is used only in the continued-pretraining study of App. J, not in Sec. 5. (c) GC-Cascade, which gives the best results and is the only variant that scales to Common Crawl, has no generative component. The paper calls its extractor a "rule-based program" (Sec. 4) and lists it under rule-based extraction in Table 4; the filter is three discriminative classifiers trained on LLM labels, which is the recipe the paper attributes to Phi-1, FineWeb-Edu and QuRating in Sec. 2. Figure 1 does not match either: the caption says GC-Cascade performs "the whole process with models", and the diagram puts FastText and the 26M filter before text extraction, while Sec. 4 says the deployed FastText classifier is trained for text input. As I read it, the contribution is distilling the keep/drop labels of a permissive LLM filter into a classifier cascade, plus an agent-tuned Resiliparse. That can be useful, but it is a scale-up of an existing recipe rather than the new approach the title and abstract describe.

  2. The paper does not show that the LLM curator itself is what helps. Under the same mixing, GC-LLM does not clearly beat doing no curation at all: in Figure 1 (right), GC-LLM and unfiltered Resiliparse reach nearly the same minimum validation loss (both about 2.6), and in Figure 4 their curves end at about the same bpb at 1B and 2.9B. Where DCLM-baseline is not yet repeated (below 7.3B tokens), GC-LLM is at or above it in Figure 4, and Sec. 5.2 notes that GC-LLM "requires larger-scale budgets to outperform DCLM". The gains come from GC-Cascade, which beats its own teacher by 5.0–7.3% in best-observed bpb at 1B and 2.9B (abstract) and lies below GC-LLM at every budget at those two sizes, although it agrees with the teacher only at 0.729 ROUGE-5 F1 on extraction and 0.871 F1 on filtering. The paper does not analyze why. The obvious candidates all move credit away from LLM generation. Either the fork avoids LLM extraction errors (Table 4: pages with at least one major / medium / minor hallucination go from 1.6% / 5.4% / 8.5% for Qwen3-8B Distill to 0.1% / 3.1% / 1.7% for the fork), or the cascade keeps a different, smaller subset (91.7B vs. 111.3B tokens). The second reading fits App. I, where a much stricter single-spec corpus of 21.3B tokens is on par with GC-Cascade and better than GC-LLM at small and moderate budgets (I take the authors' point that App. I is not a controlled comparison). Without a 2×2 ablation of filter (LLM vs. cascade) by extractor (Qwen3-8B vs. fork), the paper cannot say which part of its pipeline produces its best numbers.

  3. The pretraining comparison does not isolate curation quality.

(a) Bigger vs. better. The headline compares each corpus's best observed bpb across budgets, so a corpus with more unique tokens gets to train longer. Below 7.3B tokens, the GC-Cascade and DCLM-baseline curves in Figure 4 nearly overlap at all three sizes; the gap opens mainly after the baselines start repeating data in a pool the authors deliberately shrank (Sec. 5.1.3). The experiments support "bigger" much more than "better" per token.

(b) Mixing does part of the filtering. Every corpus is reweighted over 24 topics × 5 bins of an external quality score (Held, 2026b), and the mixture is fit to the same 51-task suite that Figure 4 reports (App. F; the caption says the mixes are "tuned for Olmix evals"). With quality bins to reweight, a large, lightly filtered pool can recover much of what an aggressive filter does. The unfiltered Resiliparse pool, for example, beats DCLM-baseline in all three MMLU domains in Figure 5 (−1.74 / −2.02 / −1.84 vs. −1.88 / −2.19 / −1.96). In the other direction, App. K trains without Olmix (with older single-call specs), and its fitted law prefers the strict HQ spec along the Chinchilla-optimal line (point estimate up to 10T parameters; more than 95% of bootstrap resamples up to 10B). So the case for permissive curation seems to depend on the mixing step. Uncheatable Eval (Figure 7) is outside the mixing objective, which helps, but it uses the same quality-binned mixtures.

(c) Deduplication is asymmetric (Sec. 5.1.2). GC-LLM, GC-Cascade and Resiliparse are deduplicated within the 10,364-WARC pool, while the baselines are slices of releases that their own pipelines deduplicated over far more WARCs. A document whose retained copy lies outside the pool is missing from the baseline slice but kept in the GC corpora. This lowers the baselines' unique-token counts by an amount the paper does not report, and pushes them into the repetition regime earlier, which is where the headline gains appear.

  1. The extraction evaluation does not support "better extraction" (Sec. 6.1). On WebMainBench, the only human-annotated benchmark in Table 2, the GC extractors score 0.646–0.708 F1 against 0.900 for MinerU-HTML. Precision is the weakest part: 0.614 for Qwen3-8B Distill and 0.663 for the fork, vs. 0.893. These extractors keep a lot of text that annotators did not mark as main content, and in a pretraining corpus that text is boilerplate. Recall is also 15–19 points lower (0.753 / 0.795 vs. 0.945). The paper explains the gap in one sentence: MinerU-HTML "was developed alongside WebMainBench and thus makes similar decisions on edge cases". Co-development is a fair caveat, but a 20–25 point F1 gap that shows up in both precision and recall needs an error analysis, not an assertion.

The in-house devset cannot fill this role. Its gold extractions were produced by three LLMs with Opus 4.8 adjudicating (Sec. 3.3), and its target-content columns were picked by the authors. The Attr column rewards keeping comment-thread attributions, which the extraction spec requires (every post "starts with Author -- date") and which extractors built around a narrower definition of main content tend to drop (MinerU-HTML 0.362, Trafilatura 0.398). Even on this set, the deployed GC-LLM extractor is not better than vanilla Resiliparse or MinerU-HTML on F1 (0.805 vs. 0.817 / 0.815); the fork reaches 0.828, and all four are within 2.3 points with no confidence intervals reported. The caption's claim that "Generative curation leads every devset column" holds only because GLM-5.3 is in the table, and GLM-5.3 was not used to build any corpus; without it, Trafilatura has the highest devset precision (0.847). The fork that GC-Cascade actually uses also has spacing errors on 17.8% of pages, more than vanilla Resiliparse (13.6%) or Trafilatura (11.5%) (Table 4). Finally, Table 1, the basis for choosing the 8B model, leaves out the learned extractors discussed in Sec. 2 and drops the 31% / 49% of test items that do not fit in 32k tokens.

  1. Cost is under-reported, and the controllability argument does not survive distillation. By the paper's own estimate, GC-LLM over Common Crawl would cost 1.78e26 FLOPs, about half of GPT-4.5's pretraining compute, so the practical system is the cascade. Its 5.3e21 FLOPs figure covers running it, not building it: running the 8B two-spec system over ~400M pages for labels (3.05 model calls per kept page on average), training on up to ~89M labeled pages (Table 7), 179 agent cycles on the extractor, and the mixing step that permissive curation relies on (363 proxy runs per corpus at 3e18 FLOPs each, i.e. about 1.1e21 FLOPs from the numbers in App. F, plus topic and quality scoring of every kept document). More importantly, the main selling point, curation controlled by a readable spec "rather than rules spread across code and classifier weights" (Sec. 7), does not carry over. The cascade approximates "a fixed specification" (Sec. 2). Changing the spec would mean relabeling with the 8B model, retraining three classifiers and re-running the agent loop, after which the behavior again lives in code and classifier weights. Together with point 1, what is new here is mostly the scale of LLM labeling and the agent-tuned extractor, not a cheaper or more controllable way to curate.
Questions for authors
  1. Can you run a 2×2 ablation at 1B, crossing the filter (Qwen3-8B vs. cascade) with the extractor (Qwen3-8B vs. the Resiliparse fork), under the same mixing? This is the most direct test of where GC-Cascade's advantage over GC-LLM comes from. Optionally, adding the strongest WebMainBench extractor in Table 2 as a third extractor would show whether extraction quality matters for pretraining here.

  2. How do GC-LLM, GC-Cascade, Resiliparse and DCLM-baseline compare at matched budgets when trained on their natural distributions, without Olmix and without the Held (2026b) quality bins? An accuracy-based evaluation next to bpb (for example the DCLM CORE tasks you already decontaminate against) would also help.

  3. Can you put the baselines on equal footing for deduplication, e.g. by re-running the DCLM-baseline filters on the pool with your within-pool deduplication, or at least report how many GC-Cascade documents have near-duplicates outside the pool?

  4. How is the 5.3e21 FLOPs figure computed, and what is the end-to-end cost including labeling, classifier training, the agent loop and mixing? Does the fork run on every page before FastText, as "for text input" in Sec. 4 implies, rather than after it as drawn in Figure 1? Which input does the deployed pooled transformer use?

  5. Which prompt produced the devset gold extractions: your extraction spec or something else? Can you break down the WebMainBench gap, including the recall gap? Sec. 3.3 and the AI-use statement mention 420 gold pages, while Sec. 6.1 uses 412; what happened to the other 8?

2 comments
AuthorsOpenReview ↗

Response to Reviewer cZRK (1/2)

Thank you for taking the time to review our paper. We are glad you found our experimental design with 500+ runs convincing and the numerous contributions from the pooled transformer to the efficient cascade for pretraining significant.

We will address your weaknesses and questions directly.

W1. What is deployed is different from what is described. We acknowledge that we can clarify our writing here. Because the length of raw HTML webpages exceeds the token limit of our Qwen3 8B model, we had to split the LLM extraction into multiple calls over page chunks for GC-LLM, and we separated the filtering and extraction steps. We are upfront about this in section 3.2; however, we recognize that Figure 1 can look overly simple. To address this, we have made two edits in the attached draft:

  1. Figure 1 now makes it clear that GC-LLM uses the LLM in a Harness rather than a single call
  2. We added Figure 7 to the appendix, which presents the full LLM Harness in the same style as Figure 1.

To your point about GC-Cascade (our main contribution) - “the diagram puts FastText and the 26M filter before text extraction” - this is untrue, both in our original draft and updated copy. Figure 1 shows text extraction before FastText and all filters, consistent with section four. Please clarify whether anything in the figure is confusing.

We recognize your concern that Figure 2 shows a spec from the appendix, so we updated Figure 2 to show only an accurate representation of what we did in the main text (main spec and exact outputs).

W2. “Without a 2×2 ablation of filter (LLM vs. cascade) by extractor (Qwen3-8B vs. fork), the paper cannot say which part of its pipeline produces its best numbers.” Thank you for this suggestion. We ran this experiment and included results in Appendix J, “Data Curation Ablations”. Our summarized finding is that both filtering and extraction matter for GC-Cascade outperforming baselines, but GC-Cascade wins over GC-LLM due to extraction. This appears consistent with findings that GC-Cascade avoids extraction errors.

W3. Cannot isolate curation quality. We will respond directly to each of your points here:

  • Bigger vs. Better. We added natural-mix ablations (no olmix) to Appendix H, “impact of Data Mixing.” Our finding is that the gap is very small with DCLM; however, against all baselines, our data remains better even before any datasets need to epoch. This supports the claim that our data is bigger and better.
  • Mixing does part of the filtering. Our natural mix experiment (Appendix H) addresses this; however, we’d like to also take this opportunity to point out that we believe this is the correct way to evaluate pretraining data. Downstream, when training models, it is standard practice to mix data [1][2]. Other papers argue that you should filter your data far less than current pretraining data curation methods dictate [3][4]. For too long, pretraining data curation filtering has overstepped and tried to support what should be the role of data mixing. It is great for most evals to filter out literature in favor of more code/math data, but this is not a tradeoff you want to make if you want your pretraining data to be useful for both training models good at coding and good at creative writing. We stand by this evaluation setting because it is faithful to how models should be trained and the true purpose for pretraining data curation. Data filtering should not assume the role of data mixing, and we hope more researchers will follow this lead.
  • Deduplication is asymmetric. Thank you for pointing this out. We address this in the shared response, but this is a good point. We reproduced DCLM, Nemotron-CC, Fineweb, and Fineweb-edu on the same deduplication pool and found that this did not significantly impact results; however, in our camera-ready draft, we will include a fairer comparison to the baselines.
AuthorsOpenReview ↗

Response to Reviewer cZRK (2/2)

W4. The extraction evaluation does not support "better extraction". We ran an error analysis on WebMainBench to break down where the precision and recall gap between our LLM extractors and MinerU-HTML comes from.

We used Gemini 3.8 Flash to label extraction gaps using a 14-category codebook (page furniture, metadata, main text, text not on the page, etc.). We validated Gemini against blind labels from Opus 5.5 with 95.6% agreement on held-out spans. The recall gap is almost entirely formatting. For Qwen3-8B Distill (the GC-LLM extractor), formatting accounts for 16.4 of the 19.2 points, and it makes up 76–94% of the gap across our extractors. The precision gap is part formatting and part extra text. Formatting is 10.1 of the 27.9 points for Qwen3-8B Distill. Of the extra text, page furniture (menus, footers, related links) is 10.4 points for the 8B model and about 4 points for the larger models. Metadata is another 3–5 points, including the "Author -- date" line on every post, which our spec requires and WebMainBench excludes. Text with no basis on the page is under 0.3 points.

If we score on words only (ROUGE-1, dropping whitespace, punctuation, and markdown marks), GLM-5.3 and Qwen3-8B Distill match MinerU-HTML on recall:

SystemROUGE-5 F1 (Table 2)ROUGE-1 PROUGE-1 RROUGE-1 F1
MinerU-HTML0.9000.9120.9600.917
GLM-5.30.7080.8450.9610.873
GPT-OSS-120B0.6580.8390.9340.855
Qwen3-8B Distill0.6460.7810.9550.822

GLM-5.3's F1 gap shrinks from 19.2 to 4.4 points. The remaining gap is primarily the metadata and spec differences described above.

W5. Cost. We include a cost analysis in Appendix F, “Compute Cost”. The key takeaway is that rebuilding GC-Cascade for a new spec would cost only about 8E+21 FLOPs, since it reuses our fine-tuned Qwen3-8B. This is similar to the cost of running GC-Cascade on the Common Crawl. It remains over 20,000x cheaper than running GC-LLM on the full Common Crawl. We have updated the writing to be clearer; however, we disagree with the characterization that “the controllability argument does not survive distillation”.

Q1. Can you run a 2×2 ablation at 1B, crossing the filter (Qwen3-8B vs. cascade) with the extractor (Qwen3-8B vs. the Resiliparse fork), under the same mixing? Done! See discussion above and Appendix J.

Q2. How do GC-LLM, GC-Cascade, Resiliparse, and the DCLM baseline compare at matched budgets when trained on their natural distributions? See W3 discussion above, but we still outperform the baselines. See Appendix H.

Q3. Can you put the baselines on equal footing for deduplication? Yes! See the shared response. We have run the first wave of experiments, and the results have not changed, but we will update this for the camera-ready version.

Q4.1 How is the 5.3e21 FLOPs figure computed? This was the cost to run GC-Cascade on Common Crawl, but we also added the cost of building it (about 4E+22 FLOPs) and rebuilding it for a new spec (about 8E+21 FLOPs), and we expanded on this in Appendix F.

Q4.2 Does the fork run on every page before FastText, as "for text input" in Sec. 4 implies, rather than after it as drawn in Figure 1? Yes! Figure 1 and Section 4 are consistent, so please clarify if this is confusing. The text extractor fork always runs before FastText, Pooled Transformer, and ModernBERT.

Q5. Sec. 3.3 and the AI-use statement mention 420 gold pages, while Sec. 6.1 uses 412; what happened to the other 8? Table 2 scores the 412 pages where every extractor in our original comparison returned non-empty output. Our initial MinerU-HTML run returned nothing on those pages, so we removed them to keep the comparison fair. To avoid confusion, we have just reduced our AI-Use statement to 412 to match. Thank you for catching this.

References
[1] Will Held. Curating 25 Trillion Tokens for LLM Pretraining. Open Athena Blog, 2026. https://www.openathena.ai/blog/marin-data-pipeline-overview/
[2] Aaron Grattafiori et al. The Llama 3 Herd of Models. arXiv:2407.21783, 2024.
[3] Christopher Mohri, John Duchi, and Tatsunori Hashimoto. A Bitter Lesson for Data Filtering. arXiv:2605.19407, 2026.
[4] Sachin Goyal, Pratyush Maini, Zachary C. Lipton, Aditi Raghunathan, and J. Zico Kolter. Scaling Laws for Data Filtering—Data Curation Cannot be Compute Agnostic. CVPR 2024.

Reviewer_ARPnOpenReview ↗
Rating
4
Confidence
3
Informativeness
3
Presentation
3
Soundness
3
Read review
Paper summary

This paper proposes Generative Curation, an LLM-based approach to constructing pretraining corpora from raw web data. GC-LLM uses natural-language specifications to guide content filtering and HTML-to-text extraction, replacing conventional heuristic-based pipelines with context-aware decisions. To enable web-scale processing, the authors distill the LLM-based pipeline into GC-Cascade, combining an optimized rule-based extractor with lightweight classifiers. Experiments on a fixed Common Crawl data pool show that the proposed methods retain substantially more training tokens than existing pipelines while improving pretraining performance across models ranging from 157M to 2.9B parameters. Additional evaluations examine extraction quality, data coverage, diversity, and computational efficiency.

Critical strengths
  1. A practical and well-motivated approach to pretraining data curation. The paper addresses an important limitation of existing web data pipelines, where heuristic extraction and filtering can discard valuable content. The proposed specification-driven approach unifies content selection and extraction, allowing more flexible and context-aware curation. Distilling this process into an efficient cascade further makes the approach practical for web-scale deployment.

  2. Strong empirical validation and substantial downstream improvements. The paper conducts extensive experiments across multiple model sizes, training budgets, and evaluation suites, demonstrating consistent improvements over established data curation pipelines. Particularly compelling is the ability to retain substantially more useful training data while improving downstream pretraining performance. The additional analyses of extraction quality, data coverage, and diversity further support the effectiveness of the approach.

Critical weaknesses
  1. Potential inconsistency in baseline data construction. The comparison uses released baseline datasets that have already undergone deduplication, which are subsequently restricted to the selected WARC pool, whereas Generative Curation processes the raw WARC files and performs deduplication within that pool. If the baselines were deduplicated against their larger original corpora, this could exclude documents whose retained duplicates fall outside the evaluation pool, artificially reducing their available unique tokens. This distinction is particularly consequential because the reported pretraining advantages at larger token budgets partly arise from the baselines exhausting their smaller corpora and repeating data. The paper does not establish whether this potential discrepancy affects the reported differences in data coverage and downstream performance.
Questions for authors
  1. Baseline data construction. Were the released DCLM and Nemotron-CC datasets deduplicated against documents outside the selected WARC pool before being restricted to that pool? If so, could this have reduced their available unique tokens relative to GC-Cascade, which performs deduplication within the selected pool? How might this affect the reported data coverage and downstream pretraining comparisons?

  2. Sources of pretraining improvements. Can the authors further clarify the relative contributions of improved content extraction, filtering decisions, and increased data coverage to the downstream pretraining gains? In particular, do the existing results provide evidence that the proposed curation strategy improves data quality independently of the benefits from retaining more unique tokens?

  3. End-to-end computational cost and adaptability. What is the total upfront computational cost of constructing GC-Cascade, including GPT-OSS supervision, Qwen3-8B distillation, LLM labeling of approximately 400M pages, classifier training, and agent-driven extractor development? Are these costs accounted for in the reported efficiency estimates? Additionally, would adapting GC-Cascade to a different curation specification require repeating substantial parts of this process?

1 comment
AuthorsOpenReview ↗

Response to Reviewer ARPn

Thank you for your time and effort spent reviewing our paper. We are glad you found the idea practical and well motivated, and that you found our experiments compelling! We were particularly encouraged by your positive feedback and high marks for the presentation, informativeness, and soundness of our paper! We also believe that your suggestions will strengthen our paper, which we discuss below.

We will discuss the weaknesses and questions in the order you proposed them:

W1: Potential Inconsistency in baseline data construction. Your deduplication concern with taking a slice of the released data was a really helpful thing to flag. It is slightly inconsistent to deduplicate the baselines against a global pool while deduplicating GC-LLM, GC-Cascade, and Resiliparse against only the 10k WARC pool. We ran several experiments which we describe in the shared response to address your concern. In summary, we reproduce DCLM, Nemotron-CC, Fineweb, and Fineweb-edu using their released code, and we get remarkably similar results to the slices of the produced datasets. However, we think this is a more correct way of doing things, so we have updated our draft. Thank you so much for your suggestion!

Q1: Are the baselines deduplicated fairly? Addressed in the shared response! TLDR; we ran many experiments, and the results are the same.

Q2: What leads to the improvements? Is it the filtering, extraction, coverage? Is it just having more tokens that helps? We also decided to address this in the shared response and by adding Appendix J “Data Curation Ablations,” to the paper. The summary is that both filtering and extraction matter for GC-Cascade outperforming baselines, but GC-Cascade wins over GC-LLM due to extraction. To show that our wins are not only from having more tokens, we also train on natural data mixes in Appendix H, and report Figure 8 to show that, prior to epoching, our data is still better than baselines. Thank you for this suggestion; it certainly strengthened our paper!

Q3: What is the end-to-end cost? How much would it cost to adapt this to a new spec? We also decided to address this in the shared response, but the simple numbers are that the end-to-end cost of producing and running GC-Cascade was about 5E+22 FLOPs. Adapting GC-Cascade to a new spec reuses the fine-tuned Qwen3-8B, so it only requires relabeling about 90M pages and retraining the classifiers, which costs about 8E+21 FLOPs, less than twice the cost of one GC-Cascade run over the Common Crawl. This remains over 20,000x cheaper than running GC-LLM on the Common Crawl. We include Appendix F for more detailed cost information.

Comments on the paper

2 comments
AuthorsOpenReview ↗

General Response to All Reviewers (1/2)

We thank all our reviewers for their comments and for the time they spent reviewing our manuscript. In particular, we are very pleased that the paper was considered “a practical and well-motivated approach” (ARPn), that all reviewers highlighted the substantial scope of our pretraining sweep (ARPn, cZRK, ePF3), and that reviewers identified both the scientific and engineering contributions of our Cascade (cZRK, ePF3).

There were a few points that more than one reviewer commented on. To address these points, we modified the attached manuscript. We have made the following revisions to our draft:

1. GC-Cascade on the entire Common Crawl has finished. We updated the manuscript to reflect that we have produced a 17.1T token dataset using GC-Cascade, which we are calling Atlantic-CC.

2. Potential Inconsistency in baseline data construction. Reviewers noted that training on a fixed slice of the released datasets could be problematic because of deduplication. It is slightly inconsistent to deduplicate the baselines against a global pool while deduplicating GC-LLM, GC-Cascade, and Resiliparse against only the 10k WARC pool. In order to address these concerns, we took the following actions:

(a) We reproduced DCLM, FineWeb-Edu, FineWeb, and Nemotron-CC using their released code on precisely the same 10k WARCs so that they are deduplicated on the same pool. For most baselines, this had minimal effect, since DCLM and both FineWeb and FineWeb-Edu use local/sharded deduplication; however, Nemotron-CC uses global deduplication. We are reporting the token differences in the table below:

BaselineReleased Slice tokens (Old)Reproduction tokens (New)
DCLM7.3B9.5B
FineWeb28.0B44.8B
FineWeb-Edu2.3B3.9B
Nemotron-CC7.3B69.2B
Nemotron-CC (+ Synthetic)10.1B95.2B

(b)We are in the process of rerunning all experiments under this new setup. Unfortunately, our experiments are time-consuming, so they will require another week to finish. However, we are happy to report extremely minimal shifts so far.

The table below shows the bpb difference between the two baseline versions for the 1B model at various compute budgets. As you can see, the difference is usually less than 0.02 bpb, with the exception of FineWeb-Edu (which was already dramatically underperforming other baselines).

Baseline3e18 FLOPs9E+183E+199E+193E+20
0.5B tokens1.5B tokens5.0B tokens14.9B tokens49.8B tokens
DCLM-0.039-0.002-0.0040.002-0.012
FineWeb-0.0140.0010.010-0.0190.001
FineWeb-Edu-0.0100.0390.023-0.065-0.146
Nemotron-CC (+ Synthetic)0.0080.004-0.015-0.025-0.057

This suggests that, although there is a slight difference between the two ways of comparing to the baselines, both yield very similar results. We believe that this way is a bit fairer, so we will finish running it and replace our results in the paper, but it seems both produce the same results. It is worth noting that only the absolute scores of each baseline change; the ranking does not.

(c) We will update the paper with this fair comparison to the baselines when the domain mixing experiments finish in 1 week. We do not anticipate any of the findings changing. We thank you all for this great suggestion!

3. Source of Pretraining Improvements. Reviewers raised concerns that it was uncertain whether the gains for GC-LLM and GC-Cascade come from better extraction or better filtering. To isolate this, we ran the 2x2 ablation at 157M, 1B, and 2.9B as requested by both reviewers cZRK and ePF3. We included this in our new Appendix J: “Data Curation Ablations”. The summary is that both filtering and extraction matter for GC-Cascade to outperform baselines, but GC-Cascade wins over GC-LLM because of extraction. This ties in with some of our discussions about the limitations of GC-LLM.

4. Presentation of GC-LLM. Both reviewers cZRK and ePF3 were concerned that GC-LLM is represented as a single transformation call to an LLM in Figure 1; however, in Section 3.2 we clarify that it is split into multiple calls, primarily due to context length considerations. To address this, we have made two edits in the attached draft:

  1. Figure 1 now makes it clear that GC-LLM uses the LLM in a Harness rather than a single call
  2. We added Figure 7 to the appendix, which presents the full LLM Harness in the same style as Figure 1.
AuthorsOpenReview ↗

General Response to all Reviewers (2/2)

5. Role of Data Mixing. Reviewers cZRK and ePF3 expressed concerns that “Mixing does part of the filtering”. In our individual response, we argue that our experimental setup is the correct way to evaluate datasets (as it matches the downstream way practitioners use pretraining datasets); we nevertheless run a simple experiment to show that results without mixing are the same. We add Appendix H, “Impact of Data Mixing,” where we run all datasets under their natural mix with no data mixing. We find that the ranking remains largely the same: GC-Cascade > DCLM > GC-LLM > Nemotron > Resiliparse > FineWeb-Edu > Fineweb. This is shown in Appendix Figure 8 in the updated draft and is consistent with our data-mixed findings.

6. Cost Accounting. All reviewers asked about the “End-to-end computational cost” (ARPn). To make our computations more transparent to readers, we include Appendix F, “Compute Cost,” which discusses the costs incurred to build and run our pipeline and how those costs were calculated. Below, we include the full accounting of costs. Adapting GC-Cascade to a new spec costs about 8e+21 FLOPs, similar to the cost of running it once on the Common Crawl, and still over 20,000x cheaper than running GC-LLM on the Common Crawl.

StageFLOPs
Build: teacher data (GPT-OSS-120B)~3E+20
Build: fine-tune Qwen3-8B2.9E+20
Build: label our 10k-WARC pool with GC-LLM~4E+22
Build: train the classifiers<1E+20
Build: fit the extractor3.8 days of agent-driven search (179 cycles, CPU only)
Run: GC-Cascade over Common Crawl5.3E+21
New spec: relabel ~90M pages and retrain the classifiers~8E+21
Mixing: Olmix, per corpus1.1E+21
Reference: GC-LLM over Common Crawl (single spec)1.78E+26

Overall, we want to thank the reviewers for their feedback. We took great care to incorporate these changes into our paper and strengthen the draft, and we hope this addresses the shared concerns. We will also respond to individual comments individually.

From OpenReview, CC BY 4.0. Authors as signed there; shown unedited.

Related papers

Loading the map…

Discussion (0)

Sign in to comment.