Datasets:

HongchengGao
/

EngiWorld-Tasks

from __future__ import annotations

import base64
import hashlib
import json
import math
import os
import re
import stat
import subprocess
import sys
import tempfile
import zipfile
import xml.etree.ElementTree as ET
from collections import Counter
from pathlib import Path, PurePosixPath


TARGET = Path("/home/user/Desktop")
STEP = TARGET / "relief_surface.step"
FCSTD = TARGET / "task-18.FCStd"
NC = TARGET / "task-18.nc"
FREECADCMD = Path("/usr/bin/freecadcmd")
EXPECTED_STEP_SHA256 = "82c2721b1d0bdd3bd76bdab27fd537828a0b1b96f1c2f6bc491e144382aec9e6"
EXPECTED_VERSION = ("0", "21", "2", "33771 (Git)")
EXPECTED_COMMIT = "b9bfa5c5507506e4515816414cd27f4851d00489"
NUMBER = r"[+-]?(?:\d+(?:\.\d*)?|\.\d+)"
WORD_RE = re.compile(rf"([A-Z])\s*({NUMBER})", re.ASCII)
ALLOWED_ADDRESSES = {"N", "G", "M", "T", "H", "S", "F", "X", "Y", "Z", "I", "J", "R", "P", "Q"}
ALLOWED_G = {0, 1, 2, 3, 17, 21, 40, 43, 49, 54, 80, 90, 94}
ALLOWED_M = {2, 3, 5, 6, 30}
G_MODAL_GROUPS = (
    {0, 1, 2, 3, 80},
    {17},
    {21},
    {40},
    {43, 49},
    {54},
    {90},
    {94},
)
PROXY_COUNTS = Counter(
    {
        ("Path.Main.Job", "ObjectJob"): 1,
        ("Path.Base.SetupSheet", "SetupSheet"): 1,
        ("draftobjects.clone", "Clone"): 1,
        ("Path.Tool.Controller", "ToolController"): 2,
        ("Path.Tool.Bit", "ToolBit"): 2,
        ("Path.Main.Stock", "StockFromBase"): 1,
        ("Path.Op.Pocket", "ObjectPocket"): 1,
        ("Path.Op.Surface", "ObjectSurface"): 1,
    }
)
ALLOWED_EXTERNAL_FILES = {
    "",
    "/home/user/Desktop/task-18.nc",
    "/usr/lib/freecad/Mod/Path/Tools/Shape/endmill.fcstd",
    "/usr/share/freecad/Mod/Path/Tools/Shape/endmill.fcstd",
    "/usr/lib/freecad/Mod/Path/Tools/Shape/ballend.fcstd",
    "/usr/share/freecad/Mod/Path/Tools/Shape/ballend.fcstd",
    "/usr/lib/freecad/Mod/Path/Tools/Bit/6mm_Ball_End.fctb",
    "/usr/share/freecad/Mod/Path/Tools/Bit/6mm_Ball_End.fctb",
}


def fail(message):
    print("task-18 evaluator: " + message, file=sys.stderr)
    return False


def close(left, right, tolerance=1e-6):
    try:
        a, b = float(left), float(right)
    except (TypeError, ValueError):
        return False
    return math.isfinite(a) and math.isfinite(b) and abs(a - b) <= tolerance


def regular_file(path, minimum, maximum):
    try:
        info = path.lstat()
    except OSError:
        return False
    return (
        stat.S_ISREG(info.st_mode)
        and not path.is_symlink()
        and minimum <= info.st_size <= maximum
    )


def sha256(path):
    digest = hashlib.sha256()
    with path.open("rb") as stream:
        for chunk in iter(lambda: stream.read(1024 * 1024), b""):
            digest.update(chunk)
    return digest.hexdigest()


def normalized_text_sha256(path):
    data = path.read_bytes().replace(b"\r\n", b"\n").replace(b"\r", b"\n")
    return hashlib.sha256(data).hexdigest()


