VSTAT dataset release

.gitattributes

@@ -0,0 +1,2 @@
+*.mp4 filter=lfs diff=lfs merge=lfs -text
+*.mov filter=lfs diff=lfs merge=lfs -text

LICENSE

@@ -0,0 +1,13 @@
+Creative Commons Attribution 4.0 International (CC BY 4.0)
+
+Copyright (c) 2026 The VSTAT Authors
+
+Annotations and self-recorded videos in this dataset are licensed under
+CC BY 4.0: https://creativecommons.org/licenses/by/4.0/
+
+Synthetic Blender-rendered videos are licensed under CC BY 4.0.
+
+YouTube videos referenced via URL/timestamp are NOT redistributed and
+remain under the original uploaders' licenses (typically Standard YouTube
+License). Users must download YouTube clips themselves and comply with
+YouTube's Terms of Service.

README.md

@@ -0,0 +1,209 @@
+---
+license: cc-by-4.0
+language:
+- en
+tags:
+- video
+- multimodal
+- benchmark
+- video-question-answering
+- visual-state-tracking
+size_categories:
+- 1K<n<10K
+---
+
+# VSTAT: Visual State Tracking Benchmark
+
+VSTAT is a video-based benchmark for evaluating the **visual state tracking**
+capability of Multimodal Large Language Models (MLLMs). It contains 834 video
+clips paired with 1,500 questions whose answers cannot be inferred from any
+single keyframe or short segment.
+
+## Dataset Composition
+
+| Split          | Videos | Questions |
+|----------------|-------:|----------:|
+| synthetic      |    450 |       550 |
+| self_recorded  |     80 |       100 |
+| youtube        |    304 |       850 |
+| **Total**      |  **834** |  **1,500** |
+
+## Files
+
+- `vstat_qa_clean.json` — all 1,500 question-answer pairs with taxonomy labels
+- `youtube_metadata.json` — YouTube URLs + start/end timestamps (one entry per chunk)
+- `youtube_resolutions.json` — per-clip target (W, H, fps) used by the
+  downloader to reproduce the official release pixel layout
+- `redactions.json` — declarative privacy-redaction regions applied after trim
+- `scripts/download_youtube.py` — fetches & trims the 304 YouTube clips
+- `scripts/redact.sh` — applies the privacy black-boxes from `redactions.json`
+- `scripts/build_resolution_map.py` — utility to (re)build `youtube_resolutions.json`
+  from a reference render
+- `videos/synthetic/<category>/<id>.mp4` — Blender-rendered videos (hosted)
+- `videos/self_recorded/<category>/<id>.mp4` — author-recorded clips, hands only,
+  audio removed (hosted)
+- `videos/youtube/<category>/<id>.mp4` — **NOT redistributed**; you must
+  download these yourself with the provided script (see *Quick start* below)
+
+## Quick start
+
+### 1. Get the repo
+
+Pick whichever method you prefer:
+
+```bash
+# A. huggingface-cli (recommended, supports LFS)
+pip install -U "huggingface_hub[cli]"
+huggingface-cli download nyu-visionx/vstat \
+  --repo-type=dataset \
+  --local-dir vstat
+cd vstat
+
+# B. git clone (requires git-lfs installed)
+git lfs install
+git clone https://huggingface.co/datasets/nyu-visionx/vstat vstat
+cd vstat
+```
+
+After this, you have all annotations and the synthetic + self_recorded
+videos. The YouTube clips are still missing — fetch them next.
+
+### 2. Download and redact the YouTube clips
+
+The downloader reads `youtube_metadata.json` and downloads each source
+video once with `yt-dlp`, then trims it into the chunks expected by
+`vstat_qa_clean.json`. Pass `--resolution-map youtube_resolutions.json`
+so each chunk lands at the exact `(width, height, fps)` of the official
+release. After trimming, `scripts/redact.sh` applies the privacy
+black-boxes (matches `redactions.json`) to the affected clips in place.
+
+> **Important — reproducing the official release.** The benchmark
+> numbers in our paper were obtained on the clips produced by exactly
+> this two-step pipeline (`download_youtube.py --resolution-map …` →
+> `redact.sh`). The downloader picks the smallest YouTube format that
+> matches each clip's target dimensions and frame rate so the trim
+> avoids any resampling drift. Skip the resolution map only for
+> ablations on input resolution.
+
+```bash
+# Install dependencies
+pip install -U yt-dlp
+# macOS:    brew install ffmpeg
+# Ubuntu:   sudo apt install ffmpeg
+
+# 1. Fetch and trim every YouTube clip to its release-spec dims
+python scripts/download_youtube.py --resolution-map youtube_resolutions.json
+
+# 2. Apply privacy redactions in place (idempotent)
+bash scripts/redact.sh
+```
+
+Common flags for the downloader:
+
+```bash
+# Faster: 4 parallel downloads
+python scripts/download_youtube.py --resolution-map youtube_resolutions.json --workers 4
+
+# Test on a few videos first
+python scripts/download_youtube.py --resolution-map youtube_resolutions.json --limit 5
+
+# Keep the full source videos around (faster re-trim, more disk)
+python scripts/download_youtube.py --resolution-map youtube_resolutions.json --keep-fulls
+
+# Print plan without doing anything
+python scripts/download_youtube.py --resolution-map youtube_resolutions.json --dry-run
+
+# Cap source download size (default uncapped — required for portrait sources)
+python scripts/download_youtube.py --resolution-map youtube_resolutions.json --source-cap 1080
+```
+
+Re-running the downloader is safe: it skips clips that already exist
+on disk and writes a `download_report.json` listing any failures (rare,
+usually due to YouTube link rot — affected clips can be reported to
+the authors via the dataset issue tracker). Re-running `redact.sh` is
+also idempotent and replaces any earlier redaction with the canonical
+set defined in `redactions.json`.
+
+### 3. Load the data
+
+```python
+import json
+
+with open("vstat_qa_clean.json") as f:
+    data = json.load(f)
+
+for cat, entries in data["data"].items():
+    for e in entries:
+        print(e["video_id"], e["video_path"], e["video_source"])
+```
+
+Each entry has these fields:
+
+| Field                      | Description                                                 |
+|----------------------------|-------------------------------------------------------------|
+| `video_id`                 | Unique identifier (e.g. `0001_pt1_q1`)                      |
+| `video_path`               | Relative path under `videos/`                               |
+| `video_source`             | `synthetic` / `self_recorded` / `youtube`                   |
+| `source_task`              | Coarse category (e.g. `basketball`, `dice`, `shell_game`)   |
+| `question`                 | Question text. For MCQ items, choices are inline `(A)(B)…`  |
+| `answer_type`              | `mcq` or `numeric`                                          |
+| `answer`                   | Letter (`A`/`B`/`C`/`D`) for MCQ; integer for numeric       |
+| `choices`                  | List of MCQ option strings (empty for numeric)              |
+| `answer_index`             | 0-based index into `choices` (null for numeric)             |
+| `perceptual_complexity`    | List of perceptual challenge tags (see Taxonomy)            |
+| `state_element_type`       | `count` / `location` / `attribute`                          |
+| `state_structure`          | `atomic` / `sequence` / `set` / `dictionary`                |
+| `youtube_url`, `youtube_id`, `start_time`, `end_time`, `start_sec`, `end_sec` | Present only for `video_source == "youtube"` |
+
+### 4. Run an evaluation
+
+A minimal MCQ scoring loop (numeric questions are scored with mean
+relative accuracy in our paper; see Section 3.1 for details):
+
+```python
+def score(entry, model_pred):
+    if entry["answer_type"] == "mcq":
+        return int(model_pred.strip().upper() == entry["answer"])
+    # numeric
+    try:
+        return int(int(model_pred) == int(entry["answer"]))
+    except ValueError:
+        return 0
+```
+
+## Taxonomy
+
+Each question is annotated with:
+
+- `perceptual_complexity` (multi-label, paper Section 2.2):
+  `action_ambiguity`, `camera_motion`, `homogeneity`,
+  `multi_entity_attribution`, `occlusion`, `symbolic_decoding`
+- `state_element_type` (single label): `count`, `location`, `attribute`
+- `state_structure` (single label): `atomic`, `sequence`, `set`, `dictionary`
+
+## License
+
+- Annotations and self-recorded / synthetic videos: **CC BY 4.0**
+- YouTube videos: NOT redistributed; subject to original uploader's license
+- See `LICENSE` for full terms
+
+## Privacy & consent
+
+- Self-recorded videos contain only the authors' hands; no faces, voices,
+  or other identifiable persons. Audio tracks were stripped before release.
+- Authors consented to public release of their hand footage.
+- For YouTube clips, only URLs and timestamps are redistributed; original
+  uploaders retain control over their content. The `redact.sh` step
+  applies black-boxes over scoreboards / on-screen text in a small
+  number of clips per `redactions.json`, matching the official release.
+
+## Citation
+
+```bibtex
+@article{vstat2026,
+    title={Benchmarking Visual State Tracking in Multimodal Video Understanding},
+    author={Sihyun Yu and Nanye Ma and Pinzhi Huang and Hyunseok Lee and Shusheng Yang and June Suk Choi and Ellis Brown and Oscar Michel and Boyang Zheng and Jinwoo Shin and Saining Xie},
+    year={2026},
+    journal={arXiv preprint arXiv:2606.03920},
+}
+```

