Upload folder using huggingface_hub

data_example.json

@@ -0,0 +1,27 @@
+[
+    {
+        "id": 1,
+        "type": "after_effect",
+        "after_effect_type": [
+            "light_source"
+        ],
+        "fg_object": "a hand holding a flashlight"
+    },
+    {
+        "id": 3,
+        "type": "after_effect",
+        "after_effect_type": [
+            "light_source"
+        ],
+        "fg_object": "a man"
+    },
+    {
+        "id": 5,
+        "type": "after_effect",
+        "after_effect_type": [
+            "shadow",
+            "reflection"
+        ],
+        "fg_object": "a insect"
+    }
+]

eval.py

@@ -0,0 +1,567 @@
+import os
+import time
+import json
+import re
+import hashlib
+import argparse
+from pathlib import Path
+
+import cv2
+from google import genai
+from google.genai import types
+
+MODEL = "gemini-3.1-pro-preview"
+FPS = 1.0
+TARGET_W = 720
+TARGET_H = 480
+VIDEO_EXTENSIONS = {".mp4", ".mov", ".avi", ".mkv", ".webm"}
+
+PROMPT_TEMPLATE = """
+You are an expert computer vision judge evaluating a video object removal
+task using THREE separate videos.
+
+The three videos provided represent:
+INPUT Video: The original reference video where the target object and its
+aftereffects ARE PRESENT.
+GT Video (Ground Truth): The IDEAL result video where the object and
+aftereffects are perfectly removed, showing the true background
+across all frames.
+RESULT Video: Our method’s output video. Your goal is to evaluate how
+well the RESULT video removes the target object and reconstructs a
+plausible, natural background.
+
+Context for this sample:
+Target object (present in INPUT; absent in GT): {fg_object}
+Aftereffect types to check: {focus_effect}
+
+EVALUATION PROCESS (THINKING STEPS)
+Before scoring, you MUST output a step-by-step reasoning process using
+the following structure:
+Step 1: Target Identification: Watch the INPUT video and identify the
+exact appearance, movement, and location of the Target Object ({fg_object})
+and its Aftereffects ({focus_effect}).
+Step 2: Expected Background Pattern (GT Analysis): Watch the GT video.
+Understand the general context, texture, and lighting of the
+background where the object used to be.
+Step 3: Output vs GT Comparison (Naturalness Check): Compare the RESULT
+video against the GT. Evaluate the inpainted area. Does the filled
+background look natural and fit the surrounding scene harmoniously?
+Did the model successfully create a clean background, or did it
+hallucinate a new foreground object?
+Step 4: Error Categorization: Determine which identified differences are
+related to the main Target Object removal, and which are related to
+the Aftereffect removal. Find the specific flaws based on the rubrics
+below.
+
+SCORING RUBRICS (1-5 Scale)
+HUMAN-LIKE JUDGING GUIDELINES:
+- Humans care most about SEMANTIC removal. If the identifiable features
+of the target object are gone, humans consider the removal mostly
+successful (Score 4), EVEN IF a blurry smudge or a dark moving blob
+is left behind.
+- A score of 3 should be reserved for partial temporal failures or when a
+small piece of the object remains.
+- Punish heavily (Scores 1-2) ONLY if the object is fully visible for a
+long time, if the model hallucinates a completely new recognizable
+object, or if the artifact left behind is grotesquely out of place.
+
+ObjectScore Rubric (How well the main target object was removed):
+5 Points: Perfect or Near Perfect. The object is completely removed. The
+inpainted background seamlessly matches the GT. Minor, almost
+unnoticeable imperfections are acceptable.
+4 Points: Good (Forgiving of Smudges). The core semantic features of the
+target object are completely gone. The inpainted area might contain
+noticeable smudges, blurriness, or dark moving blobs, but it does not
+severely break the overall geometry of the scene. The human eye
+forgives these as long as the object itself is unrecognizable.
+3 Points: Fair (Partial/Distracting). The removal is flawed but not a
+total failure. Use this if: 1) A small but recognizable part of the
+object remains. 2) Temporal failure: The object is removed, but
+suddenly reappears for a few frames. 3) The object is gone, but the
+artifact left behind is highly distracting and physically illogical
+for the scene.
+2 Points: Poor. Huge remnants of the target object are still clearly
+visible and moving. OR the model hallucinated a completely new,
+identifiable foreground object that completely ruins the background.
+1 Point: Fail. The object is practically untouched and fully visible for
+the majority of the video, or the generated artifacts cause extreme,
+video-breaking corruption.
+
+AftereffectScore Rubric (How well object-caused effects like shadows/
+reflections were removed):
+5 Points: Perfect. The aftereffect is completely removed, matching the GT
+seamlessly.
+4 Points: Good. Aftereffect is successfully removed and the area looks
+natural, even if lighting/texture slightly differs from the exact GT.
+3 Points: Fair. Aftereffect area is noticeably blurry, smudged, or
+improperly lit compared to the rest of the scene.
+2 Points: Poor. Severe visual artifacts in the aftereffect region.
+1 Point: Fail. The aftereffect is still clearly visible in the RESULT
+video, completely ignored by the removal process.
+
+OUTPUT FORMAT
+You MUST format your response exactly like this:
+Reasoning:
+Step 1: [Your reasoning]
+Step 2: [Your reasoning]
+Step 3: [Your reasoning]
+Step 4: [Your reasoning]
+AftereffectScore: X, ObjectScore: Y
+"""
+
+
+def natural_key(value):
+    return [
+        int(token) if token.isdigit() else token.lower()
+        for token in re.split(r"(\d+)", str(value))
+    ]
+
+
+def normalize_id(value):
+    value = str(value)
+
+    if value.isdigit():
+        return str(int(value))
+
+    return value
+
+
+def get_video_fps(cap):
+    fps = cap.get(cv2.CAP_PROP_FPS)
+
+    if fps is None or fps <= 0 or fps != fps:
+        return 25.0
+
+    return float(fps)
+
+
+def resize_video(src_path, preproc_dir):
+    src_path = Path(src_path)
+    preproc_dir.mkdir(parents=True, exist_ok=True)
+
+    stat = src_path.stat()
+    fingerprint = hashlib.sha1(
+        f"{src_path.resolve()}_{stat.st_size}_{stat.st_mtime_ns}".encode()
+    ).hexdigest()[:16]
+
+    output_path = preproc_dir / (
+        f"{src_path.stem}_{fingerprint}_{TARGET_W}x{TARGET_H}.mp4"
+    )
+
+    if output_path.exists() and output_path.stat().st_size > 0:
+        return output_path
+
+    cap = cv2.VideoCapture(str(src_path))
+
+    if not cap.isOpened():
+        raise RuntimeError(f"Could not open video: {src_path}")
+
+    output_fps = get_video_fps(cap)
+
+    writer = cv2.VideoWriter(
+        str(output_path),
+        cv2.VideoWriter_fourcc(*"mp4v"),
+        output_fps,
+        (TARGET_W, TARGET_H),
+    )
+
+    if not writer.isOpened():
+        cap.release()
+        raise RuntimeError(f"Could not create output video: {output_path}")
+
+    try:
+        while True:
+            success, frame = cap.read()
+
+            if not success:
+                break
+
+            resized = cv2.resize(
+                frame,
+                (TARGET_W, TARGET_H),
+                interpolation=cv2.INTER_AREA,
+            )
+
+            writer.write(resized)
+
+    finally:
+        cap.release()
+        writer.release()
+
+    if not output_path.exists() or output_path.stat().st_size == 0:
+        raise RuntimeError(f"Resized video was not created: {output_path}")
+
+    return output_path
+
+
+def upload_and_wait(client, file_path, timeout_seconds=180):
+    uploaded_file = client.files.upload(file=str(file_path))
+    deadline = time.time() + timeout_seconds
+
+    while True:
+        remote_file = client.files.get(name=uploaded_file.name)
+        state = getattr(remote_file.state, "name", str(remote_file.state))
+
+        if state == "ACTIVE":
+            part = types.Part(
+                file_data=types.FileData(
+                    file_uri=remote_file.uri,
+                    mime_type=remote_file.mime_type or "video/mp4",
+                ),
+                video_metadata=types.VideoMetadata(fps=FPS),
+            )
+            return remote_file, part
+
+        if state in {"FAILED", "DELETED"}:
+            raise RuntimeError(
+                f"Video processing failed on Gemini: {file_path}"
+            )
+
+        if time.time() > deadline:
+            raise TimeoutError(
+                f"Video upload timed out: {file_path}"
+            )
+
+        time.sleep(2)
+
+
+def delete_remote_file(client, remote_file):
+    if remote_file is None:
+        return
+
+    try:
+        client.files.delete(name=remote_file.name)
+    except Exception:
+        pass
+
+
+def generate_with_retry(client, contents, max_attempts=5):
+    wait_seconds = 20
+    last_error = None
+
+    for attempt in range(1, max_attempts + 1):
+        try:
+            return client.models.generate_content(
+                model=MODEL,
+                contents=contents,
+                config=types.GenerateContentConfig(
+                    temperature=0.0
+                ),
+            )
+
+        except Exception as error:
+            last_error = error
+            error_text = str(error).lower()
+
+            retryable = any(
+                keyword in error_text
+                for keyword in [
+                    "429",
+                    "500",
+                    "502",
+                    "503",
+                    "504",
+                    "unavailable",
+                    "high demand",
+                    "rate limit",
+                    "resource exhausted",
+                    "internal error",
+                ]
+            )
+
+            if not retryable or attempt == max_attempts:
+                raise
+
+            print(
+                f"    Retry {attempt}/{max_attempts}: {error}"
+            )
+
+            time.sleep(wait_seconds)
+            wait_seconds = min(wait_seconds * 2, 180)
+
+    raise RuntimeError(f"Gemini request failed: {last_error}")
+
+
+def get_sample_id(video_path, root_dir, is_result=False):
+    relative = video_path.relative_to(root_dir).with_suffix("")
+    sample_id = relative.as_posix()
+
+    if is_result and sample_id.endswith("_remove"):
+        sample_id = sample_id[:-7]
+
+    if "/" not in sample_id:
+        sample_id = normalize_id(sample_id)
+
+    return sample_id
+
+
+def build_video_index(folder, is_result=False):
+    index = {}
+
+    for path in folder.rglob("*"):
+        if not path.is_file():
+            continue
+
+        if path.suffix.lower() not in VIDEO_EXTENSIONS:
+            continue
+
+        sample_id = get_sample_id(path, folder, is_result)
+
+        if sample_id not in index:
+            index[sample_id] = path
+            continue
+
+        current_name = index[sample_id].stem
+        candidate_name = path.stem
+
+        if candidate_name == sample_id and current_name != sample_id:
+            index[sample_id] = path
+
+    return index
+
+
+def load_metadata(data_json_path):
+    with open(data_json_path, "r", encoding="utf-8") as file:
+        raw_data = json.load(file)
+
+    metadata = {}
+
+    for item in raw_data:
+        sample_id = normalize_id(item["id"])
+        metadata[sample_id] = item
+
+    return metadata
+
+
+def load_results(output_path):
+    if not output_path.exists():
+        return []
+
+    try:
+        with open(output_path, "r", encoding="utf-8") as file:
+            data = json.load(file)
+
+        if isinstance(data, list):
+            return data
+
+    except json.JSONDecodeError:
+        pass
+
+    return []
+
+
+def save_results(output_path, results):
+    temp_path = output_path.with_suffix(".tmp")
+
+    with open(temp_path, "w", encoding="utf-8") as file:
+        json.dump(results, file, ensure_ascii=False, indent=2)
+
+    temp_path.replace(output_path)
+
+
+def parse_score(text, field_name):
+    match = re.search(
+        rf"{field_name}\s*:\s*([1-5])",
+        text,
+        flags=re.IGNORECASE,
+    )
+
+    if match:
+        return int(match.group(1))
+
+    return None
+
+
+def evaluate_sample(
+    client,
+    sample_id,
+    fg_path,
+    bg_path,
+    result_path,
+    item_data,
+    preproc_dir,
+):
+    remote_fg = None
+    remote_bg = None
+    remote_result = None
+
+    fg_object = str(item_data["fg_object"])
+    effects = item_data["after_effect_type"]
+
+    if isinstance(effects, list):
+        focus_effect = ", ".join(map(str, effects))
+    else:
+        focus_effect = str(effects)
+
+    try:
+        fg_720 = resize_video(fg_path, preproc_dir)
+        bg_720 = resize_video(bg_path, preproc_dir)
+        result_720 = resize_video(result_path, preproc_dir)
+
+        remote_fg, part_fg = upload_and_wait(client, fg_720)
+        remote_bg, part_bg = upload_and_wait(client, bg_720)
+        remote_result, part_result = upload_and_wait(client, result_720)
+
+        prompt = PROMPT_TEMPLATE.format(
+            fg_object=fg_object,
+            focus_effect=focus_effect,
+        )
+
+        contents = [
+            "INPUT VIDEO",
+            part_fg,
+            "GT VIDEO",
+            part_bg,
+            "RESULT VIDEO",
+            part_result,
+            prompt,
+        ]
+
+        response = generate_with_retry(client, contents)
+        model_output = response.text or ""
+
+        return {
+            "id": sample_id,
+            "fg_object": fg_object,
+            "after_effects": focus_effect,
+            "fg_video": str(fg_path),
+            "bg_video": str(bg_path),
+            "result_video": str(result_path),
+            "ObjectScore": parse_score(model_output, "ObjectScore"),
+            "AftereffectScore": parse_score(
+                model_output,
+                "AftereffectScore",
+            ),
+            "model_output": model_output,
+            "status": "ok",
+        }
+
+    except Exception as error:
+        return {
+            "id": sample_id,
+            "fg_object": fg_object,
+            "after_effects": focus_effect,
+            "fg_video": str(fg_path),
+            "bg_video": str(bg_path),
+            "result_video": str(result_path),
+            "status": "error",
+            "error": str(error),
+        }
+
+    finally:
+        delete_remote_file(client, remote_fg)
+        delete_remote_file(client, remote_bg)
+        delete_remote_file(client, remote_result)
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--root", type=str, default=".")
+    parser.add_argument(
+        "--api_key",
+        type=str,
+        default=os.getenv("GEMINI_API_KEY"),
+    )
+    args = parser.parse_args()
+
+    if not args.api_key:
+        raise RuntimeError(
+            "API key was not found. Set GEMINI_API_KEY or use --api_key."
+        )
+
+    root_dir = Path(args.root)
+    fg_dir = root_dir / "fg"
+    bg_dir = root_dir / "bg"
+    result_dir = root_dir / "result"
+    data_json_path = root_dir / "data.json"
+    preproc_dir = root_dir / "_preproc_720x480"
+    output_path = root_dir / "core_evaluation_results.json"
+
+    for folder in [fg_dir, bg_dir, result_dir]:
+        if not folder.is_dir():
+            raise FileNotFoundError(
+                f"Required folder was not found: {folder}"
+            )
+
+    if not data_json_path.exists():
+        raise FileNotFoundError(
+            f"data.json was not found: {data_json_path}"
+        )
+
+    client = genai.Client(api_key=args.api_key)
+    metadata = load_metadata(data_json_path)
+
+    fg_index = build_video_index(fg_dir)
+    bg_index = build_video_index(bg_dir)
+    result_index = build_video_index(result_dir, is_result=True)
+
+    common_ids = sorted(
+        set(fg_index) & set(bg_index) & set(result_index),
+        key=natural_key,
+    )
+
+    existing_results = load_results(output_path)
+
+    completed_ids = {
+        normalize_id(result["id"])
+        for result in existing_results
+        if result.get("status") == "ok"
+    }
+
+    print(f"Matched fg/bg/result video triples: {len(common_ids)}")
+
+    for index, sample_id in enumerate(common_ids, start=1):
+        normalized_id = normalize_id(sample_id)
+
+        if normalized_id not in metadata:
+            print(
+                f"[{index}/{len(common_ids)}] "
+                f"{sample_id}: not found in data.json, skipping."
+            )
+            continue
+
+        if normalized_id in completed_ids:
+            print(
+                f"[{index}/{len(common_ids)}] "
+                f"{sample_id}: already completed, skipping."
+            )
+            continue
+
+        print(
+            f"[{index}/{len(common_ids)}] "
+            f"{sample_id}: starting Gemini evaluation."
+        )
+
+        record = evaluate_sample(
+            client=client,
+            sample_id=normalized_id,
+            fg_path=fg_index[sample_id],
+            bg_path=bg_index[sample_id],
+            result_path=result_index[sample_id],
+            item_data=metadata[normalized_id],
+            preproc_dir=preproc_dir,
+        )
+
+        existing_results.append(record)
+        save_results(output_path, existing_results)
+
+        if record["status"] == "ok":
+            print(
+                f"[{index}/{len(common_ids)}] "
+                f"{sample_id}: completed | "
+                f"ObjectScore={record['ObjectScore']} | "
+                f"AftereffectScore={record['AftereffectScore']}"
+            )
+        else:
+            print(
+                f"[{index}/{len(common_ids)}] "
+                f"{sample_id}: failed | {record['error']}"
+            )
+
+        time.sleep(1)
+
+    print(f"Evaluation completed. Results saved to: {output_path}")
+
+
+if __name__ == "__main__":
+    main()