def freeze_file(source, target, minimum, maximum):
    flags = os.O_RDONLY | os.O_CLOEXEC | os.O_NOFOLLOW
    try:
        descriptor = os.open(source, flags)
        try:
            before = os.fstat(descriptor)
            if not stat.S_ISREG(before.st_mode) or not minimum <= before.st_size <= maximum:
                return False
            chunks = []
            remaining = maximum + 1
            while remaining:
                chunk = os.read(descriptor, min(1024 * 1024, remaining))
                if not chunk:
                    break
                chunks.append(chunk)
                remaining -= len(chunk)
            after = os.fstat(descriptor)
        finally:
            os.close(descriptor)
        stable = (
            before.st_dev,
            before.st_ino,
            before.st_size,
            before.st_mtime_ns,
            before.st_ctime_ns,
        ) == (
            after.st_dev,
            after.st_ino,
            after.st_size,
            after.st_mtime_ns,
            after.st_ctime_ns,
        )
        data = b"".join(chunks)
        if not stable or len(data) != before.st_size:
            return False
        target.write_bytes(data)
        target.chmod(0o600)
        return True
    except OSError:
        return False


def validate_archive(path):
    if not regular_file(path, 10_000, 10_000_000):
        return False
    try:
        with zipfile.ZipFile(path) as archive:
            names = archive.namelist()
            if "Document.xml" not in names or len(names) != len(set(names)) or len(names) > 100:
                return False
            total = 0
            for entry in archive.infolist():
                pure = PurePosixPath(entry.filename)
                mode = entry.external_attr >> 16
                if (
                    not entry.filename
                    or "\\" in entry.filename
                    or pure.is_absolute()
                    or ".." in pure.parts
                    or entry.flag_bits & 1
                    or stat.S_ISLNK(mode)
                    or entry.file_size > 10_000_000
                    or (entry.compress_size == 0 and entry.file_size > 0)
                    or (entry.compress_size and entry.file_size / entry.compress_size > 300)
                    or pure.suffix.lower() in {".py", ".pyc", ".pyo", ".sh", ".so", ".dll", ".dylib", ".exe"}
                ):
                    return False
                total += entry.file_size
                if total > 40_000_000:
                    return False
            root = ET.fromstring(archive.read("Document.xml"))
            proxies = Counter()
            for element in root.iter("Python"):
                module = element.attrib.get("module")
                class_name = element.attrib.get("class")
                encoded = element.attrib.get("encoded")
                value = element.attrib.get("value")
                if encoded != "yes" or not isinstance(value, str) or len(value) > 100_000:
                    return False
                payload = json.loads(base64.b64decode(value, validate=True).decode("utf-8"))
                if payload is not None and not isinstance(payload, (dict, str)):
                    return False
                proxies[(module, class_name)] += 1
            if proxies != PROXY_COUNTS:
                return False
            for prop in root.iter("Property"):
                if prop.attrib.get("type") != "App::PropertyFile":
                    continue
                values = [child.attrib.get("value") for child in prop if child.tag == "String"]
                if len(values) != 1 or values[0] not in ALLOWED_EXTERNAL_FILES:
                    return False
            for element in root.iter():
                if element.tag not in {"Part", "Path"}:
                    continue
                member = element.attrib.get("file")
                if not member or member not in names or PurePosixPath(member).suffix.lower() not in {".brp", ".nc"}:
                    return False
            return True
    except (
        OSError,
        UnicodeError,
        ValueError,
        zipfile.BadZipFile,
        ET.ParseError,
        json.JSONDecodeError,
    ):
        return False


def strip_comments(text):
    output = []
    in_comment = False
    for line in text.replace("\r\n", "\n").replace("\r", "\n").split("\n"):
        code = []
        for char in line:
            if in_comment:
                if char == "(":
                    return None
                if char == ")":
                    in_comment = False
            elif char == "(":
                in_comment = True
            elif char == ")":
                return None
            elif char == ";":
                break
            else:
                code.append(char)
        output.append("".join(code))
    return None if in_comment else "\n".join(output)


def integral(value):
    rounded = round(value)
    return int(rounded) if math.isfinite(value) and abs(value - rounded) <= 1e-9 else None


def parse_nc(path):
    try:
        executable = strip_comments(path.read_text(encoding="utf-8"))
    except (OSError, UnicodeError):
        return None
    if executable is None:
        return None
    blocks = []
    for raw in executable.splitlines():
        line = raw.strip().upper()
        if not line or line == "%":
            continue
        words = []
        cursor = 0
        for match in WORD_RE.finditer(line):
            if line[cursor : match.start()].strip():
                return None
            value = float(match.group(2))
            if not math.isfinite(value):
                return None
            words.append((match.group(1), value))
            cursor = match.end()
        if line[cursor:].strip() or not words:
            return None
        if any(letter not in ALLOWED_ADDRESSES for letter, _ in words):
            return None
        if any(
            sum(letter == address for letter, _ in words) > 1
            for address in ALLOWED_ADDRESSES - {"G", "M"}
        ):
            return None
        blocks.append(words)
    return blocks or None