redactions.json

@@ -0,0 +1,37 @@
+{
+  "description": "Per-source-video privacy redactions applied to YouTube clips. Coordinates are in the OUTPUT resolution (640x360, the official VSTAT release spec). Each redaction draws a solid black box (drawbox filter, t=fill) over the listed region in every chunk of the matching source video.",
+  "coordinate_space": "640x360 (post-scale)",
+  "redactions": [
+    {
+      "match": {"category": "tennis", "local_id": "0001"},
+      "boxes": [
+        {"x": 32, "y": 306, "w": 134, "h": 38}
+      ]
+    },
+    {
+      "match": {"category": "tennis", "local_id": "0002"},
+      "boxes": [
+        {"x": 32, "y": 306, "w": 134, "h": 38}
+      ]
+    },
+    {
+      "match": {"category": "basketball", "local_id": "0002"},
+      "boxes": [
+        {"x": 98, "y": 323, "w": 443, "h": 37}
+      ]
+    },
+    {
+      "match": {"category": "basketball", "local_id": "0003"},
+      "boxes": [
+        {"x": 22, "y": 285, "w": 125, "h": 63}
+      ]
+    },
+    {
+      "match": {"category": "soccer", "local_id": "0002"},
+      "boxes": [
+        {"x": 0,   "y": 0,   "w": 122, "h": 19},
+        {"x": 140, "y": 320, "w": 360, "h": 40}
+      ]
+    }
+  ]
+}

scripts/build_resolution_map.py

