chunklate 0.1.0__py3-none-any.whl

Chunklate.py

@@ -0,0 +1,2578 @@
+#!/usr/bin/env python3
+from argparse import ArgumentParser, SUPPRESS
+from datetime import datetime
+import os
+import sys
+
+
+def Local_Venv_Python(script_path=None, *, os_name=None):
+    root = os.path.dirname(os.path.abspath(script_path or __file__))
+    os_name = os.name if os_name is None else os_name
+    if os_name == "nt":
+        candidate = os.path.join(root, ".venv", "Scripts", "python.exe")
+    else:
+        candidate = os.path.join(root, ".venv", "bin", "python")
+    if os.path.exists(candidate):
+        return candidate
+    return None
+
+
+def Should_Reexec_Local_Venv(script_path=None, executable=None, env=None):
+    env = env if env is not None else os.environ
+    if env.get("CHUNKLATE_NO_VENV_REEXEC"):
+        return False
+    venv_python = Local_Venv_Python(script_path)
+    if not venv_python:
+        return False
+    current = executable or sys.executable
+    return os.path.normcase(os.path.abspath(current)) != os.path.normcase(os.path.abspath(venv_python))
+
+
+def Maybe_Reexec_Local_Venv():
+    if __name__ != "__main__" or not Should_Reexec_Local_Venv():
+        return
+    venv_python = Local_Venv_Python()
+    os.execv(venv_python, [venv_python, os.path.abspath(__file__), *sys.argv[1:]])
+
+
+Maybe_Reexec_Local_Venv()
+
+MISSING_IMPORT_ERRORS = {}
+
+try:
+    from PIL import Image,ImageShow,ImageTk
+except ImportError as exc:
+    MISSING_IMPORT_ERRORS["Pillow"] = exc
+    Image = ImageShow = ImageTk = None
+
+try:
+    from inputimeout import TimeoutOccurred, inputimeout
+except ImportError as exc:
+    MISSING_IMPORT_ERRORS["inputimeout"] = exc
+    TimeoutOccurred = TimeoutError
+    def inputimeout(prompt="", timeout=None):
+        return input(prompt)
+
+try:
+    import numpy as np
+except ImportError as exc:
+    MISSING_IMPORT_ERRORS["numpy"] = exc
+    np = None
+
+try:
+    import tkinter
+except ImportError as exc:
+    MISSING_IMPORT_ERRORS["tkinter"] = exc
+    tkinter = None
+
+import random, time, zlib, io, inspect, types, collections, itertools, shutil, shlex, subprocess
+
+try:
+    import cv2
+except ImportError as exc:
+    MISSING_IMPORT_ERRORS["opencv-python"] = exc
+    cv2 = None
+
+try:
+    import psutil
+except ImportError as exc:
+    MISSING_IMPORT_ERRORS["psutil"] = exc
+    psutil = None
+
+try:
+    import imagehash
+except ImportError as exc:
+    MISSING_IMPORT_ERRORS["ImageHash"] = exc
+    imagehash = None
+
+try:
+    import colorama
+except ImportError as exc:
+    MISSING_IMPORT_ERRORS["colorama"] = exc
+    colorama = None
+
+from chunklate import ancillary, ancillary_runtime, bruteforce, checkpoint, checkpoint_actions_runtime, checkpoint_runtime, chunk_info, chunk_name_runtime, chunk_order, chunk_order_runtime, chunk_report, chunk_scanner, chunk_state, chunk_state_runtime, chunk_story, chunk_validation_runtime, cli, decisions, dummy_chunk, dummy_chunk_runtime, error_log, fixit_felix, fixit_felix_runtime, full_chunk_forcer, getinfo_runtime, getspec_runtime, history, image_viewer, libpng_check, libpng_runtime, magic_runtime, main_runtime, name_shift, name_shift_runtime, nearby, nearby_runtime, output, package_update, palette, palette_runtime, palette_ui, platform_runtime, prompts, question_runtime, relics, relics_runtime, relics_ui, runtime_state, smash_bruteforce, sorting, spec_length_runtime, specs, stdio, ui, ui_runtime, ultimate_reference_ui, writer, writer_runtime, youshallpass_runtime
+from chunklate.png import (
+    chunk_type_crc_matches,
+    detect_png_signature_recovery,
+    legacy_crc_checkpoint_args,
+    legacy_crc_decision,
+    legacy_crc_debug_lines,
+    legacy_crc_monkey_lines,
+    legacy_find_magic_checkpoint_args,
+    legacy_length_checkpoint_args,
+    legacy_length_decision,
+    validate_png_structure,
+)
+
+
+RUNTIME_IMPORTS = (
+    ("Pillow", "PIL.Image/PIL.ImageTk", lambda: Image is not None and ImageShow is not None and ImageTk is not None),
+    ("inputimeout", "inputimeout", lambda: "inputimeout" not in MISSING_IMPORT_ERRORS),
+    ("numpy", "numpy", lambda: np is not None),
+    ("opencv-python", "cv2", lambda: cv2 is not None),
+    ("psutil", "psutil", lambda: psutil is not None),
+    ("ImageHash", "imagehash", lambda: imagehash is not None),
+    ("python3-tk", "tkinter", lambda: tkinter is not None),
+    ("colorama", "colorama", lambda: colorama is not None),
+)
+
+
+def Missing_Runtime_Dependencies():
+    missing = []
+    for package, import_name, is_available in RUNTIME_IMPORTS:
+        if not is_available():
+            missing.append((package, import_name, MISSING_IMPORT_ERRORS.get(package)))
+    return tuple(missing)
+
+
+def Format_Missing_Runtime_Dependencies(missing, *, os_name=None):
+    os_name = os.name if os_name is None else os_name
+    root = os.path.dirname(os.path.abspath(__file__))
+    bootstrap_command = Bootstrap_Command(os_name=os_name)
+    local_python = Local_Venv_Python(os_name=os_name) or platform_runtime.local_venv_python(root, os_name=os_name)
+    run_command = platform_runtime.format_command(
+        [local_python, os.path.abspath(__file__), "-f", "<file>"],
+        os_name=os_name,
+    )
+    lines = [
+        "Missing runtime dependencies; Chunklate cannot safely continue.",
+        "",
+        "Missing imports:",
+    ]
+    for package, import_name, error in missing:
+        lines.append("- %s (import %s)" % (package, import_name))
+        if error is not None:
+            lines.append("  error: %s" % error)
+    lines.extend(
+        [
+            "",
+            "Install/refresh the local virtual environment with:",
+            "  %s" % platform_runtime.format_command(bootstrap_command, os_name=os_name),
+            "",
+            "Then run Chunklate with:",
+            "  %s" % run_command,
+        ]
+    )
+    if any(package == "python3-tk" for package, _, _ in missing) and os_name != "nt":
+        lines.extend(
+            [
+                "",
+                "Tkinter is a system Python module on many Linux distributions.",
+                "On Debian/Ubuntu install it with: sudo apt install python3-tk",
+            ]
+        )
+    elif any(package == "python3-tk" for package, _, _ in missing):
+        lines.extend(
+            [
+                "",
+                "Tkinter is normally installed by the official Python for Windows installer.",
+                "Repair or reinstall Python with the Tcl/Tk option enabled if tkinter is missing.",
+            ]
+        )
+    return "\n".join(lines)
+
+
+def Bootstrap_Script_Path(script_path=None, *, os_name=None):
+    root = os.path.dirname(os.path.abspath(script_path or __file__))
+    return platform_runtime.bootstrap_python_script(
+        root,
+        os_name=os.name if os_name is None else os_name,
+    )
+
+
+def Bootstrap_Command(script_path=None, *, os_name=None):
+    root = os.path.dirname(os.path.abspath(script_path or __file__))
+    return platform_runtime.bootstrap_command(
+        root,
+        executable=sys.executable,
+        os_name=os.name if os_name is None else os_name,
+    )
+
+
+def Can_Prompt_Dependency_Install(stdin=None):
+    stream = stdin or sys.stdin
+    return (
+        not NODIALOGUE
+        and not AUTO
+        and hasattr(stream, "isatty")
+        and stream.isatty()
+    )
+
+
+def Prompt_Dependency_Install(missing, *, input_func=input, stdin=None, runner=subprocess.run):
+    print(Format_Missing_Runtime_Dependencies(missing), file=sys.stderr)
+    if not Can_Prompt_Dependency_Install(stdin):
+        return False
+
+    answer = input_func("Install/refresh missing dependencies now? (yes/no): ").strip().lower()
+    if answer not in ("y", "yes"):
+        return False
+
+    command = Bootstrap_Command()
+    print("Running: %s" % platform_runtime.format_command(command), file=sys.stderr)
+    result = runner(command, cwd=os.path.dirname(os.path.abspath(__file__)))
+    return getattr(result, "returncode", 0) == 0
+
+
+def Reexec_Local_Venv_Or_Exit():
+    venv_python = Local_Venv_Python()
+    if not venv_python:
+        print("Dependency install finished, but .venv Python was not found.", file=sys.stderr)
+        sys.exit(1)
+    os.execv(venv_python, [venv_python, os.path.abspath(__file__), *sys.argv[1:]])
+
+
+def Configure_Terminal_Color():
+    global USE_COLOR
+    platform_runtime.configure_text_stream_errors(sys.stdout, sys.stderr)
+    decision = platform_runtime.decide_terminal_color(
+        COLOR_MODE,
+        stream=sys.stdout,
+        os_name=os.name,
+        platform=sys.platform,
+        colorama_module=colorama,
+    )
+    USE_COLOR = decision.use_color
+    return decision
+
+
+def Ensure_Runtime_Dependencies(*, prompt_installer=Prompt_Dependency_Install, reexec=Reexec_Local_Venv_Or_Exit):
+    missing = Missing_Runtime_Dependencies()
+    if missing:
+        if prompt_installer(missing):
+            reexec()
+            return True
+        sys.exit(1)
+    return True
+
+
+def Check_Package_Update(*, current_version=None, fetch_latest=package_update.latest_pypi_version):
+    return package_update.check_package_update(
+        current_version=current_version,
+        fetch_latest=fetch_latest,
+    )
+
+
+def Format_Package_Update_Message(status):
+    return package_update.format_update_message(status, python_executable=sys.executable)
+
+
+def Should_Run_Package_Update_Check(args, *, argv0=None):
+    if bool(getattr(args, "NO_UPDATE_CHECK", False)):
+        return False
+    return True
+
+
+def Can_Prompt_Package_Update(stdin=None):
+    stream = stdin or sys.stdin
+    return (
+        not NODIALOGUE
+        and not AUTO
+        and hasattr(stream, "isatty")
+        and stream.isatty()
+    )
+
+
+def Prompt_Package_Update_Continue(status, *, input_func=input, stdin=None, stream=None):
+    if not status.update_available:
+        return True
+    out = stream or sys.stderr
+    print(Format_Package_Update_Message(status), file=out)
+    if not Can_Prompt_Package_Update(stdin):
+        print("Continuing with the installed version.", file=out)
+        return True
+    while True:
+        answer = input_func("Continue with this older Chunklate anyway? (yes/no): ").strip().lower()
+        if answer in ("y", "yes"):
+            return True
+        if answer in ("n", "no"):
+            return False
+        print("I need yes or no before continuing with an older package.", file=out)
+
+
+def Ensure_Package_Current_Or_Continue(
+    *,
+    checker=Check_Package_Update,
+    prompt_continue=Prompt_Package_Update_Continue,
+    exit_process=sys.exit,
+):
+    status = checker()
+    if status.up_to_date is None:
+        return True
+    if prompt_continue(status):
+        return True
+    exit_process(1)
+    return False
+
+
+def Betterror(error_msg, def_name): ##useless since 3.11
+    return error_log.betterror_from_namespace(globals(), error_msg, def_name)
+
+
+def Error_Log(Err_to_log):
+    return error_log.append_error_log_from_namespace(globals(), Err_to_log)
+
+
+# Relics state model:
+# - PandoraBox holds current-file findings that still need a decision or repair.
+#   Keys look like "Function_Error_N:message"; values are "<Chunk>_Tool_N" dicts.
+# - Cornucopia holds fixes already accepted by CheckPoint/FixItFelix.
+# - WriteClone snapshots those two stores into Pandemonium/ArkOfCovenant so
+#   Relics can react to the repair history when libpng reports a later failure.
+def CheckPoint_Record_Finding(registration):
+    if registration.side_note is not None:
+        SideNotes.append(registration.side_note)
+    return relics.record_checkpoint_registration(PandoraBox, Cornucopia, registration)
+
+
+def CheckPoint_Apply_Flags(flags):
+    if not flags:
+        return
+    globals().update(flags)
+
+
+def CheckPoint_Print_Libpng_Critical(info):
+    PRINT("\n-\033[1;31;49mCriticalHit\033[m: %s" % info)
+
+
+def CheckPoint_Discard_Libpng_Warning():
+    for nb, key in enumerate(PandoraBox):
+        if "libpng warning:" in str(key):
+            relics.discard_pandora_error(PandoraBox, key)
+            SideNotes.append("-Found False-Positive :[Error:-%s]." % (str(key)))
+            break
+
+
+def CheckPoint_Libpng_End_Success(message):
+    saved_path = Current_Display_Image_Path()
+    visual_reference_note = Final_Image_Visual_Reference_Note(saved_path)
+    if visual_reference_note:
+        Candy(
+            "Cowsay",
+            visual_reference_note,
+            "com",
+        )
+        SideNotes.append("-Visual reference route: %s" % visual_reference_note)
+        PRINT("-Visual reference route: %s" % visual_reference_note)
+        TheEnd()
+        return
+
+    Candy(
+        "Cowsay",
+        message,
+        "good",
+    )
+    Candy("Cowsay", "Your file is here: %s" % saved_path, "good")
+    PRINT(Candy("Color", "green", "-Saved in : %s") % saved_path)
+    Open_Final_Image_Once(saved_path)
+    TheEnd()
+
+
+def _Valid_Png_Path(path):
+    if not path or not os.path.exists(path):
+        return False
+    try:
+        with open(path, "rb") as file:
+            return validate_png_structure(output.clone_bytes(file.read())).ok
+    except (OSError, ValueError):
+        return False
+
+
+def Current_Display_Image_Path():
+    sample_dir = output.clone_folder(FILE_Origin, FILE_DIR)
+    clone_path = os.path.join(sample_dir, Sample_Name) if Sample_Name else ""
+    if SAVE_COUNT > 0:
+        candidates = (clone_path, Sample, FILE_Origin)
+    else:
+        candidates = (Sample, FILE_Origin)
+    for path in candidates:
+        if _Valid_Png_Path(path):
+            return path
+    for path in candidates:
+        if path:
+            return path
+    return ""
+
+
+def _Load_Rgba_Image(path):
+    if Image is None or not path:
+        return None
+    try:
+        with Image.open(path) as image:
+            return image.convert("RGBA")
+    except Exception:
+        return None
+
+
+def Final_Image_Visual_Reference_Note(path):
+    reference_path = Ultimate_Linefeed_Reference()
+    if not reference_path:
+        return ""
+    if not _Valid_Png_Path(path):
+        return ""
+    if not os.path.exists(reference_path):
+        return "PNG is structurally valid; visual repair needs a reference/ROI, but the configured reference is missing: %s." % reference_path
+
+    candidate = _Load_Rgba_Image(path)
+    reference = _Load_Rgba_Image(reference_path)
+    if candidate is None or reference is None:
+        return "PNG is structurally valid; visual repair needs a reference/ROI, but I could not decode the configured reference."
+    if candidate.size != reference.size:
+        return "PNG is structurally valid; visual mismatch detected against the reference size %s vs %s; repair needs reference/ROI." % (
+            candidate.size,
+            reference.size,
+        )
+    if candidate.tobytes() != reference.tobytes():
+        return "PNG is structurally valid; visual mismatch detected against the reference; repair needs reference/ROI."
+    return ""
+
+
+def Open_Final_Image_Once(path):
+    global FINAL_IMAGE_OPEN_REQUESTED
+
+    if FINAL_IMAGE_OPEN_REQUESTED:
+        return None
+    if Has_Unresolved_Findings():
+        return None
+    if not _Valid_Png_Path(path):
+        return None
+    if SAVE_COUNT == 0 and path in (Sample, FILE_Origin):
+        Candy(
+            "Cowsay",
+            "Wtf... why did you give that to me? It's perfect!",
+            "good",
+        )
+    FINAL_IMAGE_OPEN_REQUESTED = True
+    return Open_Final_Image(path)
+
+
+def Open_Current_Final_Image_If_Valid():
+    return Open_Final_Image_Once(Current_Display_Image_Path())
+
+
+def Has_Unresolved_Findings():
+    return bool(PandoraBox)
+
+
+def Open_Final_Image(path, emit=None):
+    emit = PRINT if emit is None else emit
+    if not sys.stdout.isatty():
+        return None
+    try:
+        with open(path, "rb") as file:
+            validation = validate_png_structure(output.clone_bytes(file.read()))
+    except (OSError, ValueError):
+        validation = None
+    if validation is None or not validation.ok:
+        emit(Candy("Color", "yellow", "-Not opening image automatically: PNG structure is not valid."))
+        return None
+
+    result = image_viewer.open_image(path)
+    if result.success:
+        emit(Candy("Color", "green", "-Opening image with : %s") % result.opener)
+    else:
+        emit(Candy("Color", "yellow", "-Could not open image automatically: %s") % result.error)
+    return result
+
+
+ACTIVE_PREVIEW_IMAGE = None
+LAST_PROGRESS_LINE = ""
+PREVIEW_OUTPUT_FOLDER = "Bruteforce_Previews"
+
+
+def Close_Preview_Image():
+    global ACTIVE_PREVIEW_IMAGE
+
+    preview = ACTIVE_PREVIEW_IMAGE
+    ACTIVE_PREVIEW_IMAGE = None
+    if preview is None:
+        return False
+    close = getattr(preview, "close", None)
+    if close is None:
+        return False
+    try:
+        return bool(close())
+    except Exception:
+        return False
+
+
+def Preview_Repair_Image(data, label, *, show=True, emit=None, announce=True):
+    global ACTIVE_PREVIEW_IMAGE
+
+    emit = PRINT if emit is None else emit
+    Close_Preview_Image()
+    preview_bytes = output.clone_bytes(data)
+    validation = validate_png_structure(preview_bytes)
+    if not validation.ok:
+        emit(Candy("Color", "yellow", "-Preview skipped: PNG structure is not valid."))
+        return None
+
+    folder = output.ensure_clone_folder(FILE_Origin, FILE_DIR)
+    safe_label = "".join(
+        char if char.isalnum() or char in ("-", "_", ".") else "_"
+        for char in str(label)
+    )
+    preview_folder = os.path.join(folder, PREVIEW_OUTPUT_FOLDER)
+    os.makedirs(preview_folder, exist_ok=True)
+    path = os.path.join(preview_folder, "_Preview_%s.png" % safe_label)
+    with open(path, "wb") as file:
+        file.write(preview_bytes)
+
+    if announce:
+        emit(Candy("Color", "green", "-Preview image : %s") % path)
+    if not show:
+        return types.SimpleNamespace(success=False, path=path, opened=False)
+    ACTIVE_PREVIEW_IMAGE = Open_Final_Image(path, emit=emit)
+    if ACTIVE_PREVIEW_IMAGE is None:
+        return types.SimpleNamespace(success=False, path=path, opened=False)
+    return ACTIVE_PREVIEW_IMAGE
+
+
+def Ultimate_Linefeed_Checkpoint_Path():
+    return globals().get("ULTIMATE_LINEFEED_CHECKPOINT_PATH") or os.path.join(
+        output.ensure_clone_folder(FILE_Origin, FILE_DIR),
+        "_ULF.checkpoint.jsonl",
+    )
+
+
+def Ultimate_Linefeed_Progress_Path():
+    return globals().get("ULTIMATE_LINEFEED_PROGRESS_PATH") or os.path.join(
+        output.ensure_clone_folder(FILE_Origin, FILE_DIR),
+        "_ULF.progress.json",
+    )
+
+
+def Ultimate_Linefeed_Source_Path():
+    return globals().get("ULTIMATE_LINEFEED_SOURCE_PATH") or os.path.join(
+        output.ensure_clone_folder(FILE_Origin, FILE_DIR),
+        "_ULF.Source.png",
+    )
+
+
+def _Ultimate_Linefeed_Budget_Decision(mode, estimate, manual_budget=None):
+    total = int(getattr(estimate, "total_combinations", 0) or 0)
+    return magic_runtime.idat_bruteforce.ultimate_linefeed_budget_decision(
+        total,
+        mode,
+        manual_budget=manual_budget,
+    )
+
+
+def _Ultimate_Linefeed_Print_Budget_Menu(estimate):
+    total = int(getattr(estimate, "total_combinations", 0) or 0)
+    operations = int(getattr(estimate, "operation_count", 0) or 0)
+    depth = int(getattr(estimate, "max_depth", 0) or 0)
+    lines = [
+        "Ultimate budget no jutsu:",
+        "operations: %s" % format(operations, ","),
+        "max depth: %s" % depth,
+        "possible combinations: %s" % format(total, ","),
+        *magic_runtime.idat_bruteforce.ultimate_linefeed_universe_atom_comparison_lines(total),
+        "",
+        "Enter a number from 1 to 10.",
+        "",
+        "1. quick           total / 100000",
+        "2. normal          total / 50000",
+        "3. deep            total / 10000",
+        "4. very deep       total / 1000",
+        "5. deeeeeeep       total / 100",
+        "6. abyssal         total / 10",
+        "7. inception       total / 2",
+        "8. no limit",
+        "9. manual          exact candidate budget",
+        "10. quit like a looser.",
+    ]
+    Prompt_Candy("Cowsay", "\n".join(lines), "com")
+
+
+def _Ultimate_Linefeed_Manual_Budget():
+    while True:
+        try:
+            value = input("Exact candidate budget > ").strip()
+        except EOFError:
+            return None
+        try:
+            budget = int(value)
+        except ValueError:
+            PRINT(Candy("Color", "red", "-Budget must be a positive integer."))
+            continue
+        if budget > 0:
+            return budget
+        PRINT(Candy("Color", "red", "-Budget must be greater than zero."))
+
+
+def Ultimate_Linefeed_Budget(estimate=None):
+    if globals().get("ULTIMATE_LINEFEED_UNBOUNDED", False):
+        return _Ultimate_Linefeed_Budget_Decision("unbounded", estimate)
+    budget = globals().get("ULTIMATE_LINEFEED_BUDGET", None)
+    if budget is None:
+        if globals().get("AUTO", False) or globals().get("NODIALOGUE", False):
+            return _Ultimate_Linefeed_Budget_Decision("normal", estimate)
+        choices = {
+            "1": "quick",
+            "2": "normal",
+            "": "normal",
+            "3": "deep",
+            "4": "very_deep",
+            "5": "deeeeeeep",
+            "6": "abyssal",
+            "7": "inception",
+            "8": "unbounded",
+            "9": "manual",
+            "10": "abort",
+        }
+        while True:
+            _Ultimate_Linefeed_Print_Budget_Menu(estimate)
+            try:
+                choice = input("Ultimate budget choice number [2 normal] > ").strip().lower()
+            except EOFError:
+                choice = ""
+            mode = choices.get(choice)
+            if mode is None:
+                PRINT(Candy("Color", "red", "-Enter a number from 1 to 10."))
+                continue
+            if mode == "manual":
+                manual_budget = _Ultimate_Linefeed_Manual_Budget()
+                if manual_budget is None:
+                    return _Ultimate_Linefeed_Budget_Decision("normal", estimate)
+                return _Ultimate_Linefeed_Budget_Decision(
+                    "manual",
+                    estimate,
+                    manual_budget=manual_budget,
+                )
+            return _Ultimate_Linefeed_Budget_Decision(mode, estimate)
+    return magic_runtime.idat_bruteforce.UltimateLinefeedBudgetDecision(
+        "override",
+        int(budget),
+        coverage=magic_runtime.idat_bruteforce.ultimate_linefeed_budget_coverage(
+            int(getattr(estimate, "total_combinations", 0) or 0),
+            int(budget),
+        ),
+    )
+
+
+def _Ultimate_Linefeed_Recommended_Workers():
+    return platform_runtime.recommended_worker_count(profile="normal")
+
+
+def _Ultimate_Linefeed_Worker_Profile_Counts():
+    cpu_count = platform_runtime.detected_cpu_count()
+    return {
+        "cpu": cpu_count,
+        "min": platform_runtime.recommended_worker_count(cpu_count, profile="min"),
+        "normal": platform_runtime.recommended_worker_count(cpu_count, profile="normal"),
+        "max": platform_runtime.recommended_worker_count(cpu_count, profile="max"),
+    }
+
+
+def _Ultimate_Linefeed_Workers_From_Value(value):
+    if value is None:
+        return None
+    text = str(value).strip().lower()
+    if text in ("auto", "normal"):
+        return platform_runtime.recommended_worker_count(profile="normal")
+    if text in ("min", "max"):
+        return platform_runtime.recommended_worker_count(profile=text)
+    return max(0, int(text))
+
+
+def _Ultimate_Linefeed_Print_Worker_Menu():
+    counts = _Ultimate_Linefeed_Worker_Profile_Counts()
+    lines = [
+        "Ultimate CPU worker no jutsu:",
+        "CPU detected: %s" % counts["cpu"],
+        "min workers: %s" % counts["min"],
+        "normal workers: %s" % counts["normal"],
+        "max workers: %s" % counts["max"],
+        "",
+        "Choose how many Cpu workers to use (0,min, normal, max, or enter an exact number).",
+        "",
+        "0. disabled",
+        "min. CPU / 4",
+        "normal. CPU / 2",
+        "max. CPU - 1",
+        "custom. enter an exact worker count",
+        "",
+        "Empty keeps Ultimate single-process.",
+    ]
+    Prompt_Candy("Cowsay", "\n".join(lines), "com")
+
+
+def Ultimate_Linefeed_Workers():
+    configured = globals().get("ULTIMATE_LINEFEED_WORKERS", None)
+    if configured is not None:
+        return _Ultimate_Linefeed_Workers_From_Value(configured)
+    if globals().get("AUTO", False) or globals().get("NODIALOGUE", False):
+        return 0
+
+    while True:
+        _Ultimate_Linefeed_Print_Worker_Menu()
+        try:
+            choice = input("Ultimate worker profile [0 disabled] > ").strip().lower()
+        except EOFError:
+            choice = ""
+        if choice == "":
+            return 0
+        if choice in ("min", "normal", "max", "auto"):
+            return _Ultimate_Linefeed_Workers_From_Value(choice)
+        if choice == "custom":
+            try:
+                choice = input("Custom Ultimate worker count > ").strip().lower()
+            except EOFError:
+                choice = ""
+        try:
+            workers = int(choice)
+        except ValueError:
+            PRINT(Candy("Color", "red", "-Enter 0, min, normal, max, custom, or a worker count."))
+            continue
+        if workers >= 0:
+            return workers
+        PRINT(Candy("Color", "red", "-Worker count must be zero or higher."))
+
+
+def Ultimate_Linefeed_Reference():
+    return str(globals().get("ULTIMATE_LINEFEED_REFERENCE", "") or "")
+
+
+def Ultimate_Linefeed_Reference_Mode():
+    mode = str(globals().get("ULTIMATE_LINEFEED_REFERENCE_MODE", "exact") or "exact").strip().lower()
+    return mode if mode in ("exact", "similar") else "exact"
+
+
+def Ultimate_Linefeed_Reference_Regions():
+    return str(globals().get("ULTIMATE_LINEFEED_REFERENCE_REGIONS", "") or "")
+
+
+def Ultimate_Linefeed_Reference_Region_Editor():
+    return bool(globals().get("ULTIMATE_LINEFEED_REFERENCE_REGION_EDITOR", False))
+
+
+def Ultimate_Linefeed_Reference_Region_Editor_Run(source_path, reference_path, regions_path, source_data=b""):
+    return ultimate_reference_ui.open_ultimate_reference_region_editor(
+        source_path,
+        reference_path,
+        regions_path,
+        candidate_data=source_data,
+    )
+
+
+def Ultimate_Linefeed_Visual_Gallery_Limit():
+    return int(globals().get("ULTIMATE_LINEFEED_VISUAL_GALLERY_LIMIT", 100) or 0)
+
+
+def Ultimate_Linefeed_Visual_Min_Coverage():
+    return float(globals().get("ULTIMATE_LINEFEED_VISUAL_MIN_COVERAGE", 0.95) or 0.0)
+
+
+def Ultimate_Linefeed_Live_Preview_Folder():
+    return os.path.join(output.ensure_clone_folder(FILE_Origin, FILE_DIR), PREVIEW_OUTPUT_FOLDER)
+
+
+def Announce_Ultimate_Linefeed_Live_Preview_Folder(preview_folder):
+    global ULTIMATE_LINEFEED_LIVE_PREVIEW_FOLDER_REPORTED
+    if ULTIMATE_LINEFEED_LIVE_PREVIEW_FOLDER_REPORTED == preview_folder:
+        return
+    ULTIMATE_LINEFEED_LIVE_PREVIEW_FOLDER_REPORTED = preview_folder
+    PRINT_With_Loader_Redraw(Candy("Color", "green", "-Preview folder : %s") % preview_folder)
+
+
+def Ultimate_Linefeed_Candidate_Preview(candidate, tested, budget):
+    timeout = float(globals().get("ULTIMATE_LINEFEED_PREVIEW_TIMEOUT", 5.0) or 0.0)
+    show_preview = bool(globals().get("ULTIMATE_LINEFEED_SHOW_PREVIEWS", False))
+    Announce_Ultimate_Linefeed_Live_Preview_Folder(Ultimate_Linefeed_Live_Preview_Folder())
+
+    after = getattr(candidate, "after", None)
+    scanlines = getattr(after, "usable_scanlines", "unknown")
+    height = getattr(after, "height", "unknown")
+    adler_status = getattr(after, "adler_status", "adler_unknown")
+    label = "UltimateLive_%09d_%s_of_%s_%s" % (
+        int(tested),
+        scanlines,
+        height,
+        adler_status,
+    )
+    preview = Preview_Repair_Image(
+        candidate.data,
+        label,
+        show=show_preview,
+        emit=lambda _message: None,
+        announce=False,
+    )
+    if preview is None:
+        return None
+    if not show_preview:
+        return preview
+    if not getattr(preview, "success", False):
+        Close_Preview_Image()
+        return preview
+    try:
+        if timeout > 0:
+            time.sleep(timeout)
+    finally:
+        Close_Preview_Image()
+    return preview
+
+
+def CheckPoint_Runtime():
+    return checkpoint_runtime.build_checkpoint_runtime_from_namespace(globals())
+
+
+def CheckPoint_Set_Brute_LvL(value):
+    global Brute_LvL
+
+    Brute_LvL = value
+
+
+def CheckPoint_Action_Runtime():
+    return checkpoint_actions_runtime.build_checkpoint_action_runtime_from_namespace(globals())
+
+def CheckPoint_Apply_Action_Decision(decision, chunk, info, toolkit):
+    return checkpoint_actions_runtime.apply_action_decision(
+        CheckPoint_Action_Runtime(),
+        decision,
+        chunk,
+        info,
+        toolkit,
+    )
+
+
+def Pandemonium_Remember_Current_Sample():
+    relics.remember_sample(Pandemonium, ArkOfCovenant, Sample, PandoraBox, Cornucopia)
+
+
+def IDAT_Bytes_Nbr():  # tmpworkaround
+    global IBN
+    IBN = specs.estimate_idat_bytes_from_hex(DATAX, tuple(CHUNKS))
+    return IBN
+
+
+
+def Max_Res():
+    try:
+        MaxRes, size = specs.estimate_max_resolution_from_file(FILE_Origin)
+        if DEBUG:
+            PRINT("Size:%s"%str(size))
+            PRINT(
+                "-Maximum resolution estimation based on file size: %s*%s"
+                % (MaxRes, MaxRes)
+            )
+    except Exception as e:
+        Betterror(e, inspect.stack()[0][3])
+        PRINT(Candy("Color", "red", "Error:%s")% Candy("Color", "yellow", e))
+        TheEnd()
+
+    return MaxRes
+
+
+def GetSpec(GetChunk,Mode,Fields=["All"],StructIndex=None,IterNbr=1):
+    return getspec_runtime.run_getspec_from_namespace(
+        globals(),
+        GetChunk,
+        Mode,
+        Fields,
+        StructIndex,
+        IterNbr,
+    )
+
+
+def Sync_Chunk_Info_Legacy_State(section=None):
+    if hasattr(section, "legacy_globals"):
+        globals().update(section.legacy_globals())
+        return None
+    return chunk_state_runtime.sync_state_to_legacy(globals(), CHUNK_INFO_STATE, section)
+
+
+def Sync_Chunk_Info_State_From_Legacy(section=None):
+    return chunk_state_runtime.sync_legacy_to_state(CHUNK_INFO_STATE, globals(), section)
+
+
+def Chunk_Report_Color(color, value):
+    return Candy("Color", color, value)
+
+
+def Chunky_Report(name):
+    return Candy("Chunky", name)
+
+
+####
+def GetInfo_Set_Legacy(**values):
+    globals().update(values)
+
+
+def GetInfo_Runtime():
+    return getinfo_runtime.GetInfoRuntime(
+        chunk_state=CHUNK_INFO_STATE,
+        set_legacy=GetInfo_Set_Legacy,
+        sync_legacy=Sync_Chunk_Info_Legacy_State,
+        max_resolution=Max_Res,
+        checkpoint=CheckPoint,
+        emit=PRINT,
+        candy=Candy,
+        color=Chunk_Report_Color,
+        chunky=Chunky_Report,
+        raw_length=Raw_Length,
+        orig_cl=Orig_CL,
+        ihdr_color=IHDR_Color,
+        ihdr_depth=IHDR_Depht,
+        chunks_history=tuple(Chunks_History),
+        private_chunks=tuple(PRIVATE_CHUNKS),
+        allchunks=tuple(ALLCHUNKS),
+    )
+
+
+def GetInfo(Chunk, data, Dummy=False):
+    globals().update(
+        iCCP_Name="",
+        iTXt_String="",
+        iTXt_Key="",
+        zTXt_Key="",
+        tEXt_Text="",
+        tEXt_Key="",
+    )
+
+    getinfo_runtime.run_getinfo(GetInfo_Runtime(), Chunk, data)
+
+    if Dummy is False:
+        CheckChunkOrder(Chunk, "TheGoodPlace")
+    return
+
+
+####
+
+
+def YouShallPass_Runtime():
+    return youshallpass_runtime.YouShallPassRuntime(
+        chunk_state=CHUNK_INFO_STATE,
+        sync_state=Sync_Chunk_Info_State_From_Legacy,
+        chunks_history=tuple(Chunks_History),
+        orig_cl=Orig_CL,
+    )
+
+
+def YouShallPass(Chunk, data):
+    return youshallpass_runtime.youshallpass(YouShallPass_Runtime(), Chunk, data)
+
+
+def ChunkbyChunk(offset):
+    ChunkScan = chunk_scanner.scan_legacy_chunk(DATA_BYTES, offset)
+    Sync_Chunk_Info_Legacy_State(ChunkScan)
+
+    Candy("Title", "Chunk Infos:")
+    chunk_report.render_legacy_chunk_window(
+        ChunkScan.window,
+        PRINT,
+        lambda color, value: Candy("Color", color, value),
+    )
+
+    return
+
+
+def GroundhogDay(NewDay):
+
+    Relaunch = runtime_state.groundhogday_relaunch_args(sys.argv, NewDay)
+    sys.argv[:] = Relaunch.argv
+    if DEBUG is True:
+        PRINT("sys.executable was %s"% sys.executable)
+        PRINT("argv is %s"% Relaunch.strargs)
+        PRINT("rebooting chunklate")
+        if PAUSEDEBUG is True:
+            Pause("Pause:Reboot")
+    os.execv(sys.executable, Relaunch.exec_args)
+
+
+def Chunklate(sec):
+
+    for line in ui.render_chunklate_banner(os.name, random.randint, use_color=USE_COLOR):
+        print(line)
+
+    if sec:
+        time.sleep(sec)
+
+
+def Minibar_Group(Indication=""):
+    return "".join("#" if char.isdigit() else char for char in str(Indication))
+
+
+def Minibar(Indication=""):
+    global CharPos
+    global GoBack
+    global Loading_txt
+    global Loading_sep
+    global PROGRESS_LINE_ACTIVE
+    minibar_group = Minibar_Group(Indication)
+    if minibar_group != Loading_sep:
+        Loading_txt = ""
+        CharPos = 1
+        GoBack = False
+        Loading_sep = minibar_group
+    Step = ui.minibar_step(Indication, Loading_txt, CharPos, GoBack, MAXCHAR)
+    Loading_txt = Step.loading_text
+    CharPos = Step.char_pos
+    GoBack = Step.go_back
+    if Step.should_print:
+        print(Loading_txt + "\033[K", end="\r")
+        PROGRESS_LINE_ACTIVE = True
+
+
+def Loadingbar(fishs, fishsize, loop, build):
+    global PROGRESS_LINE_ACTIVE
+    global LAST_PROGRESS_LINE
+    result = ui.run_loadingbar_from_namespace(globals(), fishs, fishsize, loop, build)
+    if not build:
+        if result is not None:
+            LAST_PROGRESS_LINE = result.text
+        PROGRESS_LINE_ACTIVE = True
+    return result
+
+
+def Finish_Progress_Line(*, clear=False):
+    global PROGRESS_LINE_ACTIVE
+    if PROGRESS_LINE_ACTIVE:
+        if clear:
+            print("\r\033[K", end="")
+        else:
+            print("")
+        PROGRESS_LINE_ACTIVE = False
+
+
+def Redraw_Progress_Line():
+    global PROGRESS_LINE_ACTIVE
+    if LAST_PROGRESS_LINE:
+        print(LAST_PROGRESS_LINE + "\033[K", end="\r")
+        PROGRESS_LINE_ACTIVE = True
+
+
+def PRINT_With_Loader_Redraw(msg):
+    was_active = PROGRESS_LINE_ACTIVE
+    Finish_Progress_Line(clear=True)
+    if DEBUGFILE is True:
+        DebugNotes.append(msg)
+    output.append_terminal_transcript(globals(), msg)
+    ui.emit_printable_message(print, msg, max_columns=MAXCHAR, no_dialogue=NODIALOGUE)
+    if was_active:
+        Redraw_Progress_Line()
+
+
+def Sumform(waitforit, switch):
+    return output.summary_separator(waitforit, switch, MAXCHAR)
+
+
+def Summarise(infos, Summary_Footer=False):
+    return output.run_summarise_from_namespace(globals(), infos, Summary_Footer)
+
+
+def Prepare_Immediate_Summary():
+    return output.ensure_immediate_summary_notes(globals())
+
+
+def Legacy_UI_Runtime():
+    return ui_runtime.LegacyUiRuntime(
+        emit=PRINT,
+        random_int=random.randint,
+        max_columns=MAXCHAR,
+        no_dialogue=NODIALOGUE,
+        use_color=USE_COLOR,
+        pause_dialogue_enabled=PAUSEDIALOGUE,
+        pause_dialogue=lambda: prompts.pause_dialogue(Transcript_Input, PAUSEDIALOGUE),
+        pause_state=DIALOGUE_PAUSE_STATE,
+    )
+
+
+def Candy(mode, arg, data=None):
+    return Legacy_UI_Runtime().candy(mode, arg, data)
+
+
+def Prompt_Candy(mode, arg, data=None):
+    def emit(message):
+        output.append_terminal_transcript(globals(), message)
+        print(message, flush=True)
+
+    return ui_runtime.LegacyUiRuntime(
+        emit=emit,
+        random_int=random.randint,
+        max_columns=MAXCHAR,
+        no_dialogue=False,
+        use_color=USE_COLOR,
+    ).candy(mode, arg, data)
+
+
+def SplitDigits(lst):
+    return sorting.natural_sort_key(lst)
+
+
+def DigDigits(dig):
+    return sorting.digit_or_text(dig)
+
+
+def ChunkStory(action, Chunk, start, end, chuck_length):
+    global Chunks_History
+    global Chunks_History_Index
+
+    if action == "add":
+        chunk_story.add(Chunks_History, Chunks_History_Index, Chunk, start, end, chuck_length)
+    elif action == "del":
+        try:
+            chunk_story.delete_legacy(Chunks_History, Chunks_History_Index, Chunk)
+        except Exception as e:
+            Betterror(e, inspect.stack()[0][3])
+            if DEBUG is True:
+                PRINT(Candy("Color", "red", "Error:%s")% Candy("Color", "yellow", e))
+                if PAUSEDEBUG is True:
+                    Pause("Pause:Chunkstory")
+
+
+def Clear_Terminal_Dialogue_Pause():
+    DIALOGUE_PAUSE_STATE.pending = False
+    DIALOGUE_PAUSE_STATE.paused_in_group = False
+    DIALOGUE_PAUSE_STATE.rendering_dialogue = False
+
+
+def Record_Terminal_Transcript(message):
+    output.append_terminal_transcript(globals(), message)
+
+
+def Transcript_Input(prompt=""):
+    answer = input(prompt)
+    Record_Terminal_Transcript("%s%s" % (prompt, answer))
+    return answer
+
+
+def TheEnd():
+    Clear_Terminal_Dialogue_Pause()
+    if DEBUG is True:
+        for line in output.the_end_debug_lines(
+            Chunks_History_Index,
+            idatcounter,
+            Chunks_History,
+            IDAT_Bytes_Len,
+        ):
+            PRINT(line)
+    if PAUSEDEBUG is True:
+        Pause("ThenEnd debug")
+    Open_Current_Final_Image_If_Valid()
+    Summarise(None, True)
+    Chunklate(0)
+    Candy("Cowsay", "See you Space Cowboy...", "good")
+    sys.exit(0)
+
+
+def ToBitstory(bytenbr):
+    global Bytes_History
+    history.append_byte_history(Bytes_History, bytenbr)
+
+
+def stderr_redirector(stream):
+    return stdio.stderr_redirector(stream)
+
+def Product(chunk_data,color_type,gen_nbr=None):
+     yield from specs.iter_product_values(chunk_data, color_type)
+
+
+class Tk_Gen_Scale_Plte:
+
+    def __init__(self, master=None, label='', value=0,to=None,from_=None,ln=None,afn=None,bfn=None,h=None,w=None,nbr=None):
+        widget = palette_ui.create_palette_scale(
+            tkinter_module=tkinter,
+            master=master,
+            label=label,
+            value=value,
+            from_=from_,
+            to=to,
+            length=ln,
+            command=lambda event: Tk_ImgUpdate_Plte(event,nbr=nbr,bfn=bfn,afn=afn,h=h,w=w),
+            grid_options={"padx": 10, "pady": 5},
+        )
+        self.var = widget.var
+        self.s = widget.scale
+        self.swatch = widget.swatch
+        self.container = widget.container
+    def clean(self):
+       if hasattr(self, "container") and hasattr(self.container, "destroy"):
+           self.container.destroy()
+       else:
+           self.s.destroy()
+
+
+def Tk_Render_Plte_Preview(wanabyte, w, h, frame=None):
+    return palette_runtime.render_palette_preview_from_namespace(globals(), wanabyte, w, h, frame)
+
+
+def Sync_Palette_Legacy_State():
+    return palette_runtime.sync_palette_legacy_state(globals(), palette_state)
+
+
+def Tk_ImgUpdate_Plte(event,nbr=None,bfn=None,afn=None,w=None,h=None):
+    return palette_runtime.update_palette_value_from_namespace(globals(), event, nbr, bfn, afn, w, h)
+
+#    if DEBUG:
+#        PRINT("PlteId : %s Value : %s Plte_Blst[PlteId]:%s bvalue: %s Lnx_New : %s"%(str(nbr),str(event),str(Plte_Blst[nbr]),str(bvalue),str(Lnx_New)))
+
+def Tk_X11_Randomize_Plte(bfn=None,afn=None,w=None,h=None):
+    return palette_runtime.apply_random_palette_colors_from_namespace(globals(), X11_Colors, bfn, afn, w, h)
+
+def Tk_X11_Plte(bfn=None,afn=None,w=None,h=None):
+    return palette_runtime.apply_palette_colors_from_namespace(globals(), X11_Colors, bfn, afn, w, h)
+
+
+def Tk_Web_Safe_Randomize_Plte(bfn=None,afn=None,w=None,h=None):
+    return palette_runtime.apply_random_palette_colors_from_namespace(globals(), Web_Safe_Colors, bfn, afn, w, h)
+
+def Tk_Web_Safe_Plte(bfn=None,afn=None,w=None,h=None):
+    return palette_runtime.apply_palette_colors_from_namespace(globals(), Web_Safe_Colors, bfn, afn, w, h)
+
+
+def Tk_Randomize_Plte(bfn=None,afn=None,w=None,h=None):
+    return palette_runtime.randomize_palette_from_namespace(globals(), bfn, afn, w, h)
+
+def Tk_update_scrollregion_Plte(event):
+    canvas = getattr(event, "widget", None)
+    if canvas is None or not hasattr(canvas, "bbox"):
+        canvas = globals().get("canvas_slider")
+    if canvas is not None and hasattr(canvas, "bbox"):
+        canvas.configure(scrollregion=canvas.bbox("all"))
+
+def Tk_Save_Plte(Tkwin,Cancel,ChunkLength,DataOffset,FromError,wanabyte):
+    return palette_runtime.save_manual_palette_from_namespace(
+        globals(),
+        Tkwin,
+        Cancel,
+        ChunkLength,
+        DataOffset,
+        FromError,
+        wanabyte,
+    )
+
+
+def Guess_Palettes_Nbr(bfn,afn):
+    return palette_runtime.guess_palette_count_from_namespace(globals(), bfn, afn)
+
+
+
+def Tk_Manual_Plte(
+    File,
+    ChunkName,
+    ChunkLength,
+    DataOffset,
+    FromError,
+    DataHex=None,
+):
+    PaletteEditor = palette_runtime.create_manual_palette_editor_from_namespace(
+        globals(),
+        File,
+        ChunkName,
+        ChunkLength,
+        DataOffset,
+        FromError,
+        data_hex=DataHex,
+    )
+    PaletteEditor.window.mainloop()
+
+
+def SmashBruteBrawl(
+    File,
+    ChunkName,
+    ChunkLength,
+    DataOffset,
+    FromError,
+    EditMode="Replace",
+    BfMode="Brutus",
+    BruteCrc=True,
+    BruteLength=True,
+    OldCrc=False,
+    BruteLevel=None,
+):
+    return smash_bruteforce.run_legacy_smash_brute_brawl_from_namespace(
+        globals(),
+        File,
+        ChunkName,
+        ChunkLength,
+        DataOffset,
+        FromError,
+        EditMode,
+        BfMode,
+        BruteCrc,
+        BruteLength,
+        OldCrc,
+        brute_level=BruteLevel,
+    )
+
+
+
+
+def FullChunkForcerNoCrc(
+    File, Chunk, DataOffset, ChunkLength, FromError
+):  ## need to be merged with SmashBruteBrawl
+    return full_chunk_forcer.run_full_chunk_forcer_no_crc_from_namespace(
+        globals(),
+        File,
+        Chunk,
+        DataOffset,
+        ChunkLength,
+        FromError,
+    )
+
+
+
+
+def Deferred_Linefeed_Signature_Repair(data_bytes, sample_name, linefeed_pattern):
+    globals()["DEFERRED_LINEFEED_SIGNATURE_REPAIR"] = {
+        "data_bytes": data_bytes,
+        "sample_name": sample_name,
+        "linefeed_pattern": linefeed_pattern,
+    }
+    return True
+
+
+def Clear_Deferred_FindMagic_Repair():
+    globals()["DEFERRED_LINEFEED_SIGNATURE_REPAIR"] = None
+
+
+def Apply_Deferred_FindMagic_Repair():
+    return magic_runtime.run_deferred_linefeed_signature_repair_from_namespace(globals())
+
+
+def Run_Ultimate_Linefeed_Direct_Resume():
+    return magic_runtime.run_ultimate_linefeed_direct_resume_from_namespace(globals())
+
+
+def Run_Smash_Brute_Brawl_Direct_Resume():
+    return smash_bruteforce.run_smash_brute_brawl_direct_resume_from_namespace(globals())
+
+
+def FindMagic():
+    return magic_runtime.run_find_magic_from_namespace(globals())
+
+
+def FindFuckingMagic():
+    return magic_runtime.run_find_fucking_magic_from_namespace(globals())
+
+
+def Ancillary(Chunk):
+    global Bad_Ancillary
+    Bad_Ancillary = ancillary_runtime.run_ancillary_check(
+        ancillary_runtime.AncillaryRuntime(
+            candy=Candy,
+            emit=PRINT,
+            betterror=Betterror,
+        ),
+        Chunk,
+    )
+
+
+def NullFind(data, search4=None):
+    return nearby.null_find(data, search4)
+
+
+def LibpngCheck(file):
+    return libpng_runtime.run_libpng_check(
+        libpng_runtime.LibpngCheckRuntime(
+            candy=Candy,
+            emit=PRINT,
+            checkpoint=CheckPoint,
+        ),
+        libpng_runtime.LibpngCheckContext(
+            sample_name=Sample_Name,
+            libpng_errors=LIBPNG_ERR,
+            cv2_module=cv2,
+            image_module=Image,
+            stderr_redirector=stderr_redirector,
+            warning_reader=KnownBadSrgbProfileWarning,
+            pending_errors=tuple(PandoraBox),
+        ),
+        file,
+    )
+
+
+def KnownBadSrgbProfileWarning(file):
+    return libpng_runtime.run_known_bad_srgb_profile_warning(file)
+
+
+def Double_Check(CType, ChunkLen, LastCType):
+    return nearby_runtime.run_double_check_from_namespace(globals(), CType, ChunkLen, LastCType)
+
+
+def RandomSample(data,colortype,chunk_format):
+    return specs.random_sample_hex(data, colortype, chunk_format, random.random)
+
+
+def DummyChunk_Runtime():
+    return dummy_chunk_runtime.DummyChunkRuntime(
+        data_hex=DATAX,
+        side_notes=SideNotes,
+        candy=Candy,
+        emit=PRINT,
+        checkpoint=CheckPoint,
+        end=TheEnd,
+        pause=Pause,
+        get_spec=GetSpec,
+        spec_length=SpecLength,
+        random_sample=RandomSample,
+        repair_note=fixit_felix.repair_note,
+        debug=DEBUG,
+        pause_debug=PAUSEDEBUG,
+        question=Question,
+        file_origin=FILE_Origin,
+        write_clone=WriteClone,
+    )
+
+
+def DummyChunk(Chunkname, bad_pos, bad_start, bad_end, FromError): ##TODO bad_pos is not used well enough
+    return dummy_chunk_runtime.run_dummy_chunk(
+        DummyChunk_Runtime(),
+        Chunkname,
+        bad_pos,
+        bad_start,
+        bad_end,
+        FromError,
+    )
+
+
+def Remove_Extra_Bytes_Before_Chunk(CType, LastCType, Excluded):
+    return nearby_runtime.run_remove_extra_bytes_before_chunk_from_namespace(
+        globals(),
+        CType,
+        LastCType,
+        Excluded,
+    )
+
+
+def NearbyChunk(CType, ChunkLen, LastCType, DoubleCheck, FromError=None):
+    return nearby_runtime.run_nearby_chunk_from_namespace(
+        globals(),
+        CType,
+        ChunkLen,
+        LastCType,
+        DoubleCheck,
+        FromError,
+    )
+
+
+def TheGoodPlace(Missplaced_Chunkname, Missplaced_Chunkpos, ToFix_Chunkname):
+    return chunk_order_runtime.run_the_good_place_from_namespace(
+        globals(),
+        Missplaced_Chunkname,
+        Missplaced_Chunkpos,
+        ToFix_Chunkname,
+    )
+
+
+def CheckChunkOrder(lastchunk, mode):
+    return chunk_order_runtime.run_check_chunk_order_from_namespace(globals(), lastchunk, mode)
+
+
+
+def NameShift():
+    return name_shift_runtime.run_name_shift_from_namespace(globals())
+
+
+def BruteChunk_Crc_Matches(candidates):
+    try:
+        # Add validation to check if Raw_Data and Raw_Crc are not empty
+        if not Raw_Data or Raw_Data.strip() == '':
+            return []
+        if not Raw_Crc or Raw_Crc.strip() == '':
+            return []
+            
+        chunk_data = bytes.fromhex(Raw_Data)
+        stored_crc = int(Raw_Crc, 16)
+    except Exception as e:
+        Betterror(e, inspect.stack()[0][3])
+        return []
+
+    return chunk_type_crc_matches(chunk_data, stored_crc, candidates)
+
+
+def BruteChunk_Save_Auto_Name(CType, FromError, ChunkName, reason):
+    return chunk_name_runtime.save_auto_name_from_namespace(
+        globals(),
+        CType,
+        FromError,
+        ChunkName,
+        reason,
+    )
+
+
+def ChunkName_Runtime():
+    return chunk_name_runtime.build_chunk_name_runtime_from_namespace(globals())
+
+
+def ChunkName_Context():
+    return chunk_name_runtime.build_chunk_name_context_from_namespace(globals())
+
+
+def BruteChunk(CType, LastCType, ChunkLen, FromError):
+    return chunk_name_runtime.run_brute_chunk_from_namespace(
+        globals(),
+        CType,
+        LastCType,
+        ChunkLen,
+        FromError,
+    )
+
+
+def CheckChunkName(ChunkType, ChunkLen, LastCType, Next=None):
+    return chunk_name_runtime.run_check_chunk_name_from_namespace(
+        globals(),
+        ChunkType,
+        ChunkLen,
+        LastCType,
+        Next,
+    )
+
+
+def SpecLength(chunk_name, chunk_length=None):
+    return spec_length_runtime.run_spec_length(
+        spec_length_runtime.SpecLengthRuntime(
+            candy=Candy,
+            emit=PRINT,
+            end=TheEnd,
+            get_spec=GetSpec,
+            side_notes=SideNotes,
+        ),
+        chunk_name,
+        chunk_length,
+    )
+
+
+def CheckLength(Cdata, Clen, Ctype):
+    return chunk_validation_runtime.run_check_length_from_namespace(
+        globals(),
+        Cdata,
+        Clen,
+        Ctype,
+    )
+
+
+
+
+def Question(
+    id=None,
+    idhash=None,
+    skipauto=False,
+    timeout_seconds=None,
+    timeout_default=None,
+):
+    globals()["LAST_QUESTION_STATUS"] = None
+
+    def asker(prompt):
+        if timeout_seconds is None:
+            return Transcript_Input(prompt)
+        try:
+            answer = inputimeout(prompt, timeout=timeout_seconds)
+            Record_Terminal_Transcript("%s%s" % (prompt, answer))
+            return answer
+        except TimeoutOccurred:
+            default_answer = "yes" if timeout_default is True else "no"
+            Record_Terminal_Transcript(
+                "%s%s [timeout after %s seconds]"
+                % (prompt, default_answer, timeout_seconds)
+            )
+            PRINT("")
+            PRINT(
+                "-Question timed out after %s seconds; auto-answering %s.\n"
+                % (timeout_seconds, default_answer)
+            )
+            return default_answer
+
+    runtime = question_runtime.QuestionRuntime(
+        history=IFOP,
+        nodialogue=NODIALOGUE,
+        auto=AUTO,
+        clear=CLEAR_SCREEN_ACTIVE_THIS_PASS,
+        debug=DEBUG,
+        pause_debug=PAUSEDEBUG,
+        offset=CLoffI,
+        asker=asker,
+        candy=Candy,
+        emit=PRINT,
+        pause=Pause,
+        end=TheEnd,
+        prompt_candy=Prompt_Candy,
+        status_sink=lambda status: globals().__setitem__("LAST_QUESTION_STATUS", status),
+    )
+    try:
+        return question_runtime.ask_question(runtime, id, idhash, skipauto=skipauto)
+    finally:
+        Clear_Terminal_Dialogue_Pause()
+        Close_Preview_Image()
+
+
+def Checksum(Ctype, Cdata, Crc, next=None):
+    return chunk_validation_runtime.run_checksum_from_namespace(
+        globals(),
+        Ctype,
+        Cdata,
+        Crc,
+        next,
+    )
+
+
+def RemoveChunk(start,length,infos):
+    return writer_runtime.run_remove_chunk(
+        writer_runtime.ClonePatchRuntime(
+            data_hex=DATAX,
+            candy=Candy,
+            emit=PRINT,
+            betterror=Betterror,
+            write_clone=WriteClone,
+            set_show_must_go_on=lambda value: globals().__setitem__("Show_Must_Go_On", value),
+        ),
+        start,
+        length,
+        infos,
+    )
+
+def SaveClone(DataFix, start, end, infos):
+    return writer_runtime.run_save_clone(
+        writer_runtime.ClonePatchRuntime(
+            data_hex=DATAX,
+            candy=Candy,
+            emit=PRINT,
+            betterror=Betterror,
+            write_clone=WriteClone,
+            set_show_must_go_on=lambda value: globals().__setitem__("Show_Must_Go_On", value),
+            save_debug_payloads=lambda label, start, end, payloads: writer_runtime.save_clone_debug_payloads(
+                FILE_Origin,
+                FILE_DIR,
+                label,
+                start,
+                end,
+                payloads,
+            ),
+            side_notes=SideNotes,
+        ),
+        DataFix,
+        start,
+        end,
+        infos,
+    )
+
+
+def WriteClone(data,infos):
+    return writer_runtime.run_write_clone_from_namespace(globals(), data, infos)
+
+
+def Relics_Runtime():
+    return relics_runtime.build_relics_runtime_from_namespace(globals())
+
+
+def Relics_Context(FromError):
+    return relics_runtime.build_relics_context_from_namespace(globals(), FromError)
+
+
+def Relics(FromError):
+    return relics_runtime.handle_relics_from_namespace(globals(), FromError)
+
+
+def Naming(filename):
+
+    target = output.next_clone_target(filename, FILE_DIR)
+    return (target.name, target.directory)
+
+def LockDown():
+    Candy("Title", "LockDown: ", Candy("Color", "white", Chunk))
+
+    for folder in output.lockdown_folder_lines(FILE_Origin, FILE_DIR):
+        PRINT(folder)
+
+
+def FixItFelix_Set_Skip_Bad_Crc(value):
+    global Skip_Bad_Crc
+
+    Skip_Bad_Crc = value
+
+
+def FixItFelix_Set_Old_Bad_Crc(value):
+    global Old_Bad_Crc
+
+    Old_Bad_Crc = value
+
+
+def FixItFelix_Wrong_Crc_Runtime():
+    return fixit_felix_runtime.build_wrong_crc_runtime_from_namespace(globals())
+
+
+def FixItFelix_Wrong_Crc(key, chkd, PandoraBox_len):
+    CrcDecision = fixit_felix.wrong_crc_decision(
+        key,
+        solved=str(key) in Cornucopia,
+        pandora_box_len=PandoraBox_len,
+    )
+
+    CrcTools = None
+    if CrcDecision.action != "already_in_cornucopia":
+        try:
+            chkd = relics.resolve_tool_prefix(PandoraBox[key], chkd)
+            CrcTools = relics.wrong_crc_tools(PandoraBox[key], chkd)
+        except KeyError:
+            Candy(
+                "Cowsay",
+                "CRC repair data is missing for this malformed chunk. I will leave it to the chunk-name/length repair path.",
+                "com",
+            )
+            FixItFelix_Set_Skip_Bad_Crc(True)
+            return False, None
+
+    success, result = fixit_felix_runtime.apply_wrong_crc(
+        FixItFelix_Wrong_Crc_Runtime(),
+        CrcDecision,
+        chkd,
+        CrcTools,
+    )
+
+    return success, result
+
+
+def FixItFelix_Set_Skip_Bad_Libpng(value):
+    global Skip_Bad_Libpng
+
+    Skip_Bad_Libpng = value
+
+
+def FixItFelix_Libpng_Error_Runtime():
+    return fixit_felix_runtime.build_libpng_error_runtime_from_namespace(globals())
+
+
+def FixItFelix_Libpng_Error(key, chkd):
+    return fixit_felix_runtime.apply_libpng_error(
+        FixItFelix_Libpng_Error_Runtime(),
+        fixit_felix.libpng_error_decision(
+            key,
+            solved=str(key) in Cornucopia,
+            skip_bad_libpng=Skip_Bad_Libpng,
+        ),
+        chkd,
+    )
+
+
+def FixItFelix_Set_Skip_Bad_Next_Name(value):
+    global Skip_Bad_Next_Name
+
+    Skip_Bad_Next_Name = value
+
+
+def FixItFelix_Set_Skip_Bad_Current_Name(value):
+    global Skip_Bad_Current_Name
+
+    Skip_Bad_Current_Name = value
+
+
+def FixItFelix_Wrong_Chunk_Name_Runtime():
+    return fixit_felix_runtime.build_wrong_chunk_name_runtime_from_namespace(globals())
+
+
+def FixItFelix_Wrong_Chunk_Name(key, chkd):
+    if Skip_Bad_Current_Name is False:
+        NameDecision = fixit_felix.wrong_chunk_name_decision(
+            key,
+            solved=str(key) in Cornucopia,
+            bad_crc=Bad_Crc,
+        )
+
+        NameTools = None
+        name_chkd = chkd
+        if NameDecision.action != "save_existing_solution":
+            name_chkd = relics.resolve_tool_prefix(PandoraBox[key], chkd)
+            NameTools = relics.wrong_chunk_name_tools(PandoraBox[key], name_chkd)
+
+        return fixit_felix_runtime.apply_wrong_chunk_name(
+            FixItFelix_Wrong_Chunk_Name_Runtime(),
+            NameDecision,
+            name_chkd,
+            NameTools,
+        )
+
+    return False, None
+
+
+def FixItFelix_Set_Skip_Bad_No_Next_Chunk(value):
+    global Skip_Bad_No_Next_Chunk
+
+    Skip_Bad_No_Next_Chunk = value
+
+
+def FixItFelix_Set_EOF(value):
+    global EOF
+
+    EOF = value
+
+
+def FixItFelix_No_NextChunk_Runtime():
+    return fixit_felix_runtime.build_no_next_chunk_runtime_from_namespace(globals())
+
+
+def FixItFelix_No_NextChunk_Decision_Chunk(Chunk, chkd, no_next_chkd, tools):
+    if Chunk in (None, b"", ""):
+        return tools.chunk_type
+    if no_next_chkd != chkd:
+        return tools.chunk_type
+    return Chunk
+
+
+def FixItFelix_No_NextChunk(key, chkd, Chunk):
+    global Skip_Bad_No_Next_Chunk
+
+    if Skip_Bad_No_Next_Chunk is False:
+        no_next_chkd = relics.resolve_tool_prefix(PandoraBox[key], chkd)
+        NoNextTools = relics.no_next_chunk_tools(PandoraBox[key], no_next_chkd)
+        decision_chunk = FixItFelix_No_NextChunk_Decision_Chunk(
+            Chunk,
+            chkd,
+            no_next_chkd,
+            NoNextTools,
+        )
+        NoNextDecision = fixit_felix.no_next_chunk_decision(
+            current_chunk=decision_chunk,
+            chunk_type=NoNextTools.chunk_type,
+            chunk_length=NoNextTools.chunk_length,
+            bad_critical=Bad_Critical,
+        )
+        return fixit_felix_runtime.apply_no_next_chunk(
+            FixItFelix_No_NextChunk_Runtime(),
+            NoNextDecision,
+            key,
+            no_next_chkd,
+            NoNextTools,
+        )
+
+    return False, None
+
+
+def FixItFelix_Gama_Zero_Runtime():
+    return fixit_felix_runtime.build_gama_zero_runtime_from_namespace(globals())
+
+
+def FixItFelix_Gama_Zero(key):
+    return fixit_felix_runtime.apply_gama_zero(
+        FixItFelix_Gama_Zero_Runtime(),
+        fixit_felix.gama_zero_decision(key),
+    )
+
+
+def FixItFelix_Critical_Miss_Runtime():
+    return fixit_felix_runtime.build_critical_miss_runtime_from_namespace(globals())
+
+
+def FixItFelix_Critical_Miss(key):
+    return fixit_felix_runtime.apply_critical_miss(
+        FixItFelix_Critical_Miss_Runtime(),
+        fixit_felix.critical_miss_decision(
+            key,
+            debug=DEBUG,
+            pause_debug=PAUSEDEBUG,
+        ),
+    )
+
+
+def FixItFelix_Automatic_Repair_Runtime():
+    return fixit_felix_runtime.build_automatic_repair_runtime_from_namespace(globals())
+
+
+def FixItFelix_Apply_Repair(repair):
+    return fixit_felix_runtime.apply_repair(
+        FixItFelix_Automatic_Repair_Runtime(),
+        repair,
+    )
+
+
+def FixItFelix_Try_Automatic_Repair(name):
+    global Bad_Libpng
+
+    repair_intent = fixit_felix.automatic_repair_intent(name, PandoraBox)
+    repair = fixit_felix.automatic_repair(
+        name,
+        DATA_BYTES,
+        PandoraBox,
+        known_chunk_types=ALLCHUNKS,
+        auto=AUTO,
+        nodialogue=NODIALOGUE,
+        max_saves=MAX_SAVES,
+    )
+    if repair is None:
+        failure_explanation = fixit_felix.automatic_repair_failure_explanation(
+            name,
+            PandoraBox,
+        )
+        if failure_explanation is not None:
+            Candy("Cowsay", failure_explanation, "bad")
+            SideNotes.append("-FixItFelix:%s." % failure_explanation)
+        return None
+
+    if repair_intent is not None:
+        Candy("Cowsay", repair_intent, "com")
+
+    if name == "hist_out_of_place_cleanup":
+        if NODIALOGUE:
+            for key in list(PandoraBox):
+                key_text = str(key)
+                if "hIST: out of place" in key_text or "hIST chunk must appear before" in key_text:
+                    relics.discard_pandora_error(PandoraBox, key)
+            SideNotes.append(
+                "-Keeping optional hIST chunk(s): non-interactive mode cannot confirm metadata removal."
+            )
+            Bad_Libpng = False
+            return True
+        if not AUTO and not Question(
+            id="hIST Optional Metadata Removal:-Remove hIST chunk(s) to silence libpng?"
+        ):
+            for key in list(PandoraBox):
+                key_text = str(key)
+                if "hIST: out of place" in key_text or "hIST chunk must appear before" in key_text:
+                    relics.discard_pandora_error(PandoraBox, key)
+            SideNotes.append("-Keeping optional hIST chunk(s) as requested.")
+            PRINT("-Keeping hIST chunk(s) as requested.")
+            Bad_Libpng = False
+            return True
+
+    if name == "ihdr_rebuild":
+        crc_bruteforce_result = fixit_felix_runtime.try_ihdr_stored_crc_bruteforce(
+            FixItFelix_Automatic_Repair_Runtime(),
+            repair,
+        )
+        if crc_bruteforce_result is not None:
+            return crc_bruteforce_result
+
+    return FixItFelix_Apply_Repair(repair)
+
+
+def FixItFelix_Runtime_Callbacks():
+    return fixit_felix_runtime.build_legacy_fixit_felix_handlers_from_namespace(globals())
+
+
+def FixItFelix_Runtime():
+    return fixit_felix_runtime.build_fixit_felix_runtime_from_namespace(globals())
+
+
+def FixItFelix_Tool_Prefix(Chunk):
+    if isinstance(Chunk, str):
+        return Chunk + "_Tool_"
+    try:
+        return Chunk.decode(errors="ignore") + "_Tool_"
+    except AttributeError as e:
+        Betterror(e, "FixItFelix")
+        return fixit_felix.tool_prefix_for_chunk(Chunk)
+
+
+def FixItFelix(Chunk=None):
+    Candy("Title", "Fix It Felix: ", Candy("Color", "white", Chunk))
+    ##TODOFIND A WAY TO MAKE IT READABLE
+
+    global Show_Must_Go_On
+
+    chkd = FixItFelix_Tool_Prefix(Chunk)
+    RunResult = fixit_felix_runtime.run_fixit_felix_pipeline_from_namespace(
+        globals(),
+        Chunk,
+        chkd,
+    )
+    if RunResult.should_return:
+        return RunResult.result
+
+    Show_Must_Go_On = True
+
+def CheckPoint(error, fixed, function, chunk, infos, *ToolKit):
+    if DEBUGFILE is True:
+        DebugNotes.extend(
+            checkpoint_runtime.checkpoint_debug_lines(
+                error=error,
+                fixed=fixed,
+                function=function,
+                infos=infos,
+                chunk=chunk,
+                toolkit=ToolKit,
+                pandora_keys=tuple(PandoraBox),
+            )
+        )
+    return checkpoint_runtime.run_checkpoint_from_namespace(
+        globals(),
+        error=error,
+        fixed=fixed,
+        function=function,
+        chunk=chunk,
+        infos=infos,
+        toolkit=ToolKit,
+    )
+
+
+def Pause(msg):
+    prompts.pause_with_legacy_eof_report(
+        Transcript_Input,
+        msg,
+        error_emit=print,
+        stderr_redirector=stderr_redirector,
+        stream_factory=io.BytesIO,
+    )
+    return ()
+
+def PRINT(msg):
+    Finish_Progress_Line()
+    if DEBUGFILE is True:
+        DebugNotes.append(msg)
+    output.append_terminal_transcript(globals(), msg)
+    ui.emit_printable_message(print, msg, max_columns=MAXCHAR, no_dialogue=NODIALOGUE)
+
+#    else:
+#        print("-not print-")
+#        print(msg)
+
+
+def DebugPrint(*args, **kwargs):
+    if DEBUGFILE is True:
+        DebugNotes.append(" ".join(str(arg) for arg in args))
+    print(*args, **kwargs)
+
+def main():
+    parser = cli.configure_parser(ArgumentParser())
+    Args, unknown = parser.parse_known_args()
+    MainOptions = main_runtime.apply_main_cli_options_from_namespace(
+        globals(),
+        Args,
+        unknown,
+        argv_len=len(sys.argv),
+        parser=parser,
+    )
+    if MainOptions is None:
+        return
+    Ensure_Runtime_Dependencies()
+    Configure_Terminal_Color()
+    if Should_Run_Package_Update_Check(Args):
+        Ensure_Package_Current_Or_Continue()
+
+    while True:
+        MainLoopState = main_runtime.run_main_loop_once_from_namespace(globals())
+        if MainLoopState.should_return:
+            return
+
+
+###
+
+
+###
+
+MINIMAL_CHUNKS = list(specs.MINIMAL_CHUNKS)
+CRITICAL_CHUNKS = list(specs.CRITICAL_CHUNKS)
+CHUNKS = list(specs.CHUNKS)
+PRIVATE_CHUNKS = list(specs.PRIVATE_CHUNKS)
+BEFORE_PLTE = list(specs.BEFORE_PLTE)
+AFTER_PLTE = list(specs.AFTER_PLTE)
+BEFORE_IDAT = list(specs.BEFORE_IDAT)
+BEFORE_IDAT2 = list(specs.BEFORE_IDAT2)
+UNIQUE_CHUNK = list(specs.UNIQUE_CHUNK)
+NO_ORDER_CHUNKS = list(specs.NO_ORDER_CHUNKS)
+CHUNKS_LEN_NOT_FIXED = list(specs.CHUNKS_LEN_NOT_FIXED)
+ALLCHUNKS = list(specs.ALLCHUNKS)
+LIBPNG_ERR = list(specs.LIBPNG_ERR)
+
+
+
+IFOP = []
+Chunks_History = []
+IDAT_Bytes_Len_History = []
+Chunks_History_Index = []
+pCAL_Param = []
+PLTE_R = []
+PLTE_G = []
+PLTE_B = []
+Plte_Blst = []
+palette_state = None
+slider_list = []
+wanabyte = b""
+sPLT_Name = []
+sPLT_Depht = []
+sPLT_Red = []
+sPLT_Green = []
+sPLT_Blue = []
+sPLT_Alpha = []
+sPLT_Freq = []
+hIST = []
+tEXt_Key_List = []
+tEXt_Str_List = []
+iTXt_String_List = []
+iTXt_Key_List = []
+tRNS_Index = []
+zTXt_Key_List = []
+zTXt_Str_List = []
+ThksForTheFish = []
+SideNotes = []
+DebugNotes = []
+TerminalTranscript = []
+ERRORSFLAG = []
+
+PandoraBox = {}
+Cornucopia = {}
+IDAT_CRC_PATCH_FAILED = False
+IDAT_CRC_PATCH_FAILED_FINDING = None
+IDAT_CRC_DEFER_EXPLAINED = False
+IDAT_CRC_DEFERRED_FINDINGS = set()
+IDAT_CRC_DEFERRED_ROUTES = set()
+IDAT_DEFLATE_PROBE_KEYS = set()
+WRONG_CHUNK_NAME_TRIED_ROUTES = set()
+REPAIR_ROUTE_STATES = {}
+NEARBY_FOUND_LATER_IEND = None
+FOG_OF_WAR_BAD_CHUNKS = set()
+FOG_OF_WAR_LAST_MAP = None
+FOG_OF_WAR_LAST_WIDTH = None
+FOG_OF_WAR_LAST_RENDER_KEY = None
+FOG_OF_WAR_PREVIEW_CHUNK = None
+FOG_OF_WAR_PREVIEW_ERROR = False
+ArkOfCovenant = {}
+Pandemonium = {}
+CHUNK_INFO_STATE = chunk_state.ChunkInfoState()
+
+
+MAXCHAR = shutil.get_terminal_size(fallback=(120, 24)).columns - 1
+# TMPFIX = False
+
+FirStart = True
+Switch = False
+GoBack = False
+CharPos = 1
+Loading_sep = ""
+PROGRESS_LINE_ACTIVE = False
+Have_A_KitKat = False
+TmpFixIHDR = False
+Warning = False
+Summary_Header = True
+Bad_Current_Name = False
+Bad_Ancillary = False
+Bad_No_Next_Chunk = False
+Bad_Next_Name = False
+Bad_Next_Ancillary = False
+Bad_Length = False
+Bad_Infos = False
+Bad_Crc = False
+Bad_Critical = False
+Bad_Missplaced = False
+Bad_Libpng = False
+Skip_Bad_Current_Name = False
+Skip_Bad_Ancillary = False
+Skip_Bad_No_Next_Chunk = False
+Skip_Bad_Next_Name = False
+Skip_Bad_Next_Ancillary = False
+Skip_Bad_Length = False
+Skip_Bad_Infos = False
+Skip_Bad_Crc = False
+Skip_Bad_Critical = False
+Skip_Bad_Missplaced = False
+Skip_Bad_Libpng = False
+EOF = False
+Show_Must_Go_On = False
+CLEAR = False
+CLEAR_SCREEN_ACTIVE_THIS_PASS = False
+LAST_QUESTION_STATUS = None
+FINAL_IMAGE_OPEN_REQUESTED = False
+CRASH = False
+PAUSE = False
+DEBUG = False
+DEBUGFILE = False
+PAUSEDEBUG = False
+PAUSEERROR = False
+PAUSEDIALOGUE = False
+DIALOGUE_PAUSE_STATE = ui_runtime.LegacyDialoguePauseState()
+NODIALOGUE = False
+AUTO = False
+COLOR_MODE = "auto"
+USE_COLOR = os.name != "nt"
+CLONESWAR = False
+MAX_SAVES = None
+SAVE_COUNT = 0
+ULTIMATE_LINEFEED_PREVIEW_TIMEOUT = 5.0
+ULTIMATE_LINEFEED_SHOW_PREVIEWS = False
+ULTIMATE_LINEFEED_REFERENCE_MODE = "exact"
+ULTIMATE_LINEFEED_REFERENCE_REGIONS = ""
+ULTIMATE_LINEFEED_REFERENCE_REGION_EDITOR = False
+ULTIMATE_LINEFEED_VISUAL_GALLERY_LIMIT = 100
+ULTIMATE_LINEFEED_VISUAL_MIN_COVERAGE = 0.95
+ULTIMATE_LINEFEED_RESUME = "ask"
+ULTIMATE_LINEFEED_LIVE_PREVIEW_FOLDER_REPORTED = ""
+SMASH_BRUTE_BRAWL_RESUME = "ask"
+SMASH_BRUTE_BRAWL_WORKERS = None
+
+FishPos = 0
+LenFishList = 0
+Brute_LvL = 0
+IBN = 0
+IDAT_Bytes_Len = 0
+IDAT_Datastream = ""
+idatcounter = 0
+ETA = 0
+Old_Bad_Crc = ""
+IDAT_Avg_Len = ""
+FILE_Origin = ""
+FILE_DIR = ""
+Loading_txt = ""
+DIFF = ""
+DATAX = ""
+DATA_BYTES = b""
+Sample_Name = ""
+Sample = ""
+
+Raw_Length = ""
+Raw_Data = ""
+Raw_Crc = ""
+Raw_NextChunk = ""
+Raw_Type = ""
+Orig_CL = ""
+Orig_CT = ""
+Orig_NC = ""
+Orig_CD = ""
+Orig_CRC = ""
+CLoffX = ""
+CLoffB = ""
+CLoffI = ""
+CToffX = ""
+CToffB = ""
+CToffI = ""
+NCoffX = ""
+NCoffB = ""
+NCoffI = ""
+NCoff_CRC = ""
+Bad_Ancillary = ""
+CDoffX = ""
+CDoffB = ""
+CDoffI = ""
+CrcoffX = ""
+CrcoffB = ""
+CrcoffI = ""
+iCCP_Name = ""
+iCCP_Method = ""
+iCCP_Profile = ""
+IHDR_Height = 0
+IHDR_Width = 0
+IHDR_Depht = ""
+IHDR_Color = ""
+IHDR_Method = ""
+IHDR_Filter = ""
+IHDR_Interlace = ""
+bKGD_Gray = ""
+bKGD_Red = ""
+bKGD_Green = ""
+bKGD_Blue = ""
+bKGD_Index = ""
+sRGB = ""
+
+pCAL_Key = ""
+pCAL_Zero = ""
+pCAL_Max = ""
+pCAL_Eq = ""
+pCAL_PNBR = ""
+
+cHRM_WhiteX = ""
+cHRM_WhiteY = ""
+cHRM_Redx = ""
+cHRM_Redy = ""
+cHRM_Greenx = ""
+cHRM_Greeny = ""
+cHRM_Bluex = ""
+cHRM_Bluey = ""
+
+gAMA = ""
+
+pHYs_Y = ""
+pHYs_X = ""
+pHYs_Unit = ""
+sTER = ""
+gIFID = ""
+gIFCD = ""
+gIFDT = ""
+gIFgM = ""
+gIFgU = ""
+gIFgT = ""
+
+sBIT_Gray = ""
+sBIT_TrueR = ""
+sBIT_TrueG = ""
+sBIT_TrueB = ""
+sBIT_GrayScale = ""
+sBIT_GrayAlpha = ""
+sBIT_TrueAlphaR = ""
+sBIT_TrueAlphaG = ""
+sBIT_TrueAlphaB = ""
+sBIT_TrueAlpha = ""
+
+tEXt_Key = ""
+tEXt_Text = ""
+
+iTXt_String = ""
+iTXt_Key = ""
+tIME_Yr = ""
+tIME_Mth = ""
+tIME_Day = ""
+tIME_Hr = ""
+tIME_Min = ""
+tIME_Sec = ""
+tRNS_Gray = ""
+tRNS_TrueR = ""
+tRNS_TrueG = ""
+tRNS_TrueB = ""
+
+zTXt_Key = ""
+zTXt_Meth = ""
+zTXt_Text = ""
+eXIf_endian = ""
+
+Web_Safe_Colors =['000000', '000033', '000066', '000099', '0000cc', '0000ff', '003300', '003333', '003366', '003399', '0033cc', '0033ff', '006600', '006633', '006666', '006699', '0066cc', '0066ff', '009900', '009933', '009966', '009999', '0099cc', '0099ff', '00cc00', '00cc33', '00cc66', '00cc99', '00cccc', '00ccff', '00ff00', '00ff33', '00ff66', '00ff99', '00ffcc', '00ffff', '330000', '330033', '330066', '330099', '3300cc', '3300ff', '333300', '333333', '333366', '333399', '3333cc', '3333ff', '336600', '336633', '336666', '336699', '3366cc', '3366ff', '339900', '339933', '339966', '339999', '3399cc', '3399ff', '33cc00', '33cc33', '33cc66', '33cc99', '33cccc', '33ccff', '33ff00', '33ff33', '33ff66', '33ff99', '33ffcc', '33ffff', '660000', '660033', '660066', '660099', '6600cc', '6600ff', '663300', '663333', '663366', '663399', '6633cc', '6633ff', '666600', '666633', '666666', '666699', '6666cc', '6666ff', '669900', '669933', '669966', '669999', '6699cc', '6699ff', '66cc00', '66cc33', '66cc66', '66cc99', '66cccc', '66ccff', '66ff00', '66ff33', '66ff66', '66ff99', '66ffcc', '66ffff', '990000', '990033', '990066', '990099', '9900cc', '9900ff', '993300', '993333', '993366', '993399', '9933cc', '9933ff', '996600', '996633', '996666', '996699', '9966cc', '9966ff', '999900', '999933', '999966', '999999', '9999cc', '9999ff', '99cc00', '99cc33', '99cc66', '99cc99', '99cccc', '99ccff', '99ff00', '99ff33', '99ff66', '99ff99', '99ffcc', '99ffff', 'cc0000', 'cc0033', 'cc0066', 'cc0099', 'cc00cc', 'cc00ff', 'cc3300', 'cc3333', 'cc3366', 'cc3399', 'cc33cc', 'cc33ff', 'cc6600', 'cc6633', 'cc6666', 'cc6699', 'cc66cc', 'cc66ff', 'cc9900', 'cc9933', 'cc9966', 'cc9999', 'cc99cc', 'cc99ff', 'cccc00', 'cccc33', 'cccc66', 'cccc99', 'cccccc', 'ccccff', 'ccff00', 'ccff33', 'ccff66', 'ccff99', 'ccffcc', 'ccffff', 'ff0000', 'ff0033', 'ff0066', 'ff0099', 'ff00cc', 'ff00ff', 'ff3300', 'ff3333', 'ff3366', 'ff3399', 'ff33cc', 'ff33ff', 'ff6600', 'ff6633', 'ff6666', 'ff6699', 'ff66cc', 'ff66ff', 'ff9900', 'ff9933', 'ff9966', 'ff9999', 'ff99cc', 'ff99ff', 'ffcc00', 'ffcc33', 'ffcc66', 'ffcc99', 'ffcccc', 'ffccff', 'ffff00', 'ffff33', 'ffff66', 'ffff99', 'ffffcc', 'ffffff']
+
+X11_Colors =[
+  "000000",
+  "800000",
+  "008000",
+  "808000",
+  "000080",
+  "800080",
+  "008080",
+  "c0c0c0",
+  "808080",
+  "ff0000",
+  "00ff00",
+  "ffff00",
+  "0000ff",
+  "ff00ff",
+  "00ffff",
+  "ffffff",
+  "000000",
+  "00005f",
+  "000087",
+  "0000af",
+  "0000d7",
+  "0000ff",
+  "005f00",
+  "005f5f",
+  "005f87",
+  "005faf",
+  "005fd7",
+  "005fff",
+  "008700",
+  "00875f",
+  "008787",
+  "0087af",
+  "0087d7",
+  "0087ff",
+  "00af00",
+  "00af5f",
+  "00af87",
+  "00afaf",
+  "00afd7",
+  "00afff",
+  "00d700",
+  "00d75f",
+  "00d787",
+  "00d7af",
+  "00d7d7",
+  "00d7ff",
+  "00ff00",
+  "00ff5f",
+  "00ff87",
+  "00ffaf",
+  "00ffd7",
+  "00ffff",
+  "5f0000",
+  "5f005f",
+  "5f0087",
+  "5f00af",
+  "5f00d7",
+  "5f00ff",
+  "5f5f00",
+  "5f5f5f",
+  "5f5f87",
+  "5f5faf",
+  "5f5fd7",
+  "5f5fff",
+  "5f8700",
+  "5f875f",
+  "5f8787",
+  "5f87af",
+  "5f87d7",
+  "5f87ff",
+  "5faf00",
+  "5faf5f",
+  "5faf87",
+  "5fafaf",
+  "5fafd7",
+  "5fafff",
+  "5fd700",
+  "5fd75f",
+  "5fd787",
+  "5fd7af",
+  "5fd7d7",
+  "5fd7ff",
+  "5fff00",
+  "5fff5f",
+  "5fff87",
+  "5fffaf",
+  "5fffd7",
+  "5fffff",
+  "870000",
+  "87005f",
+  "870087",
+  "8700af",
+  "8700d7",
+  "8700ff",
+  "875f00",
+  "875f5f",
+  "875f87",
+  "875faf",
+  "875fd7",
+  "875fff",
+  "878700",
+  "87875f",
+  "878787",
+  "8787af",
+  "8787d7",
+  "8787ff",
+  "87af00",
+  "87af5f",
+  "87af87",
+  "87afaf",
+  "87afd7",
+  "87afff",
+  "87d700",
+  "87d75f",
+  "87d787",
+  "87d7af",
+  "87d7d7",
+  "87d7ff",
+  "87ff00",
+  "87ff5f",
+  "87ff87",
+  "87ffaf",
+  "87ffd7",
+  "87ffff",
+  "af0000",
+  "af005f",
+  "af0087",
+  "af00af",
+  "af00d7",
+  "af00ff",
+  "af5f00",
+  "af5f5f",
+  "af5f87",
+  "af5faf",
+  "af5fd7",
+  "af5fff",
+  "af8700",
+  "af875f",
+  "af8787",
+  "af87af",
+  "af87d7",
+  "af87ff",
+  "afaf00",
+  "afaf5f",
+  "afaf87",
+  "afafaf",
+  "afafd7",
+  "afafff",
+  "afd700",
+  "afd75f",
+  "afd787",
+  "afd7af",
+  "afd7d7",
+  "afd7ff",
+  "afff00",
+  "afff5f",
+  "afff87",
+  "afffaf",
+  "afffd7",
+  "afffff",
+  "d70000",
+  "d7005f",
+  "d70087",
+  "d700af",
+  "d700d7",
+  "d700ff",
+  "d75f00",
+  "d75f5f",
+  "d75f87",
+  "d75faf",
+  "d75fd7",
+  "d75fff",
+  "d78700",
+  "d7875f",
+  "d78787",
+  "d787af",
+  "d787d7",
+  "d787ff",
+  "d7af00",
+  "d7af5f",
+  "d7af87",
+  "d7afaf",
+  "d7afd7",
+  "d7afff",
+  "d7d700",
+  "d7d75f",
+  "d7d787",
+  "d7d7af",
+  "d7d7d7",
+  "d7d7ff",
+  "d7ff00",
+  "d7ff5f",
+  "d7ff87",
+  "d7ffaf",
+  "d7ffd7",
+  "d7ffff",
+  "ff0000",
+  "ff005f",
+  "ff0087",
+  "ff00af",
+  "ff00d7",
+  "ff00ff",
+  "ff5f00",
+  "ff5f5f",
+  "ff5f87",
+  "ff5faf",
+  "ff5fd7",
+  "ff5fff",
+  "ff8700",
+  "ff875f",
+  "ff8787",
+  "ff87af",
+  "ff87d7",
+  "ff87ff",
+  "ffaf00",
+  "ffaf5f",
+  "ffaf87",
+  "ffafaf",
+  "ffafd7",
+  "ffafff",
+  "ffd700",
+  "ffd75f",
+  "ffd787",
+  "ffd7af",
+  "ffd7d7",
+  "ffd7ff",
+  "ffff00",
+  "ffff5f",
+  "ffff87",
+  "ffffaf",
+  "ffffd7",
+  "ffffff",
+  "080808",
+  "121212",
+  "1c1c1c",
+  "262626",
+  "303030",
+  "3a3a3a",
+  "444444",
+  "4e4e4e",
+  "585858",
+  "606060",
+  "666666",
+  "767676",
+  "808080",
+  "8a8a8a",
+  "949494",
+  "9e9e9e",
+  "a8a8a8",
+  "b2b2b2",
+  "bcbcbc",
+  "c6c6c6",
+  "d0d0d0",
+  "dadada",
+  "e4e4e4",
+  "eeeeee"
+]
+
+
+if __name__ == "__main__":
+    main()