def validate_nc(path):
    if not regular_file(path, 10_000, 2_000_000):
        return False
    blocks = parse_nc(path)
    if blocks is None:
        return False
    state = {
        "units": None,
        "absolute": False,
        "plane": None,
        "wcs": None,
        "motion": None,
        "tool": None,
        "changed": False,
        "speed": None,
        "feed": None,
        "spindle": False,
        "X": None,
        "Y": None,
        "Z": None,
    }
    changed_tools = []
    cuts = {1: [], 2: []}
    ended = False
    for index, block in enumerate(blocks):
        words = dict(block)
        gs = [integral(value) for letter, value in block if letter == "G"]
        ms = [integral(value) for letter, value in block if letter == "M"]
        if ended:
            return False
        if any(code is None or code not in ALLOWED_G for code in gs):
            return False
        if any(code is None or code not in ALLOWED_M for code in ms):
            return False
        if any(sum(code in group for code in gs) > 1 for group in G_MODAL_GROUPS):
            return False
        if len(ms) != len(set(ms)) or (2 in ms and 30 in ms):
            return False
        if 21 in gs:
            state["units"] = "mm"
        if 17 in gs:
            state["plane"] = "XY"
        if 90 in gs:
            state["absolute"] = True
        if 54 in gs:
            state["wcs"] = 54
        for code in gs:
            if code in {0, 1, 2, 3}:
                state["motion"] = code
        if "T" in words:
            tool = integral(words["T"])
            if tool not in {1, 2}:
                return False
            if tool != state["tool"]:
                state["changed"] = False
            state["tool"] = tool
        if "H" in words and integral(words["H"]) != state["tool"]:
            return False
        if "S" in words:
            if not close(words["S"], 7000):
                return False
            state["speed"] = words["S"]
        if "F" in words:
            if state["units"] != "mm" or not close(words["F"], 500, 0.01):
                return False
            state["feed"] = words["F"]
        if 5 in ms:
            state["spindle"] = False
        if 6 in ms:
            if state["spindle"] or state["tool"] not in {1, 2}:
                return False
            state["changed"] = True
            changed_tools.append(state["tool"])
        if 3 in ms:
            if not state["changed"] or state["speed"] is None:
                return False
            state["spindle"] = True

        before = (state["X"], state["Y"], state["Z"])
        for axis in ("X", "Y", "Z"):
            if axis in words:
                state[axis] = words[axis]
        motion = next((code for code in gs if code in {0, 1, 2, 3}), state["motion"])
        has_axis = any(axis in words for axis in ("X", "Y", "Z"))
        if has_axis and motion == 0 and any(axis in words for axis in ("X", "Y")):
            if state["Z"] is None or state["Z"] < 20.0 - 1e-6:
                return False
        if has_axis and motion in {1, 2, 3}:
            if (
                state["tool"] not in {1, 2}
                or not state["changed"]
                or not state["spindle"]
                or state["speed"] is None
                or state["feed"] is None
                or state["units"] != "mm"
                or not state["absolute"]
                or state["plane"] != "XY"
                or state["wcs"] != 54
                or any(state[axis] is None for axis in ("X", "Y", "Z"))
            ):
                return False
            if not (-60.001 <= state["X"] <= 60.001 and -40.001 <= state["Y"] <= 40.001 and 9.999 <= state["Z"] <= 23.001):
                return False
            if motion in {2, 3} and not all(letter in words for letter in ("I", "J")):
                return False
            cuts[state["tool"]].append((state["X"], state["Y"], state["Z"], motion, before))
        if 2 in ms or 30 in ms:
            if index != len(blocks) - 1 or state["spindle"]:
                return False
            ended = True

    if not ended or changed_tools != [1, 2]:
        return False
    t1, t2 = cuts[1], cuts[2]
    if len(t1) < 200 or len(t2) < 450:
        return False
    t1_x = [point[0] for point in t1]
    t1_y = [point[1] for point in t1]
    t1_z = [point[2] for point in t1]
    if not (
        close(min(t1_x), -54.5, 0.02)
        and close(max(t1_x), 54.5, 0.02)
        and close(min(t1_y), -34.5, 0.02)
        and close(max(t1_y), 34.5, 0.02)
        and close(min(t1_z), 12.0, 0.01)
        and close(max(t1_z), 16.0, 0.01)
    ):
        return False
    t2_x = [point[0] for point in t2]
    t2_y = [point[1] for point in t2]
    t2_z = [point[2] for point in t2]
    scanlines = sorted({round(value, 4) for value in t2_y})
    if not (
        min(t2_x) < -56.0
        and max(t2_x) > 56.0
        and min(t2_y) <= -36.0
        and max(t2_y) >= 36.0
        and close(min(t2_z), 10.0, 0.01)
        and max(t2_z) > 17.0
        and len(scanlines) >= 49
        and max(b - a for a, b in zip(scanlines, scanlines[1:])) <= 1.5001
    ):
        return False
    return True