@@ -0,0 +1,92 @@
+#!/usr/bin/env python3
+"""Build a per-clip resolution map from an existing render of `videos/youtube/`.
+
+Walks a reference directory laid out like `<ref>/<category>/<file>.mp4`,
+runs ffprobe on each clip, and writes a JSON map keyed by
+`videos/youtube/<category>/<file>.mp4` (matching `video_path` in
+`youtube_metadata.json`). The map is consumed by `download_youtube.py
+--resolution-map` to reproduce the exact width/height/fps of each clip.
+
+Usage:
+    python scripts/build_resolution_map.py ~/Desktop/ytb/processed
+    python scripts/build_resolution_map.py REF_DIR -o youtube_resolutions.json
+"""
+from __future__ import annotations
+import argparse
+import json
+import subprocess
+import sys
+from concurrent.futures import ThreadPoolExecutor
+from pathlib import Path
+
+
+def probe(path: Path) -> dict | None:
+    try:
+        out = subprocess.run(
+            ["ffprobe", "-v", "error", "-select_streams", "v:0",
+             "-show_entries", "stream=width,height,r_frame_rate",
+             "-show_entries", "format=duration",
+             "-of", "json", str(path)],
+            capture_output=True, text=True, check=True, timeout=30,
+        ).stdout
+    except (subprocess.CalledProcessError, subprocess.TimeoutExpired):
+        return None
+    try:
+        info = json.loads(out)
+    except json.JSONDecodeError:
+        return None
+    s = (info.get("streams") or [{}])[0]
+    f = info.get("format", {})
+    fr = s.get("r_frame_rate", "0/1")
+    try:
+        n, d = (int(x) for x in fr.split("/"))
+        fps = round(n / d, 4) if d else None
+    except ValueError:
+        fps = None
+    if not (s.get("width") and s.get("height")):
+        return None
+    return {
+        "width": int(s["width"]),
+        "height": int(s["height"]),
+        "fps": fps,
+        "duration": round(float(f["duration"]), 4) if f.get("duration") else None,
+    }
+
+
+def main() -> int:
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("ref_dir", help="reference directory (e.g. ~/Desktop/ytb/processed)")
+    ap.add_argument("-o", "--out", default="youtube_resolutions.json",
+                    help="output JSON path (default: youtube_resolutions.json)")
+    ap.add_argument("--workers", type=int, default=8)
+    args = ap.parse_args()
+
+    ref = Path(args.ref_dir).expanduser()
+    if not ref.is_dir():
+        sys.exit(f"ERROR: {ref} is not a directory")
+
+    paths = sorted(ref.glob("*/*.mp4"))
+    print(f"probing {len(paths)} files under {ref}…", file=sys.stderr)
+
+    out: dict[str, dict] = {}
+    bad: list[str] = []
+    with ThreadPoolExecutor(max_workers=max(1, args.workers)) as ex:
+        for p, info in zip(paths, ex.map(probe, paths)):
+            key = f"videos/youtube/{p.parent.name}/{p.name}"
+            if info is None:
+                bad.append(key)
+                continue
+            out[key] = info
+
+    out_path = Path(args.out)
+    out_path.write_text(json.dumps(out, indent=2, sort_keys=True))
+    print(f"wrote {out_path} ({len(out)} entries; {len(bad)} probe failures)",
+          file=sys.stderr)
+    if bad:
+        print("  failures:", *bad[:10], "…" if len(bad) > 10 else "", file=sys.stderr)
+    return 0
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

scripts/download_youtube.py

