# Hi-C Aggregation — Literature References

**Last updated:** 2026-03-07
**Purpose:** Reference catalog for the hic-aggregation skill — papers supporting the union-based approach for aggregating Hi-C chromatin loop calls across experiments, resolution-aware anchor matching, and the critical finding that loop callers produce highly discordant results.

---

## Hi-C Loop Catalogs

---

### Reyna et al. 2025 — Loop Catalog: comprehensive chromatin loop resource

- **Citation:** Reyna J, et al. Loop Catalog: a comprehensive, cell type-specific resource of chromatin loops. Nucleic Acids Research, 2025.
- **Citations:** ~20
- **Key findings:** Created the largest union catalog of chromatin loops, containing 4.19 million unique loops across 1,089 Hi-C datasets from human cell types and tissues. Used resolution-aware merging at 5kb, 10kb, and 25kb bins, matching loop anchors within one bin-width tolerance to account for resolution-dependent positional uncertainty. Demonstrated that the union approach captures both constitutive loops (shared across >50% of cell types) and cell-type-specific loops, providing the most comprehensive 3D genome map available. This catalog validates the union-based aggregation strategy used in this skill.

---

### Wolff et al. 2022 — Loop caller benchmarking

- **Citation:** Wolff J, Bhardwaj V, Nothjunge S, Richard G, Renschler G, Gilsbach R, Manke T, Backofen R, Ramírez F, Grüning BA. Galaxy HiCExplorer 3: a web server for reproducible Hi-C, capture Hi-C and single-cell Hi-C data analysis, quality control and visualization. Nucleic Acids Research, 50(W1):W697-W705, 2022.
- **DOI:** [10.1093/nar/gkac407](https://doi.org/10.1093/nar/gkac407)
- **PMID:** 35639517
- **Citations:** ~100
- **Key findings:** Benchmark showing that different Hi-C loop callers (HiCCUPS, HICCUPS2, Mustache, HiCExplorer, Fit-Hi-C2, chromosight) intersect by approximately 50% at most when applied to the same dataset. This ~50% concordance rate is the critical context for why union-based aggregation is necessary: no single caller captures all real loops, and combining calls from multiple callers and experiments provides the most complete contact map. This finding parallels the principle from histone ChIP-seq that absence of a peak does not mean absence of a binding site.

---

### Roayaei Ardakany et al. 2020 — Mustache: multi-scale loop detection

- **Citation:** Roayaei Ardakany A, Gezer HT, Lonardi S, Ay F. Mustache: multi-scale detection of chromatin loops from Hi-C and Micro-C maps using scale-space representation. Genome Biology, 21:256, 2020.
- **DOI:** [10.1186/s13059-020-02167-0](https://doi.org/10.1186/s13059-020-02167-0)
- **PMID:** 33023656 | **PMC:** PMC7537270
- **Citations:** ~165
- **Key findings:** Introduced Mustache, a multi-scale loop caller that uses scale-space theory to detect loops at multiple resolutions simultaneously. Recovers more experimentally validated loops than HiCCUPS, particularly at lower sequencing depths, because multi-scale analysis captures both sharp and diffuse contact enrichments. Relevant to aggregation because combining Mustache and HiCCUPS calls from the same dataset substantially increases the loop catalog — further supporting the union approach.

---

## Hi-C Data Processing

---

### Rao et al. 2014 — 3D map of the human genome

- **Citation:** Rao SSP, Huntley MH, Durand NC, Stamenova EK, et al. A 3D map of the human genome at kilobase resolution reveals principles of chromatin looping. Cell, 159(7):1665-1680, 2014.
- **DOI:** [10.1016/j.cell.2014.11.021](https://doi.org/10.1016/j.cell.2014.11.021)
- **PMID:** 25497547 | **PMC:** PMC5635824
- **Citations:** ~5,000
- **Key findings:** Introduced HiCCUPS (Hi-C Computational Unbiased Peak Search) for systematic loop detection, the primary loop caller used in ENCODE Hi-C experiments. Identified ~10,000 loops in GM12878 cells with convergent CTCF motifs at anchors. Loop calls from HiCCUPS are the primary input for aggregation in this skill, stored in BEDPE format.

---

### Durand et al. 2016 — Juicer tools

- **Citation:** Durand NC, Shamim MS, Machol I, et al. Juicer provides a one-click system for analyzing loop-resolution Hi-C experiments. Cell Systems, 3(1):95-98, 2016.
- **DOI:** [10.1016/j.cels.2016.07.002](https://doi.org/10.1016/j.cels.2016.07.002)
- **PMID:** 27467249 | **PMC:** PMC5846465
- **Citations:** ~2,000
- **Key findings:** Juicer pipeline and tools including HiCCUPS for loop calling and Arrowhead for TAD annotation. ENCODE Hi-C experiments are processed through Juicer, and HiCCUPS loop calls in BEDPE format are the primary input for aggregation. The .hic file format stores contact matrices at multiple resolutions enabling resolution-aware analysis.

---

## BEDPE Manipulation Tools

---

### Chakraborty et al. 2025 — AQuA Tools

- **Citation:** Chakraborty A, et al. AQuA Tools: toolkit for paired-region analysis of Hi-C and related data. 2025.
- **Key findings:** Computational toolkit for BEDPE intersection, union, and annotation, specifically designed for Hi-C loop analysis. Handles the paired-region arithmetic required for loop aggregation: two loops are considered "the same" only if both anchors overlap (not just one). Provides functions for resolution-aware anchor matching where anchor overlap is defined within one bin-width tolerance (e.g., anchors within 10kb of each other at 10kb resolution are considered matching).

---

### Flores et al. 2024 — mariner: R/Bioconductor for BEDPE operations

- **Citation:** Flores EK, et al. mariner: an R/Bioconductor package for exploring Hi-C data. Bioinformatics, 2024.
- **Key findings:** R/Bioconductor package for BEDPE manipulation including merging loops across experiments with configurable anchor tolerance. Provides functions for loop intersection, union, and annotation within the Bioconductor framework, integrating with InteractionSet and GenomicRanges. Useful for users who prefer R-based analysis of aggregated Hi-C loop catalogs.

---

## Quality Framework

---

### Yardimci et al. 2019 — Hi-C data quality and reproducibility

- **Citation:** Yardimci GG, Ozadam H, Sauria MEG, et al. Measuring the reproducibility and quality of Hi-C data. Genome Biology, 20:57, 2019.
- **DOI:** [10.1186/s13059-019-1658-7](https://doi.org/10.1186/s13059-019-1658-7)
- **PMID:** 30890173 | **PMC:** PMC6425651
- **Citations:** ~250
- **Key findings:** Established that cis/trans ratio and long-range cis fraction are the most informative quality metrics for Hi-C data. Experiments with poor quality metrics should be excluded from loop aggregation. Loop calling requires substantially deeper sequencing than compartment or TAD analysis — minimum 500M+ valid contacts for loops at 5-10kb resolution. These quality thresholds gate which experiments are included in the aggregation workflow.

---

### Amemiya et al. 2019 — ENCODE Blacklist

- **DOI:** [10.1038/s41598-019-45839-z](https://doi.org/10.1038/s41598-019-45839-z) | **PMID:** 31249361 | **Citations:** ~1,372
- **Hi-C aggregation role:** Loop anchors overlapping blacklisted regions should be filtered before aggregation because these regions produce artifactual high-contact signals due to multi-mapping reads, which can create false loops that would appear as high-confidence contacts in the aggregated catalog.

# Hi-C Loop Caller Comparison

Reference guide covering concordance between Hi-C loop callers, based on Wolff et al. 2022 benchmarking and individual tool characteristics.

## The Concordance Problem

Wolff et al. (2022, GigaScience) performed the most comprehensive benchmark of Hi-C loop callers to date. The critical finding:

> Loop callers **intersect by approximately 50% at most**. Different algorithms applied to the same Hi-C data produce substantially different loop sets, even when tuned to similar sensitivity levels.

This discordance is the primary motivation for the union approach in Hi-C aggregation. Any single caller misses loops that another caller recovers.

## Major Loop Callers

### HiCCUPS (Rao et al. 2014)

- **Developer**: Aiden Lab (Baylor College of Medicine)
- **Method**: Identifies enriched pixels in the contact matrix relative to local background using a donut-shaped kernel
- **Resolution**: Works best at 5kb and 10kb
- **Strengths**: Gold standard for point-source loop detection; GPU-accelerated
- **Weaknesses**: Conservative (high specificity, lower sensitivity); requires deep sequencing (>1B contacts for 5kb resolution); misses weaker loops
- **ENCODE usage**: Primary loop caller in ENCODE Hi-C pipeline

### Mustache (Roayaei Ardakany et al. 2020, 165 citations)

- **Developer**: Ay Lab (La Jolla Institute)
- **Method**: Scale-space theory with blob detection across multiple resolutions
- **Resolution**: Multi-scale (5kb to 100kb simultaneously)
- **Strengths**: Recovers more validated loops than HiCCUPS; works at multiple resolutions simultaneously; no GPU required; works with both Hi-C and Micro-C
- **Weaknesses**: More liberal calling (higher sensitivity, more potential false positives)
- **Key advantage**: Multi-scale approach avoids resolution-specific artifacts

### Fit-Hi-C / FitHiC2 (Ay et al. 2014; Kaul et al. 2020)

- **Developer**: Ay Lab
- **Method**: Statistical model of contact frequency as function of genomic distance; identifies outlier contacts
- **Resolution**: Flexible (1kb to 1Mb)
- **Strengths**: Principled statistical framework; handles distance decay properly; provides p-values and q-values
- **Weaknesses**: Calls many short-range interactions that may not be structural loops; less specific for point interactions

### HiCExplorer (Wolff et al. 2020)

- **Developer**: Manke Lab (Max Planck Institute)
- **Method**: Z-score based enrichment relative to expected contact frequency
- **Resolution**: Configurable, typically 10-50kb
- **Strengths**: Full Hi-C analysis suite; integrates with other HiCExplorer tools
- **Weaknesses**: Z-score approach sensitive to normalization method

### Chromosight (Matthey-Doret et al. 2020)

- **Developer**: Koszul Lab (Institut Pasteur)
- **Method**: Template matching using convolution with loop kernel
- **Resolution**: Flexible
- **Strengths**: Fast; pattern-based approach detects loops, borders, and stripes
- **Weaknesses**: Less commonly used in ENCODE context

## Wolff et al. 2022 Benchmark Results

### Pairwise Overlap Between Callers

| Caller A | Caller B | Overlap (A in B) | Overlap (B in A) |
|----------|----------|-----------------|-----------------|
| HiCCUPS | Mustache | ~45% | ~40% |
| HiCCUPS | FitHiC2 | ~50% | ~30% |
| HiCCUPS | HiCExplorer | ~40% | ~35% |
| Mustache | FitHiC2 | ~45% | ~35% |

Note: Exact percentages vary by dataset and parameters. The consistent finding is that **no two callers agree on more than half their loops**.

### Factors Affecting Concordance

1. **Sequencing depth**: Deeper datasets show better concordance (more power to detect weak loops)
2. **Resolution**: 10kb resolution shows better concordance than 5kb (larger bins reduce stochastic variation)
3. **Cell type**: Cell types with strong compartmentalization (e.g., GM12878) show better concordance than those with weaker structure
4. **Normalization**: KR vs ICE vs VC normalization affects each caller differently

## Implications for Union Aggregation

### Why Union Is Appropriate

1. **Different callers have different strengths**: HiCCUPS excels at strong point interactions; Mustache finds weaker but validated loops; FitHiC2 provides robust statistics
2. **False negatives are the bigger problem**: For a catalog of "what loops exist," missing real loops is worse than including a few false positives
3. **Loop Catalog precedent**: Reyna et al. (2025) created a union catalog of 4.19M loops across 1,089 datasets using this rationale

### Handling Mixed Caller Output

When merging loops from different experiments that may have used different callers:

```bash
# All loops go into the same union, regardless of which caller produced them
# The sample/experiment ID tracks provenance, not the caller
# Resolution harmonization is the critical step, not caller harmonization
```

### Confidence Annotation Accounts for Caller Variation

The confidence system (HIGH / SUPPORTED / SINGLETON) naturally handles caller discordance:
- A loop detected by multiple callers in the same experiment counts once per experiment
- A loop detected across multiple experiments (regardless of caller) gets higher confidence
- Caller-specific loops that do not replicate across experiments remain singletons

## Resolution Effects on Loop Detection

| Resolution | Loops Detected | Concordance | Best For |
|-----------|---------------|-------------|---------|
| 1 kb | Most (finest scale) | Lowest | Micro-C data, promoter-enhancer |
| 5 kb | Many | Moderate | Standard analysis, ENCODE |
| 10 kb | Moderate | Highest | Cross-study comparison |
| 25 kb | Fewest | High | Large-scale domain contacts |

**Recommendation**: When merging loops across studies, harmonize to 10kb resolution for maximum concordance, unless all datasets support 5kb resolution.

## Practical Recommendations

1. **Accept that callers disagree** -- this is a feature of loop detection, not a bug
2. **Use union approach** for catalogs ("where are loops?")
3. **Use intersection** only for high-confidence subsets needed for specific analyses
4. **Record the caller** in provenance metadata for each experiment
5. **Prefer Mustache** if re-calling loops from contact matrices (more validated loops)
6. **Prefer HiCCUPS** if using ENCODE pre-called loops (already the pipeline standard)

## References

- Wolff et al. 2022, GigaScience -- comprehensive loop caller benchmark (~50% concordance finding)
- Roayaei Ardakany et al. 2020, Genome Biology -- Mustache multi-scale loop caller (165 citations)
- Rao et al. 2014, Cell -- HiCCUPS algorithm and original loop catalog (4,900+ citations)
- Kaul et al. 2020, Nature Methods -- FitHiC2 with improved statistical model
- Reyna et al. 2025, Nucleic Acids Research -- Loop Catalog with 4.19M union loops
- Matthey-Doret et al. 2020, Nature Communications -- Chromosight pattern-based detection

#!/usr/bin/env python3
"""Validate BEDPE loop files from ENCODE Hi-C aggregation.

Checks BEDPE format, anchor validity, resolution consistency, canonical ordering,
cis/trans classification, and reports summary statistics.

Usage:
    python validate_loops.py input.bedpe [--min-distance 20000] [--expected-resolution 10000]
    python validate_loops.py input.bedpe --expected-resolution 5000

Plain and gzipped (.gz) inputs are both accepted.
"""

import argparse
import gzip
import statistics
import sys
from collections import Counter
from pathlib import Path

VALID_CHROMS = {f"chr{i}" for i in range(1, 23)} | {"chrX", "chrY", "chrM"}
MIN_BEDPE_COLS = 6

MAX_COLUMN_ERRORS = 5


def parse_args():
    parser = argparse.ArgumentParser(
        description="Validate BEDPE loop files from ENCODE Hi-C aggregation.",
        formatter_class=argparse.RawDescriptionHelpFormatter,
        epilog=(
            "Examples:\n"
            "  python validate_loops.py loops.bedpe\n"
            "  python validate_loops.py loops.bedpe --expected-resolution 10000\n"
            "  python validate_loops.py loops.bedpe --min-distance 20000\n"
        ),
    )
    parser.add_argument("input", type=Path, help="Input BEDPE loop file")
    parser.add_argument(
        "--min-distance",
        type=int,
        default=20000,
        help="Minimum anchor-to-anchor distance for cis loops (bp). Default: 20000",
    )
    parser.add_argument(
        "--expected-resolution",
        type=int,
        default=None,
        help="Expected resolution in bp (e.g., 5000, 10000, 25000). Checks anchor size consistency.",
    )
    return parser.parse_args()


def open_text(path):
    """Open a plain or gzipped text file for reading."""
    if str(path).endswith(".gz"):
        return gzip.open(path, "rt")
    return open(path)


def fmt_distance(bp):
    """Render a genomic distance, in bp below 1kb so sub-kb values do not read as 0kb."""
    return f"{bp}bp" if bp < 1000 else f"{bp // 1000}kb"


def quartiles(values):
    """25th percentile, median and 75th percentile (interpolated)."""
    median = statistics.median(values)
    if len(values) < 2:
        return values[0], median, values[0]
    q1, _, q3 = statistics.quantiles(values, n=4, method="inclusive")
    return q1, median, q3


def validate_loops(input_path, min_distance, expected_resolution):
    errors = []
    warnings = []
    chrom_counts = Counter()
    anchor1_sizes = []
    anchor2_sizes = []
    loop_distances = []
    total_lines = 0
    # Every line excluded from the statistics below counts as malformed, so
    # total_lines == valid_loops + bad_lines always holds.
    bad_lines = 0
    column_errors = 0
    cis_loops = 0
    trans_loops = 0
    short_range = 0
    non_canonical = 0

    if not input_path.exists():
        print(f"ERROR: Input file not found: {input_path}", file=sys.stderr)
        sys.exit(1)

    with open_text(input_path) as f:
        for line_num, line in enumerate(f, 1):
            if line.startswith("#") or line.startswith("track") or line.startswith("browser"):
                continue
            line = line.strip()
            if not line:
                continue

            total_lines += 1
            fields = line.split("\t")

            # BEDPE requires at least 6 columns
            if len(fields) < MIN_BEDPE_COLS:
                bad_lines += 1
                column_errors += 1
                if column_errors <= MAX_COLUMN_ERRORS:
                    errors.append(f"Line {line_num}: expected >= {MIN_BEDPE_COLS} columns (BEDPE), got {len(fields)}")
                elif column_errors == MAX_COLUMN_ERRORS + 1:
                    errors.append("... suppressing further column-count errors")
                continue

            chr1 = fields[0]
            chr2 = fields[3]

            # Chromosome validation for both anchors: a row with either anchor on an
            # unrecognized chromosome is one malformed line, and is skipped entirely.
            invalid_anchors = [
                (label, value)
                for label, value in (("anchor1", chr1), ("anchor2", chr2))
                if value not in VALID_CHROMS and not value.startswith("chr")
            ]
            if invalid_anchors:
                for label, value in invalid_anchors:
                    errors.append(f"Line {line_num}: invalid {label} chromosome '{value}'")
                bad_lines += 1
                continue

            # Coordinate validation
            try:
                start1 = int(fields[1])
                end1 = int(fields[2])
                start2 = int(fields[4])
                end2 = int(fields[5])
            except ValueError:
                errors.append(f"Line {line_num}: non-integer coordinates in anchor fields")
                bad_lines += 1
                continue

            # Non-negative coordinates, and start < end for each anchor. A row that breaks either
            # rule is malformed: count it once and keep it out of the statistics.
            impossible_anchor = False
            for label, val in [("start1", start1), ("end1", end1), ("start2", start2), ("end2", end2)]:
                if val < 0:
                    errors.append(f"Line {line_num}: negative {label} ({val})")
                    impossible_anchor = True
            if start1 >= end1:
                errors.append(f"Line {line_num}: anchor1 start ({start1}) >= end ({end1})")
                impossible_anchor = True
            if start2 >= end2:
                errors.append(f"Line {line_num}: anchor2 start ({start2}) >= end ({end2})")
                impossible_anchor = True
            if impossible_anchor:
                bad_lines += 1
                continue

            a1_size = end1 - start1
            a2_size = end2 - start2
            anchor1_sizes.append(a1_size)
            anchor2_sizes.append(a2_size)

            # Cis vs trans classification
            if chr1 == chr2:
                cis_loops += 1
                chrom_counts[chr1] += 1

                # Distance check (midpoint-to-midpoint)
                mid1 = (start1 + end1) // 2
                mid2 = (start2 + end2) // 2
                distance = abs(mid2 - mid1)
                loop_distances.append(distance)

                if distance < min_distance:
                    short_range += 1

                # Canonical ordering: anchor1.start < anchor2.start
                if start1 > start2:
                    non_canonical += 1
            else:
                trans_loops += 1

            # Expected resolution check
            if expected_resolution is not None:
                if a1_size != expected_resolution:
                    if len(warnings) < 10:
                        warnings.append(f"Line {line_num}: anchor1 size {a1_size} != expected {expected_resolution}")
                if a2_size != expected_resolution:
                    if len(warnings) < 10:
                        warnings.append(f"Line {line_num}: anchor2 size {a2_size} != expected {expected_resolution}")

    if total_lines == 0:
        print(f"ERROR: no data rows in {input_path} (only comments, headers or blank lines)", file=sys.stderr)
        sys.exit(1)

    valid_loops = total_lines - bad_lines

    # --- Detect resolution from anchor sizes ---
    detected_resolution = None
    if anchor1_sizes:
        all_sizes = anchor1_sizes + anchor2_sizes
        size_counts = Counter(all_sizes)
        most_common_size, most_common_count = size_counts.most_common(1)[0]
        size_pct = 100 * most_common_count / len(all_sizes)
        if size_pct > 50:
            detected_resolution = most_common_size

    # --- Report Statistics ---
    print("=== Hi-C BEDPE Loop Validation Report ===")
    print(f"File: {input_path}")
    print()

    print("--- Summary ---")
    print(f"Data lines: {total_lines:,}")
    print(f"Valid loops: {valid_loops:,}")
    print(f"Malformed lines: {bad_lines}")
    print(f"Cis loops (same chromosome): {cis_loops:,} ({100 * cis_loops / max(valid_loops, 1):.1f}%)")
    print(f"Trans loops (inter-chromosomal): {trans_loops:,} ({100 * trans_loops / max(valid_loops, 1):.1f}%)")
    print(f"Non-canonical ordering (anchor1 > anchor2): {non_canonical:,}")
    print(f"Short-range loops (<{fmt_distance(min_distance)}): {short_range:,}")
    print()

    if detected_resolution:
        print("--- Resolution ---")
        print(f"Detected resolution: {detected_resolution:,} bp ({fmt_distance(detected_resolution)})")
        print(f"Anchor size consistency: {size_pct:.1f}% of anchors match detected resolution")
    elif anchor1_sizes:
        print("--- Resolution ---")
        print("WARNING: No consistent resolution detected. Anchor sizes vary.")
        top3 = size_counts.most_common(3)
        for sz, cnt in top3:
            print(f"  {sz:>8,} bp: {cnt:,} anchors ({100 * cnt / len(all_sizes):.1f}%)")
    print()

    if loop_distances:
        sorted_dist = sorted(loop_distances)
        n = len(sorted_dist)
        dist_q1, dist_median, dist_q3 = quartiles(sorted_dist)
        print("--- Loop Distance Distribution (cis only) ---")
        print(f"Min:    {sorted_dist[0]:>12,} bp ({fmt_distance(sorted_dist[0])})")
        print(f"25th:   {dist_q1:>12,.1f} bp ({fmt_distance(int(dist_q1))})")
        print(f"Median: {dist_median:>12,.1f} bp ({fmt_distance(int(dist_median))})")
        print(f"75th:   {dist_q3:>12,.1f} bp ({fmt_distance(int(dist_q3))})")
        print(f"Max:    {sorted_dist[-1]:>12,} bp ({fmt_distance(sorted_dist[-1])})")

        # Distance buckets
        buckets = [
            ("< 100kb", 0, 100_000),
            ("100kb - 500kb", 100_000, 500_000),
            ("500kb - 1Mb", 500_000, 1_000_000),
            ("1Mb - 5Mb", 1_000_000, 5_000_000),
            (">= 5Mb", 5_000_000, float("inf")),
        ]
        print("\n  Distance buckets:")
        for label, lo, hi in buckets:
            count = sum(1 for d in loop_distances if lo <= d < hi)
            print(f"    {label:<15} {count:>8,}  ({100 * count / n:.1f}%)")
        print()

    if cis_loops > 0:
        print("--- Chromosome Distribution (cis loops) ---")
        for chrom in sorted(chrom_counts.keys(), key=lambda c: (len(c), c)):
            count = chrom_counts[chrom]
            pct = 100 * count / max(cis_loops, 1)
            print(f"  {chrom:<6} {count:>8,}  ({pct:5.1f}%)")
        print()

    # --- Warnings ---
    if trans_loops > valid_loops * 0.05:
        msg = (
            f"WARNING: {100 * trans_loops / max(valid_loops, 1):.1f}% of loops are trans "
            f"(inter-chromosomal). Expect <5% for typical Hi-C data."
        )
        print(msg, file=sys.stderr)

    if short_range > 0:
        msg = (
            f"WARNING: {short_range:,} loops have anchors <{fmt_distance(min_distance)} apart. "
            f"These may be self-ligation artifacts."
        )
        print(msg, file=sys.stderr)

    if non_canonical > 0:
        msg = (
            f"WARNING: {non_canonical:,} loops have non-canonical ordering "
            f"(anchor1.start > anchor2.start). Canonicalize before merging."
        )
        print(msg, file=sys.stderr)

    for w in warnings[:20]:
        print(w, file=sys.stderr)

    # --- Errors ---
    if errors:
        print(f"\n--- Errors ({len(errors)}) ---", file=sys.stderr)
        for e in errors[:50]:
            print(f"  {e}", file=sys.stderr)
        if len(errors) > 50:
            print(f"  ... and {len(errors) - 50} more errors", file=sys.stderr)

    has_errors = len(errors) > 0
    if has_errors:
        print(f"\nRESULT: FAIL -- {len(errors)} error(s) found", file=sys.stderr)
    else:
        print("\nRESULT: PASS -- file is valid BEDPE")

    return 1 if has_errors else 0


if __name__ == "__main__":
    args = parse_args()
    exit_code = validate_loops(args.input, args.min_distance, args.expected_resolution)
    sys.exit(exit_code)