CHILD_SOURCE = r'''
import builtins
import hashlib
import json
import math
import os
import pathlib
import re
import sys
import traceback

builtins.pythonopen = open

import FreeCAD as App
import Import
import Part
import Path.Post.Command as PathPostCommand
from Path.Post.Processor import PostProcessor

EXPECTED_VERSION=("0","21","2","33771 (Git)")
EXPECTED_COMMIT="b9bfa5c5507506e4515816414cd27f4851d00489"
TIMESTAMP_RE=re.compile(r"\(Output Time:[^()\r\n]*\)")
CODE_WORD_RE=re.compile(r"([A-Z])\s*([+-]?(?:\d+(?:\.\d*)?|\.\d+))")

def close(a,b,t=1e-6):
 try:return math.isfinite(float(a)) and math.isfinite(float(b)) and abs(float(a)-float(b))<=t
 except (TypeError,ValueError):return False
def module(o):return getattr(getattr(o,"Proxy",None).__class__,"__module__","")
def same_shape(a,b,t=1e-5):return a.isValid() and b.isValid() and a.cut(b).Volume<=t and b.cut(a).Volume<=t
def expected_shape():
 base=Part.makeBox(120,80,10,App.Vector(-60,-40,0))
 sphere=Part.makeSphere(30,App.Vector(0,0,-12))
 cap=sphere.common(Part.makeBox(120,80,8,App.Vector(-60,-40,10)))
 return base.fuse(cap).removeSplitter()
def face_types(op,model):
 if len(op.Base)!=1 or op.Base[0][0]!=model:return None
 names=list(op.Base[0][1])
 if len(names)!=2:return None
 result=[]
 for name in names:
  face=getattr(model.Shape,name);typ=type(face.Surface).__name__;box=face.BoundBox
  if typ=="Plane" and close(box.ZMin,10) and close(box.ZMax,10):result.append("Plane")
  elif typ=="Sphere" and box.ZMin>=10-1e-7 and close(box.ZMax,18):result.append("Sphere")
  else:return None
 return set(result)
def path_stats(op):
 pos={"X":None,"Y":None,"Z":None};cuts=[];motions=0
 for command in op.Path.Commands:
  name=str(command.Name).upper().replace(" ","")
  for axis in pos:
   if axis in command.Parameters:pos[axis]=float(command.Parameters[axis])
  if name in {"G0","G1","G2","G3"}:motions+=1
  if name in {"G1","G2","G3"} and all(pos[a] is not None for a in pos):cuts.append(tuple(pos[a] for a in ("X","Y","Z")))
 return motions,cuts
def code_signature(path):
 text=pathlib.Path(path).read_text(encoding="utf-8").replace("\r\n","\n").replace("\r","\n")
 text=re.sub(r"\([^()]*\)","",text)
 result=[]
 for raw in text.splitlines():
  line=raw.split(";",1)[0].strip().upper()
  if not line or line=="%":continue
  words=[];cursor=0
  for match in CODE_WORD_RE.finditer(line):
   if line[cursor:match.start()].strip():return None
   value=float(match.group(2));value=0.0 if abs(value)<0.0000005 else round(value,6)
   words.append((match.group(1),value));cursor=match.end()
  if line[cursor:].strip() or not words:return None
  result.append(tuple(words))
 return tuple(result)
def validate(step_path,fcstd_path,nc_path,repost_path):
 if tuple(App.Version()[:4])!=EXPECTED_VERSION or App.Version()[-1]!=EXPECTED_COMMIT:return False
 expected=expected_shape()
 source_doc=App.newDocument("Task18SourceCheck")
 try:
  Import.insert(str(step_path),source_doc.Name);source_doc.recompute()
  source_shapes=[o.Shape for o in source_doc.Objects if hasattr(o,"Shape") and not o.Shape.isNull()]
  if len(source_shapes)!=1:return False
  source=source_shapes[0]
  if len(source.Solids)!=1 or not same_shape(source,expected):return False
 finally:
  App.closeDocument(source_doc.Name)
 doc=App.openDocument(str(fcstd_path))
 try:
  jobs=[o for o in doc.Objects if module(o)=="Path.Main.Job"]
  pockets=[o for o in doc.Objects if module(o)=="Path.Op.Pocket"]
  surfaces=[o for o in doc.Objects if module(o)=="Path.Op.Surface"]
  ctrls=[o for o in doc.Objects if module(o)=="Path.Tool.Controller"]
  tools=[o for o in doc.Objects if module(o)=="Path.Tool.Bit"]
  if len(jobs)!=1 or len(pockets)!=1 or len(surfaces)!=1 or len(ctrls)!=2 or len(tools)!=2:return False
  job=jobs[0];pocket=pockets[0];surface=surfaces[0]
  if job.Operations.Group!=[pocket,surface] or len(job.Model.Group)!=1:return False
  model=job.Model.Group[0]
  if module(model)!="draftobjects.clone" or not same_shape(model.Shape,expected):return False
  if str(job.PostProcessor).lower()!="linuxcnc" or list(job.Fixtures)!=["G54"] or bool(job.SplitOutput):return False
  if os.path.normpath(str(job.PostProcessorOutputFile))!="/home/user/Desktop/task-18.nc":return False
  stock=job.Stock
  stock_expected=Part.makeBox(120,80,18,App.Vector(-60,-40,0))
  if module(stock)!="Path.Main.Stock" or not same_shape(stock.Shape,stock_expected):return False
  if any(not close(getattr(stock,name),0) for name in ("ExtXneg","ExtXpos","ExtYneg","ExtYpos","ExtZneg","ExtZpos")):return False
  by_number={int(tc.ToolNumber):tc for tc in ctrls}
  if set(by_number)!={1,2} or [int(tc.ToolNumber) for tc in job.Tools.Group]!=[1,2]:return False
  t1,t2=by_number[1],by_number[2]
  if pocket.ToolController!=t1 or surface.ToolController!=t2:return False
  if t1.Tool not in tools or t2.Tool not in tools or t1.Tool==t2.Tool:return False
  for tc,diameter,shape_name in ((t1,10,"endmill"),(t2,6,"ballend")):
   tool=tc.Tool
   if not close(tool.Diameter,diameter) or not close(tool.ShankDiameter,diameter) or not close(tool.Length,50) or str(tool.ShapeName)!=shape_name:return False
   if tool.Shape.isNull() or len(tool.Shape.Solids)!=1:return False
   if not close(tc.SpindleSpeed,7000) or str(tc.SpindleDir)!="Forward":return False
   if not close(tc.HorizFeed.getValueAs("mm/min").Value,500) or not close(tc.VertFeed.getValueAs("mm/min").Value,500):return False
  if not close(t1.Tool.CuttingEdgeHeight,25):return False
  if face_types(pocket,model)!={"Plane","Sphere"} or face_types(surface,model)!={"Plane","Sphere"}:return False
  if not bool(pocket.Active) or bool(pocket.ProcessStockArea) or not close(pocket.ExtraOffset,0.5):return False
  if not close(pocket.StartDepth,18) or not close(pocket.FinalDepth,10) or not close(pocket.StepDown,2) or not close(float(pocket.StepOver),50):return False
  if pocket.SafeHeight.Value<20-1e-7 or pocket.ClearanceHeight.Value<23-1e-7:return False
  if not bool(surface.Active) or not close(surface.StartDepth,18) or not close(surface.FinalDepth,10) or not close(surface.DepthOffset,0):return False
  if str(surface.ScanType)!="Planar" or str(surface.LayerMode)!="Single-pass" or str(surface.BoundBox)!="BaseBoundBox":return False
  stepover=t2.Tool.Diameter.Value*float(surface.StepOver)/100.0
  if stepover<=0 or stepover>1.5+1e-9 or not close(stepover,1.5):return False
  if surface.SampleInterval.Value<=0 or surface.SampleInterval.Value>1.5:return False
  doc.recompute();doc.recompute()
  if list(pocket.State)!=["Up-to-date"] or list(surface.State)!=["Up-to-date"]:return False
  pm,pc=path_stats(pocket);sm,sc=path_stats(surface)
  if pm<200 or sm<500 or len(pc)<200 or len(sc)<450:return False
  if not close(min(p[2] for p in pc),12,0.01) or not close(max(p[2] for p in pc),16,0.01):return False
  if not close(min(p[2] for p in sc),10,0.01) or max(p[2] for p in sc)<=17:return False
  sections=PathPostCommand.buildPostList(job)
  if len(sections)!=1:return False
  PostProcessor.load("linuxcnc").export(sections[0][1],str(repost_path),job.PostProcessorArgs)
  repost_sig=code_signature(repost_path);submitted_sig=code_signature(nc_path)
  if repost_sig!=submitted_sig:
   return False
  return True
 finally:
  App.closeDocument(doc.Name)

ok=False
try:ok=validate(pathlib.Path(os.environ["TASK18_STEP"]),pathlib.Path(os.environ["TASK18_FCSTD"]),pathlib.Path(os.environ["TASK18_NC"]),pathlib.Path(os.environ["TASK18_REPOST"]))
except Exception as error:
 print("task-18 child: %s"%error,file=sys.stderr)
 traceback.print_exc()
pathlib.Path(os.environ["TASK18_RESULT"]).write_text(json.dumps({"ok":bool(ok)},sort_keys=True),encoding="utf-8")
raise SystemExit(0 if ok else 1)
'''