@@ -0,0 +1,485 @@
+#!/usr/bin/env python3
+"""
+VSTAT — YouTube clip downloader
+
+Reads `youtube_metadata.json` and, for each entry, downloads the source
+YouTube video (with yt-dlp) and extracts the specified time range
+(with ffmpeg) into the `videos/youtube/<category>/<id>.mp4` path
+expected by `vstat_qa_clean.json`.
+
+Resolution handling:
+    --height H            scale every clip to height H, width preserves aspect
+                          (default 360 → 640x360 for 16:9; ≈202x360 for 9:16).
+    --resolution-map FILE preferred per-clip exact-match mode. Reads a JSON
+                          map (built by `scripts/build_resolution_map.py`)
+                          keyed by `videos/youtube/<cat>/<file>.mp4` with
+                          {"width", "height", "fps"} per entry, and scales
+                          each trim to exactly W×H@fps.
+    --reference-dir DIR   live alternative to --resolution-map: for each
+                          clip we probe DIR/<cat>/<file>.mp4 directly. Use
+                          --resolution-map when possible (no per-run probe).
+    --source-cap N        in reference mode, cap yt-dlp source download to
+                          height ≤ N. Default is uncapped so portrait
+                          sources (whose pixel height is the long side) are
+                          still selectable; ffmpeg always downscales the
+                          source to the exact per-clip target.
+
+Usage:
+    python download_youtube.py
+    python download_youtube.py --metadata youtube_metadata.json --out videos/youtube
+    python download_youtube.py --workers 4
+    python download_youtube.py --keep-fulls   # keep full source videos in cache/
+    python download_youtube.py --dry-run
+
+    # Reproduce per-video resolutions from a saved map (preferred):
+    python scripts/build_resolution_map.py ~/Desktop/ytb/processed \
+        -o youtube_resolutions.json
+    python download_youtube.py --resolution-map youtube_resolutions.json
+
+    # Or probe a reference tree live:
+    python download_youtube.py --reference-dir ~/Desktop/ytb/processed
+
+Requirements:
+    yt-dlp  (pip install -U yt-dlp)
+    ffmpeg  (system: brew install ffmpeg / apt install ffmpeg)
+"""
+from __future__ import annotations
+import argparse
+import concurrent.futures
+import json
+import os
+import shutil
+import subprocess
+import sys
+import time
+from collections import defaultdict
+from pathlib import Path
+
+# ---------- helpers ----------
+
+def have(cmd: str) -> bool:
+    return shutil.which(cmd) is not None
+
+def hms_to_sec(s) -> float | None:
+    if s is None:
+        return None
+    s = str(s).strip()
+    if not s or s.lower() in ("none", "null", "n/a"):
+        return None
+    parts = s.split(":")
+    try:
+        parts = [float(p) for p in parts]
+    except ValueError:
+        return None
+    if len(parts) == 3:  return parts[0]*3600 + parts[1]*60 + parts[2]
+    if len(parts) == 2:  return parts[0]*60 + parts[1]
+    if len(parts) == 1:  return parts[0]
+    return None
+
+def log(msg: str, prefix: str = ""):
+    print(f"{prefix}{msg}", flush=True)
+
+def probe_resolution(path: Path) -> tuple[int, int, float] | None:
+    """Return (width, height, fps) of `path`'s first video stream, or None."""
+    if not path.exists():
+        return None
+    try:
+        out = subprocess.run(
+            ["ffprobe", "-v", "error", "-select_streams", "v:0",
+             "-show_entries", "stream=width,height,r_frame_rate",
+             "-of", "default=nw=1:nk=1", str(path)],
+            capture_output=True, text=True, check=True,
+        ).stdout.strip().splitlines()
+    except (subprocess.CalledProcessError, FileNotFoundError):
+        return None
+    if len(out) < 3:
+        return None
+    try:
+        w, h = int(out[0]), int(out[1])
+        n, d = out[2].split("/")
+        fps = float(n) / float(d) if float(d) else 0.0
+    except (ValueError, ZeroDivisionError):
+        return None
+    return w, h, fps
+
+# ---------- core operations ----------
+
+def download_full(youtube_url: str, dst: Path, max_height: int | None = 360,
+                  max_fps: int | None = None,
+                  retries: int = 3) -> tuple[bool, str]:
+    """Download the full source video to dst (mp4).
+
+    If max_height is given, picks the best stream with pixel height <=
+    max_height. If max_height is None, picks bestvideo+bestaudio with no
+    cap — required when the target is a portrait clip whose source is
+    served by YouTube at a height (long side) larger than the clip target.
+
+    If max_fps is given, also constrains source fps <= max_fps. Important
+    when the target clip is e.g. 30fps but YouTube has a 60fps version of
+    the source: ffmpeg's fps-drop chooses different keyframes than the
+    reference pipeline, causing visible per-frame drift. Matching source
+    fps eliminates that drift.
+
+    Idempotent — skips if dst already exists."""
+    if dst.exists() and dst.stat().st_size > 0:
+        return True, "cached"
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    h = f"[height<={max_height}]" if max_height is not None else ""
+    f = f"[fps<={max_fps}]" if max_fps is not None else ""
+    if not h and not f:
+        fmt = (
+            "bestvideo[ext=mp4]+bestaudio[ext=m4a]/"
+            "best[ext=mp4]/"
+            "bestvideo+bestaudio/best"
+        )
+    else:
+        fmt = (
+            f"bestvideo[ext=mp4]{h}{f}+bestaudio[ext=m4a]/"
+            f"best[ext=mp4]{h}{f}/"
+            f"bestvideo{h}{f}+bestaudio/"
+            f"best{h}{f}/best{h}/best"
+        )
+    cmd = [
+        "yt-dlp",
+        "-f", fmt,
+        "--merge-output-format", "mp4",
+        "--no-playlist",
+        "-q",
+        "--no-warnings",
+        "-o", str(dst),
+        youtube_url,
+    ]
+    last_err = ""
+    for attempt in range(1, retries + 1):
+        res = subprocess.run(cmd, capture_output=True, text=True)
+        if res.returncode == 0 and dst.exists() and dst.stat().st_size > 0:
+            return True, f"downloaded (attempt {attempt})"
+        last_err = (res.stderr or res.stdout or "")[:200]
+        time.sleep(2 * attempt)
+    return False, f"yt-dlp failed: {last_err}"
+
+def trim_clip(src: Path, dst: Path, start_sec: float, end_sec: float | None,
+              target_height: int = 360,
+              target_width: int | None = None,
+              target_fps: float | None = None,
+              source_dims: tuple[int, int] | None = None) -> tuple[bool, str]:
+    """Cut [start, end) from src to dst, re-encoded to H.264.
+
+    If source_dims == (target_width, target_height), no scale/crop filter
+    is applied — letting ffmpeg do a straight decode→encode preserves frame
+    alignment with reference pipelines that also avoided rescaling.
+    Otherwise we centre-crop to the target's aspect ratio and scale to W×H."""
+    dst.parent.mkdir(parents=True, exist_ok=True)
+    if dst.exists() and dst.stat().st_size > 0:
+        return True, "cached"
+    skip_scale = (
+        target_width is not None
+        and source_dims is not None
+        and source_dims == (target_width, target_height)
+    )
+    vf_parts: list[str] = []
+    if target_width and not skip_scale:
+        # Center-crop source to the target's aspect ratio first, then scale.
+        # When source aspect already matches target aspect the crop is a
+        # no-op (the crop expression yields the full source dims). When
+        # they differ — e.g. landscape source → square output — this
+        # matches ytb/processed which centre-crops before resizing.
+        W, H = target_width, target_height
+        vf_parts.append(f"crop=min(iw\\,ih*{W}/{H}):min(ih\\,iw*{H}/{W})")
+        vf_parts.append(f"scale={W}:{H}")
+    elif not target_width:
+        vf_parts.append(f"scale=-2:{target_height}")
+    if target_fps and target_fps > 0 and not skip_scale:
+        vf_parts.append(f"fps={target_fps}")
+    vf = ",".join(vf_parts)
+    # Match ytb/processed pipeline: -ss BEFORE -i (fast seek), default video
+    # encoder (libx264 preset=medium crf=23 profile=high, ffmpeg's defaults),
+    # no -movflags +faststart, audio dropped (-an) since the original scraper
+    # pulled video-only mp4 in most cases.
+    cmd = ["ffmpeg", "-y", "-loglevel", "error", "-nostdin",
+           "-ss", f"{start_sec:.3f}",
+           "-i", str(src)]
+    if end_sec is not None and end_sec > start_sec:
+        cmd += ["-t", f"{end_sec - start_sec:.3f}"]
+    if vf:
+        cmd += ["-vf", vf]
+    cmd += ["-an", str(dst)]
+    res = subprocess.run(cmd, capture_output=True, text=True)
+    ok = res.returncode == 0 and dst.exists() and dst.stat().st_size > 0
+    return ok, "trimmed" if ok else f"ffmpeg failed: {(res.stderr or '')[:200]}"
+
+# ---------- pipeline ----------
+
+def process_video_group(
+    yt_id: str,
+    yt_url: str,
+    chunks: list[dict],
+    out_root: Path,
+    cache_dir: Path,
+    keep_fulls: bool,
+    dry_run: bool,
+    target_height: int = 360,
+    reference_dir: Path | None = None,
+    resolution_map: dict[str, dict] | None = None,
+    source_cap: int | None = None,
+) -> dict:
+    """Download one YouTube video then trim all its chunks.
+
+    Per-clip target (W, H, fps) lookup precedence:
+      1. resolution_map[<video_path>]            (preferred — saved JSON)
+      2. probe of reference_dir/<rel>.mp4         (live ffprobe fallback)
+      3. (None, target_height, None)              (default --height behaviour)
+
+    Source download (per yt_id):
+      - default mode (no map / no ref): cap at --height (legacy behaviour).
+      - reference mode: cap at source_cap if set, else uncapped (so portrait
+        sources whose pixel height is much larger than the clip target are
+        still selectable). ffmpeg downscales to the exact target W×H."""
+    full_path = cache_dir / f"{yt_id}.mp4"
+    result = {"youtube_id": yt_id, "url": yt_url,
+              "n_chunks": len(chunks), "ok": 0, "fail": 0, "errors": []}
+
+    ref_mode = resolution_map is not None or reference_dir is not None
+
+    # Resolve per-clip resolution targets.
+    per_clip: list[tuple[dict, int | None, int, float | None]] = []
+    for ch in chunks:
+        ref_w = ref_h = None
+        ref_fps = None
+        vp = ch["video_path"]
+        if resolution_map is not None and vp in resolution_map:
+            entry = resolution_map[vp]
+            ref_w = int(entry["width"])
+            ref_h = int(entry["height"])
+            ref_fps = float(entry["fps"]) if entry.get("fps") else None
+        elif reference_dir is not None:
+            rel = vp.replace("videos/youtube/", "")
+            probed = probe_resolution(reference_dir / rel)
+            if probed is not None:
+                ref_w, ref_h, ref_fps = probed
+        if ref_h is not None:
+            per_clip.append((ch, ref_w, ref_h, ref_fps))
+        else:
+            per_clip.append((ch, None, target_height, None))
+
+    # Source download cap.
+    if ref_mode:
+        if source_cap is not None:
+            dl_cap = source_cap
+        else:
+            # Pick the smallest YouTube tier that still fits all per-clip
+            # target heights for this yt_id. Picking a tier larger than
+            # needed forces ffmpeg to downscale and introduces sub-pixel
+            # drift in action scenes (basketball, soccer); matching the
+            # tier exactly lets us trim without rescaling.
+            target_heights = [h for _, _, h, _ in per_clip if h]
+            dl_cap = max(target_heights) if target_heights else target_height
+    else:
+        dl_cap = target_height
+    # FPS cap: ceil of max per-clip target fps, so yt-dlp picks a source
+    # whose native fps matches the trim — avoids drift from frame-dropping
+    # a 60fps source down to a 30fps target.
+    fps_cap: int | None = None
+    if ref_mode:
+        target_fpses = [fps for _, _, _, fps in per_clip if fps and fps > 0]
+        if target_fpses:
+            import math
+            fps_cap = math.ceil(max(target_fpses))
+
+    if dry_run:
+        cap_str = f"<= {dl_cap}p" if dl_cap is not None else "uncapped"
+        fps_str = f", <= {fps_cap}fps" if fps_cap is not None else ""
+        log(f"[DRY] would download {yt_url} (source {cap_str}{fps_str}) -> {full_path} "
+            f"({len(chunks)} chunks)")
+        for ch, w, h, fps in per_clip:
+            tgt = f"{w or '-2'}×{h}" + (f"@{fps:.3f}fps" if fps else "")
+            log(f"  [DRY]   {ch['video_path']} -> {tgt}")
+        return result
+
+    ok, msg = download_full(yt_url, full_path, max_height=dl_cap, max_fps=fps_cap)
+    if not ok:
+        result["fail"] = len(chunks)
+        result["errors"].append(f"download: {msg}")
+        log(f"[FAIL] {yt_id}: {msg}")
+        return result
+    cap_str = f"<= {dl_cap}p" if dl_cap is not None else "uncapped"
+    log(f"[OK ] downloaded {yt_id} ({msg}); trimming {len(chunks)} chunks "
+        f"(source {cap_str})")
+
+    src_probe = probe_resolution(full_path)
+    src_dims = (src_probe[0], src_probe[1]) if src_probe else None
+
+    for ch, ref_w, ref_h, ref_fps in per_clip:
+        rel = ch["video_path"]                          # videos/youtube/<cat>/<id>.mp4
+        dst = out_root / rel.replace("videos/youtube/", "")
+        start = ch.get("start_sec")
+        end   = ch.get("end_sec")
+        if start is None:
+            start = hms_to_sec(ch.get("start_time")) or 0.0
+        if end is None:
+            end = hms_to_sec(ch.get("end_time"))
+        ok, msg = trim_clip(
+            full_path, dst, start, end,
+            target_height=ref_h,
+            target_width=ref_w,
+            target_fps=ref_fps,
+            source_dims=src_dims,
+        )
+        if ok:
+            result["ok"] += 1
+        else:
+            result["fail"] += 1
+            result["errors"].append(f"{rel}: {msg}")
+            log(f"  [FAIL] {rel}: {msg}")
+
+    # Optionally drop the full video to save space.
+    if not keep_fulls:
+        try:
+            full_path.unlink()
+        except FileNotFoundError:
+            pass
+
+    return result
+
+def main():
+    ap = argparse.ArgumentParser(description=__doc__,
+                                 formatter_class=argparse.RawDescriptionHelpFormatter)
+    ap.add_argument("--metadata", default="youtube_metadata.json",
+                    help="path to youtube_metadata.json")
+    ap.add_argument("--out", default="videos/youtube",
+                    help="output root for trimmed clips (videos/youtube)")
+    ap.add_argument("--cache", default=".cache/full_videos",
+                    help="where to cache downloaded full videos")
+    ap.add_argument("--workers", type=int, default=2,
+                    help="parallel YouTube downloads (1 video at a time per worker)")
+    ap.add_argument("--height", type=int, default=360,
+                    help="target video height in pixels; both yt-dlp format "
+                         "selection and ffmpeg re-encode use this. VSTAT's "
+                         "original release used 360 (640x360). Default: 360")
+    ap.add_argument("--resolution-map", default=None,
+                    help="path to a JSON resolution map "
+                         "(see scripts/build_resolution_map.py). Each entry "
+                         "is keyed by `videos/youtube/<cat>/<file>.mp4` with "
+                         "{'width','height','fps'}. Clips found in the map "
+                         "are scaled to that exact W×H@fps; others fall "
+                         "back to --height.")
+    ap.add_argument("--reference-dir", default=None,
+                    help="live alternative to --resolution-map: directory "
+                         "laid out like videos/youtube/. Each run re-probes "
+                         "with ffprobe. Prefer --resolution-map.")
+    ap.add_argument("--source-cap", type=int, default=None,
+                    help="in reference mode, cap source-download height to N "
+                         "(default uncapped — required for portrait sources).")
+    ap.add_argument("--keep-fulls", action="store_true",
+                    help="keep full source videos in cache after trimming")
+    ap.add_argument("--limit", type=int, default=None,
+                    help="only process the first N YouTube videos (debug)")
+    ap.add_argument("--filter-id", action="append", default=None,
+                    help="only process given youtube_id (repeatable)")
+    ap.add_argument("--dry-run", action="store_true",
+                    help="don't download or trim — just print what would happen")
+    args = ap.parse_args()
+
+    if not have("yt-dlp"):
+        sys.exit("ERROR: yt-dlp not installed. Run: pip install -U yt-dlp")
+    if not have("ffmpeg"):
+        sys.exit("ERROR: ffmpeg not installed. Run: brew install ffmpeg  (or apt install ffmpeg)")
+    if args.reference_dir and not have("ffprobe"):
+        sys.exit("ERROR: --reference-dir requires ffprobe (ships with ffmpeg).")
+
+    reference_dir = Path(args.reference_dir).expanduser() if args.reference_dir else None
+    if reference_dir is not None and not reference_dir.is_dir():
+        sys.exit(f"ERROR: --reference-dir {reference_dir} is not a directory")
+
+    resolution_map: dict[str, dict] | None = None
+    if args.resolution_map:
+        rm_path = Path(args.resolution_map).expanduser()
+        if not rm_path.is_file():
+            sys.exit(f"ERROR: --resolution-map {rm_path} not found")
+        with open(rm_path) as fh:
+            resolution_map = json.load(fh)
+        log(f"Loaded resolution map: {len(resolution_map)} entries from {rm_path}")
+
+    meta_path = Path(args.metadata)
+    if not meta_path.exists():
+        sys.exit(f"ERROR: {meta_path} not found")
+
+    with open(meta_path) as f:
+        meta = json.load(f)
+    videos = meta.get("videos", meta if isinstance(meta, list) else [])
+    log(f"Loaded {len(videos)} chunk entries from {meta_path}")
+
+    # Group chunks by youtube_id (so each source video downloads once)
+    groups: dict[str, list[dict]] = defaultdict(list)
+    for v in videos:
+        yid = v.get("youtube_id")
+        if not yid:
+            continue
+        if args.filter_id and yid not in args.filter_id:
+            continue
+        groups[yid].append(v)
+
+    yt_ids = sorted(groups.keys())
+    if args.limit:
+        yt_ids = yt_ids[:args.limit]
+    log(f"Unique YouTube source videos: {len(yt_ids)}")
+
+    out_root  = Path(args.out)
+    cache_dir = Path(args.cache)
+    out_root.mkdir(parents=True, exist_ok=True)
+    cache_dir.mkdir(parents=True, exist_ok=True)
+
+    # Run with a worker pool
+    results: list[dict] = []
+    t0 = time.time()
+    with concurrent.futures.ThreadPoolExecutor(max_workers=max(1, args.workers)) as ex:
+        futures = []
+        for yid in yt_ids:
+            chunks = groups[yid]
+            yt_url = chunks[0]["youtube_url"]
+            futures.append(ex.submit(
+                process_video_group,
+                yid, yt_url, chunks, out_root, cache_dir,
+                args.keep_fulls, args.dry_run, args.height,
+                reference_dir, resolution_map, args.source_cap,
+            ))
+        for fut in concurrent.futures.as_completed(futures):
+            results.append(fut.result())
+
+    elapsed = time.time() - t0
+    total_ok   = sum(r["ok"]   for r in results)
+    total_fail = sum(r["fail"] for r in results)
+    n_failed_videos = sum(1 for r in results if r["fail"] > 0)
+
+    print()
+    print("=" * 60)
+    print(f"DONE in {elapsed:.1f}s")
+    print(f"  YouTube videos processed: {len(results)}")
+    print(f"  Chunks OK:                {total_ok}")
+    print(f"  Chunks FAILED:            {total_fail}")
+    print(f"  Videos with failures:     {n_failed_videos}")
+    print("=" * 60)
+
+    # Write a summary report alongside the metadata
+    report = {
+        "elapsed_seconds": elapsed,
+        "n_videos":   len(results),
+        "n_chunks_ok": total_ok,
+        "n_chunks_failed": total_fail,
+        "failures": [
+            {"youtube_id": r["youtube_id"], "url": r["url"], "errors": r["errors"]}
+            for r in results if r["fail"] > 0
+        ],
+    }
+    rp = Path("download_report.json")
+    with open(rp, "w") as f:
+        json.dump(report, f, indent=2, ensure_ascii=False)
+    log(f"\nReport -> {rp}")
+
+    if total_fail:
+        log("Some clips failed. Re-run the script to retry only the failed ones "
+            "(successful clips are skipped automatically).")
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