masks/1.mp4

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

masks/10.mp4

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

masks/100.mp4

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

masks/102.mp4

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

masks/103.mp4

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

masks/11.mp4

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

masks/110.mp4

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

masks/111.mp4

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

masks/112.mp4

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

masks/113.mp4

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

masks/114.mp4

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

masks/115.mp4

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

masks/116.mp4

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

masks/117.mp4

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

masks/118.mp4

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

masks/119.mp4

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

masks/120.mp4

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

masks/121.mp4

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

masks/122.mp4

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

masks/123.mp4

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

masks/124.mp4

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

masks/125.mp4

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

masks/126.mp4

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

masks/127.mp4

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

masks/128.mp4

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

masks/129.mp4

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

masks/13.mp4

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

masks/130.mp4

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

masks/131.mp4

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

masks/132.mp4

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

masks/133.mp4

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

masks/134.mp4

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

masks/135.mp4

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

masks/136.mp4

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

masks/137.mp4

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

masks/138.mp4

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

masks/139.mp4

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

masks/140.mp4

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

masks/141.mp4

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

masks/142.mp4

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

masks/143.mp4

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

masks/150.mp4

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

masks/151.mp4

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

masks/152.mp4

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

masks/157.mp4

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

masks/158.mp4

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

masks/16.mp4

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