def validate_freecad(step_path, fcstd_path, nc_path, workdir):
    child = workdir / "validate_task18.py"
    repost = workdir / "repost.nc"
    result_file = workdir / "result.json"
    child.write_text(CHILD_SOURCE, encoding="utf-8")
    child.chmod(0o600)
    try:
        result = subprocess.run(
            [
                str(FREECADCMD),
                str(child),
            ],
            cwd=workdir,
            stdin=subprocess.DEVNULL,
            stdout=subprocess.PIPE,
            stderr=subprocess.PIPE,
            text=True,
            timeout=240,
            check=False,
            env={
                "HOME": str(workdir),
                "LANG": "C.UTF-8",
                "LC_ALL": "C.UTF-8",
                "PATH": "/usr/bin:/bin",
                "TMPDIR": str(workdir),
                "TASK18_STEP": str(step_path),
                "TASK18_FCSTD": str(fcstd_path),
                "TASK18_NC": str(nc_path),
                "TASK18_REPOST": str(repost),
                "TASK18_RESULT": str(result_file),
            },
        )
    except (OSError, subprocess.TimeoutExpired):
        return False
    try:
        payload = json.loads(result_file.read_text(encoding="utf-8"))
    except (OSError, UnicodeError, json.JSONDecodeError):
        payload = None
    if payload != {"ok": True}:
        if result.stderr:
            print(result.stderr[-4000:], file=sys.stderr)
        return False
    return regular_file(repost, 10_000, 2_000_000)