scripts/redact.sh

@@ -0,0 +1,134 @@
+#!/usr/bin/env bash
+#
+# VSTAT — Apply privacy redactions (black boxes) to YouTube clips.
+#
+# Coordinates are in 640x360 (post-scale) space, matching the official
+# VSTAT release. After this script runs, every redaction-target chunk
+# lives at the canonical `videos/youtube/<cat>/<id>_pt*.mp4` path with
+# the black boxes baked in. Any leftover `*_redacted.mp4` siblings from
+# earlier runs are removed.
+#
+# Usage (run from vstat/ root):
+#   ./scripts/redact.sh
+#   ./scripts/redact.sh --dry-run
+#
+
+set -eo pipefail
+
+DRY=0
+for arg in "$@"; do
+  case "$arg" in
+    --dry-run) DRY=1 ;;
+    -h|--help) sed -n '2,15p' "$0"; exit 0 ;;
+    *) echo "Unknown arg: $arg" >&2; exit 1 ;;
+  esac
+done
+
+# Format:  "<canonical-glob>|<ffmpeg drawbox filter>"
+RULES=(
+  # tennis 0001
+  "videos/youtube/tennis/0001_pt*.mp4|drawbox=x=32:y=306:w=134:h=38:color=black:t=fill"
+  # tennis 0002
+  "videos/youtube/tennis/0002_pt*.mp4|drawbox=x=32:y=306:w=134:h=38:color=black:t=fill"
+  # basketball 0002
+  "videos/youtube/basketball/0002_pt*.mp4|drawbox=x=98:y=323:w=443:h=37:color=black:t=fill"
+  # basketball 0003
+  "videos/youtube/basketball/0003_pt*.mp4|drawbox=x=22:y=285:w=125:h=63:color=black:t=fill"
+  # soccer 0002 (two boxes)
+  "videos/youtube/soccer/0002_pt*.mp4|drawbox=x=0:y=0:w=122:h=19:color=black:t=fill,drawbox=x=140:y=320:w=360:h=40:color=black:t=fill"
+)
+
+if ! command -v ffmpeg >/dev/null 2>&1; then
+  echo "ERROR: ffmpeg not installed. brew install ffmpeg / apt install ffmpeg" >&2
+  exit 1
+fi
+
+# Expand a canonical glob to the union of canonical paths it covers,
+# accounting for files that currently live with `_redacted` suffix.
+# Compatible with bash 3.2 (macOS default) — no associative arrays.
+canonical_paths_for_glob() {
+  glob="$1"
+  dir=$(dirname "$glob")
+  pat=$(basename "$glob")                          # 0001_pt*.mp4
+  shopt -s nullglob
+  results=""
+  for f in "$dir"/$pat "$dir"/${pat%.mp4}_redacted.mp4; do
+    [ -e "$f" ] || continue
+    case "$f" in
+      *_redacted.mp4) base="${f%_redacted.mp4}.mp4" ;;
+      *)              base="$f" ;;
+    esac
+    results="${results}${base}"$'\n'
+  done
+  shopt -u nullglob
+  printf '%s' "$results" | sort -u | sed '/^$/d'
+}
+
+total=0; ok=0; fail=0; missing=0
+
+for rule in "${RULES[@]}"; do
+  glob="${rule%%|*}"
+  filt="${rule#*|}"
+  echo
+  echo "=== $glob ==="
+  echo "    filter: $filt"
+
+  paths=$(canonical_paths_for_glob "$glob")
+  if [ -z "$paths" ]; then
+    echo "    (no matching files)"
+    continue
+  fi
+
+  while IFS= read -r canon; do
+    [ -z "$canon" ] && continue
+    total=$((total+1))
+    redacted_sibling="${canon%.mp4}_redacted.mp4"
+
+    # Pick input: prefer existing _redacted sibling, fall back to canonical.
+    if [ -f "$redacted_sibling" ]; then
+      input="$redacted_sibling"
+    elif [ -f "$canon" ]; then
+      input="$canon"
+    else
+      echo "  ! missing both $canon and $redacted_sibling"
+      missing=$((missing+1))
+      continue
+    fi
+
+    if [ "$DRY" -eq 1 ]; then
+      echo "  [DRY] $input  =[$filt]=>  $canon"
+      ok=$((ok+1))
+      continue
+    fi
+
+    # Write to a temp file then atomically swap.
+    # `-nostdin` is REQUIRED here: without it ffmpeg consumes characters
+    # from the surrounding `while read` loop's stdin, mangling later paths.
+    tmp="${canon%.mp4}.redact.tmp.mp4"
+    if ! ffmpeg -y -loglevel error -nostdin -i "$input" -vf "$filt" -c:a copy "$tmp"; then
+      echo "  ! ffmpeg failed: $input"
+      fail=$((fail+1))
+      continue
+    fi
+    if cp -f "$tmp" "$canon" && rm -f "$tmp"; then
+      :
+    else
+      echo "  ! could not write $canon (kept tmp at $tmp)"
+      fail=$((fail+1))
+      continue
+    fi
+    # Drop misleading `_redacted.mp4` sibling now that the canonical file
+    # holds the actually-redacted content.
+    if [ -f "$redacted_sibling" ] && [ "$redacted_sibling" != "$canon" ]; then
+      rm -f "$redacted_sibling" 2>/dev/null || true
+    fi
+    ok=$((ok+1))
+    echo "  -> $canon"
+  done <<< "$paths"
+done
+
+echo
+echo "============================================================"
+echo "  total: $total   ok: $ok   fail: $fail   missing: $missing"
+echo "============================================================"
+[ "$fail" -eq 0 ] && [ "$missing" -eq 0 ]

videos/self_recorded/book/0001_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7e23199e689bed794b92b70b163cd0cfb0d13517a76f576b6d410f4be00dc009
+size 8819418

videos/self_recorded/book/0002_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:edbd5f88761b0c984054ced5ed4bd76b701aac7437c3c80001cc7574575a0088
+size 8739866

videos/self_recorded/book/0003_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:042b5afa19aaec02e6bd25d1646007f68db69b6f97f5b6921dd91124d4c4bc47
+size 9093355

videos/self_recorded/book/0004_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4bf84cea1bb608d6061be02b5b26e70e5bfb41b0fef4ad957741c256760762ed
+size 7567652

videos/self_recorded/book/0005_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cead3f7cd00547801bbe03a387a7ae0a4adbe15a8c070e1f7be070337ad77976
+size 11909270

videos/self_recorded/book/0006_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a160b3ad466b7cf2b3c83e39c13f4161099ef2087c22ccb3350b448aad11b938
+size 9852910

videos/self_recorded/book/0007_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da759ccd0794e5d55812c9ac4bb796a115da820230fcfae0cb4886c36bec58fc
+size 11537660

videos/self_recorded/book/0008_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:eb275d1a1ad0230adb6c71812a1c792c25706745297b89937bdc696695ba802e
+size 12228041