def main():
    if not FREECADCMD.is_file():
        return fail("freecadcmd missing")
    if not regular_file(STEP, 2_000, 2_000_000):
        return fail("invalid STEP file")
    if normalized_text_sha256(STEP) != EXPECTED_STEP_SHA256:
        return fail("wrong init STEP")
    if not validate_archive(FCSTD):
        return fail("invalid FCStd archive")
    if not validate_nc(NC):
        return fail("invalid NC semantics")
    with tempfile.TemporaryDirectory(prefix="task-18-eval-") as directory:
        workdir = Path(directory)
        frozen_step = workdir / "relief_surface.step"
        frozen_fcstd = workdir / "task-18.FCStd"
        frozen_nc = workdir / "task-18.nc"
        if not freeze_file(STEP, frozen_step, 2_000, 2_000_000):
            return fail("could not freeze STEP")
        if not freeze_file(FCSTD, frozen_fcstd, 10_000, 10_000_000):
            return fail("could not freeze FCStd")
        if not freeze_file(NC, frozen_nc, 10_000, 2_000_000):
            return fail("could not freeze NC")
        if normalized_text_sha256(frozen_step) != EXPECTED_STEP_SHA256:
            return fail("STEP changed during evaluation")
        if not validate_freecad(frozen_step, frozen_fcstd, frozen_nc, workdir):
            return fail("FreeCAD validation failed")
    return True


if __name__ == "__main__":
    try:
        result = main()
    except Exception as error:
        print("task-18 evaluator exception: " + str(error), file=sys.stderr)
        result = False
    print(True if result else False)