videos/self_recorded/book/0009_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9752f371e1d844c55c6f41076f5ae66b32f6161ebc61e1113d725144c75770d5
+size 11899390

videos/self_recorded/book/0010_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df0bbc76c936cc57730cb8066ed34f57d7c411b20fa207817a2c45a3ae078a6e
+size 12259720

videos/self_recorded/cup_stacking/0001_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c8ea24a5232de154a0b42dac03d8ec8320d28a3646c0f2c84e941052905a57c3
+size 7853078

videos/self_recorded/cup_stacking/0002_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:87117666ed8c705e9b3816f51f4777e1964b19e27ee8407442a741c736f041ba
+size 6253120

videos/self_recorded/cup_stacking/0003_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b8cf6c140fd3292ca9f1b1383b8b22487012f6e139fca28f4d5ed682f1e92ff4
+size 11822179

videos/self_recorded/cup_stacking/0004_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:11c9aad87be2ac680fdd440ad0e8528b56cd3c2644902c0b46f57cbe9ddc341b
+size 10320277

videos/self_recorded/cup_stacking/0005_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e8fddf7ab1eb08252448caef9497995d97ebbf24fbcd185f6d8ee11e2158c687
+size 10564190

videos/self_recorded/cup_stacking/0006_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e1f597b2b1943a6bc2c748e15f6ba36bb08937f4367a220572345a144702f909
+size 11151561

videos/self_recorded/cup_stacking/0007_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8e685de2092186f6f762c566f2b347c06e5f21cb1a5a605b0422a35eef80f85c
+size 10928178

videos/self_recorded/cup_stacking/0008_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:bff79786e04265e1dc0ff3007689609063b41a570e12fdbb06acc4ed0528efaa
+size 11099668

videos/self_recorded/cup_stacking/0009_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:38af26c6b13133b5cb85cc08b261c3e854bd262023e63c926db0b62afbb9a081
+size 11809239

videos/self_recorded/cup_stacking/0010_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0f243f31fe60a1118a3f2bb07928b930eed9600bcd54c8bf147ce27bf5c554aa
+size 10751368

videos/self_recorded/keyboard/0001_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:29906936a7eb6aa473aaffdcad313b2274c47dd3a38fbdd5e3a5184d947f7e77
+size 3833649

videos/self_recorded/keyboard/0002_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1958f375f9c19bc3a8a06279562772fe74b29b6975834e1ce7af349fb2960ddd
+size 3930910

videos/self_recorded/keyboard/0003_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d5fb2600aadf15301ab14491aabee2a65c28f0155729ac786689dc67bd6ce6e5
+size 4514933

videos/self_recorded/keyboard/0004_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:3b661d65184e101d63bfc16ae4654aac45ea2179756877629f73d9671aa735ff
+size 6691558

videos/self_recorded/keyboard/0005_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cd87bde34474ae539e31280edd8a0d6e66c56969e086b78a07ca29e06ee56872
+size 5103554

videos/self_recorded/keyboard/0006_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d1ed94f1b83df3b27f9acf0aef97dd8347f3e2cd7cc0b7b9b8e4125168b5c7a0
+size 3997713

videos/self_recorded/keyboard/0007_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1f46486bbcf9dc3f7e3af168655909c5ef7da73e235ec2c28aff23ff1fabb53c
+size 7412067

videos/self_recorded/keyboard/0008_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d7c41db184fe0e8fda6d61296228b70ce82f39ca05bfdd2649dd070d1655c743
+size 3656426

videos/self_recorded/keyboard/0009_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f18b2035ae10fdd5297bf6727a7ce2a76dbc6a420124cac4b698b66bc277b469
+size 4440764

videos/self_recorded/keyboard/0010_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c46b378728f8450feec02eeed2dfd35dfe0b255416d67a6244b117278d94eecc
+size 6633008

videos/self_recorded/morse/0001_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c61400e0b40885eb4c01ffa9a5613395119debd0088dafba6282b29164ecc647
+size 7293389

videos/self_recorded/morse/0002_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:662e8f3b6fd3a7ace6bd54bf96f55ad5431e7f828bb0b056667a678f74b2e731
+size 6930512

videos/self_recorded/morse/0003_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4caa204c75dbc00c4950f518b6621bb30a6cfcf5700a01b6efa3543549432d2d
+size 6719657

videos/self_recorded/morse/0004_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c4dab31c514a425b01970ba9446c58aeefe8d720b6229602ad425ebfa5dd2a87
+size 6384910

videos/self_recorded/morse/0005_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4d63f6239d244eb6b071903e54efeacb21df52c4a086fae62f2d242adea43b5e
+size 6691792

videos/self_recorded/morse/0006_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:f6b96c1e8b573f20191eeb048fc82f1ea3727b1de7efb31b03c958e304b44a22
+size 8573960

videos/self_recorded/morse/0007_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6a598e3cc6ef698ddf1a0b9903d5b54e1bf91343583b15f847fcf597fbdaa06d
+size 5335238

videos/self_recorded/morse/0008_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7ac791f8f173fd0448915a557695ca2db71a90660b483abe87bac5ba8573d35c
+size 6388731

videos/self_recorded/morse/0009_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0462fa4c2091227e6718fed1cc1c373d59631eb448825e9ea2ef27fd57cb8ae9
+size 6846647

videos/self_recorded/morse/0010_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:644ee0ef91b0068e8147e4dab2a18a70a194ca39457f3a01b45755c7cdc09bb6
+size 7409935

videos/self_recorded/numberpad/0001_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8742b4eb0a5ac7306b7cc243ab989389f04e64f3bacccdabd2bd8afd73f25b8d
+size 7297044

videos/self_recorded/numberpad/0002_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:4a92a5cd88e5444e55e6d0659607eeb11cf223047ed6977bf910e60050b6fa09
+size 4085420

videos/self_recorded/numberpad/0003_pt1.mp4

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:228236f4a94a850c3f235410abc1101bcf9aa08782d831233f7bb3aab327bc63
+size 5145359