diff --git a/M02_MasterTemplete/M02_Hopyo_Bind.py b/M02_MasterTemplete/M02_Hopyo_Bind.py
new file mode 100644
index 000000000..abd3eeb74
--- /dev/null
+++ b/M02_MasterTemplete/M02_Hopyo_Bind.py
@@ -0,0 +1,446 @@
+"""M02 일위대가 실무자료 옵션값 읽기(PLAN 785-2 · 요구 641 · 642 · 설계 642-A 2-5 ④-3) —
+우리 기초 하나 + 엑셀 글감 → 입력값. 찾지 않고 읽음 · 지어 넣는 1 · 0 없음.
+
+길(앞이 먼저 · 두 길이 다른 값 = 엇갈림 · 앞 값 둠):
+    B1 부르는 호표 줄 규격 · 품명 괄호(`Match.spec_inputs`)
+    B6 같은 호표 다른 줄 — 레미콘 규격 「a-b-c」 → 굵은골재 · 강도 · 슬럼프 · 채움량 = 그 줄 수량 ÷ 이 줄 수량
+    B2 선택값 줄(785-1 Formula) · 글에 없는 고르기 = 「아님 · 해당 없음」(글 · 줄에 칸 이름 · 다른 고름이 없을 때)
+    B3 상수 줄(기호표 `SYMBOLS` · 기호 = 입력 이름 · 「(90˚)」 = 선회각도 · 표 칸 이름 = 기호면 그 표 줄 조건값)
+    B4 대입식 — 우리 줄 수량 식을 중간까지 펴 분자 · 분모 자리 + 단위로 짝(하나뿐일 때만)
+    B5 표 거꾸로 — 못 읽은 찾기 조건 칸 = 엑셀 품과 같은 표 줄(`fit` 검산) · 「감률」 칸 = 품 배수
+못 읽은 칸 = 비움(지역 · 자재지역 · 조종원직종 = 프로젝트) · 입력 필요(빈 줄을 낳음 · 요소 글에 듦) ·
+안 씀(그 밖) · 기본 = `master_auto.defaults` 제안(저장 아님). 엔진 몫 `quantities` = 금액 없이 품만.
+서버 단독 · 읽기만 · 짝 = `M02_Hopyo_Solve`.
+"""
+
+from __future__ import annotations
+
+import re
+from decimal import Decimal
+from typing import Any, Callable
+
+from M01_MasterData import M01_MasterData_Store as m01
+from M02_MasterTemplete import M02_Hopyo_Match as hm
+
+mf = m01.cm.mf
+mp = mf.mp
+mm = mp.mm
+import master_auto as ma  # noqa: E402 — mf 를 불러 scripts 경로가 깔린 뒤
+
+SKIP = ("지역", "자재지역", "조종원직종")
+NEG = ("아님", "해당 없음", "없음", "미적용", "사용 안 함")
+# 상수 기호 → 입력 이름(앞이 먼저 · 기호 = 입력 이름이면 바로)
+SYMBOLS = {
+    "q": ("버킷용량",),
+    "E": ("E입력",),
+    "Cm": ("싸이클입력",),
+    "L": ("운반거리", "거리"),
+    "n": ("운반회수",),
+    "T": ("실작업시간",),
+}
+_ANGLE = re.compile(r"\(\s*(\d+)\s*[˚°]\s*\)")
+_MIX = re.compile(r"(?<!\d)(\d{2})-(\d{2,3})-(\d{2,3})(?!\d)")
+MIX_NAMES = ("굵은골재최대치수", "강도", "슬럼프")
+CONC = ("레미콘", "콘크리트")
+
+
+def _num(value: Any) -> Decimal | None:
+    try:
+        return None if value in (None, "") else Decimal(str(value))
+    except ArithmeticError:
+        return None
+
+
+def plain(value: Any) -> Any:
+    """JSON 수 — Decimal → int · float(글은 그대로)."""
+    if isinstance(value, Decimal):
+        value = value.normalize()
+        return int(value) if value == value.to_integral_value() else float(value)
+    return value
+
+
+def specs_of(row: dict) -> list[dict]:
+    return mf.inputs_of(row) if isinstance(row.get("흐름"), dict) else row.get("입력", [])
+
+
+def _pick(spec: dict, value: Any) -> Any:
+    """고르기 칸이면 같은 수 · 같은 글의 고름(「080」 = 80) · 없으면 None · 고르기 아니면 수."""
+    picks = spec.get("고르기")
+    if not picks:
+        return _num(value)
+    hit = next((o for o in picks if str(o) == str(value)), None)
+    n = _num(value)
+    if hit is None and n is not None:
+        hit = next((o for o in picks if _num(o) == n), None)
+    return hit
+
+
+# ── 엔진 몫(품만) ─────────────────────────────────────────────────────
+def _env(master: mf.Master, row: dict, given: dict) -> dict:
+    """입력 검사(고르기 · 범위 · 기계 키) — 빈 칸은 자리값으로 검사만 하고 None 으로 되돌림."""
+    holes = {}
+    for spec in specs_of(row):
+        if given.get(spec["이름"]) is None:
+            span = spec.get("범위")
+            holes[spec["이름"]] = (spec.get("고르기") or [None])[0] or (span[0] if span else 0)
+    env = mf._inputs(row, {**{s["이름"]: None for s in specs_of(row)}, **given, **holes}, master)
+    return {**env, **dict.fromkeys(holes)}
+
+
+def _rate(extra: dict, env: dict, master: mf.Master) -> Decimal | None:
+    """덧줄 율 — 식 꼴 「(기준) × 율 / 100」 의 율 ÷ 100 · 다른 꼴 = None."""
+    node = mf.parse(extra["식"])
+    if node[0] == "bin" and node[1] == "/" and node[3] == ("num", Decimal(100)):
+        left = node[2]
+        if left[0] == "bin" and left[1] == "*":
+            return mf.evaluate(left[3], env, master) / 100
+    return None
+
+
+def quantities(master: mf.Master, key: str, given: dict) -> list[dict]:
+    """로직 줄마다 품 `{이름, 종류, 단위, 요소, 품, 까닭?}` + 덧줄 율(종류 「율」) — 금액 안 셈 ·
+    빈 칸을 쓰는 줄만 품 None + 까닭(`mf.run` 과 같은 길)."""
+    row = master.logic(key)
+    if isinstance(row.get("흐름"), dict):  # 흐름 로직 — 엔진 한 번(빈 칸 = 자리값 없음 → 못 셈)
+        try:
+            got = mf.run(master, key, given)
+        except mf.FormulaError as e:
+            return [{"이름": "", "종류": "", "단위": "", "품": None, "까닭": str(e)}]
+        return [{**x, "종류": "", "품": x.get("수량")} for x in got.get("줄", [])]
+    env = _env(master, row, given)
+    for step in row.get("중간", []):
+        try:
+            env[step["이름"]] = mf.evaluate(mf.parse(step["식"]), env, master)
+        except mf.EmptyInput as e:
+            env[step["이름"]] = mf.Blank(str(e))
+    out = []
+    for item in row.get("호표", []):
+        one = {k: item.get(k) for k in ("이름", "종류", "단위", "요소", "비목")}
+        try:
+            one["품"] = mf.evaluate(mf.parse(item["수량"]), env, master)
+        except mf.EmptyInput as e:
+            one |= {"품": None, "까닭": str(e)}
+        out.append(one)
+    for extra in row.get("덧줄", []):
+        one = {"이름": extra["이름"], "종류": "율", "단위": "%", "비목": extra.get("비목")}
+        try:
+            one["품"] = _rate(extra, env, master)
+        except mf.EmptyInput as e:
+            one |= {"품": None, "까닭": str(e)}
+        out.append(one)
+    return out
+
+
+# ── 식 풀기 ───────────────────────────────────────────────────────────
+def _names(node) -> set:
+    return {p[1] for p in mf.walk(node) if p[0] == "name"}
+
+
+def _mids(row: dict) -> dict:
+    return {s["이름"]: mf.parse(s["식"]) for s in row.get("중간", [])}
+
+
+def deps(row: dict, text: str) -> set:
+    """식이 기대는 입력 이름 — 중간을 거쳐 폄(만약 갈래 모두 · 넉넉히)."""
+    mids, seen, todo = _mids(row), set(), _names(mf.parse(text))
+    while todo:
+        name = todo.pop()
+        if name in seen:
+            continue
+        seen.add(name)
+        if name in mids:
+            todo |= _names(mids[name])
+    return seen
+
+
+def _place(node, side: str, mids: dict, out: dict, depth: int = 0) -> None:
+    """이름마다 분자 · 분모 자리 — 「/」 오른쪽이 뒤집힘 · 만약은 두 갈래만 · 찾기 · 함수 안은 안 봄."""
+    kind = node[0]
+    if kind == "name":
+        if node[1] in mids and depth < 20:
+            _place(mids[node[1]], side, mids, out, depth + 1)
+        else:
+            out.setdefault(node[1], set()).add(side)
+    elif kind == "bin" and node[1] in ("*", "/", "+", "-"):
+        _place(node[2], side, mids, out, depth)
+        flip = {"분자": "분모", "분모": "분자"}[side] if node[1] == "/" else side
+        _place(node[3], flip, mids, out, depth)
+    elif kind == "call" and node[1] == "만약":
+        for arm in node[2][1:]:
+            _place(arm, side, mids, out, depth)
+
+
+def _element_names(row: dict, element: Any) -> set:
+    """요소가 기대는 입력 — 글 = 식 · 묶음 = 「{이름}」 구멍."""
+    if isinstance(element, str):
+        return deps(row, element)
+    if isinstance(element, dict):
+        return {n for v in element.values() for n in re.findall(r"\{([^{}]+)\}", str(v))}
+    return set()
+
+
+def places(row: dict) -> dict:
+    """입력 이름 → {분자 | 분모} — 호표 줄 수량 식에서."""
+    out: dict = {}
+    mids = _mids(row)
+    for item in row.get("호표", []):
+        _place(mf.parse(item["수량"]), "분자", mids, out)
+    return out
+
+
+def finds(master: mf.Master, row: dict, depth: int = 0) -> dict:
+    """찾기 조건 칸으로 쓰인 입력 → [(표, 조건)] — 「로직(키, 칸=이름)」 한 겹 안도 이름을 옮겨 봄."""
+    out = {k: list(v) for k, v in ma._uses(row)[0].items()}
+    if depth > 1:
+        return out
+    for text in ma._texts(row):
+        for part in mf.walk(mf.parse(text)):
+            if part[0] != "logic" or not isinstance(part[1], str) or "{" in part[1]:
+                continue
+            try:
+                inner = finds(master, master.logic(part[1]), depth + 1)
+            except mf.FormulaError:
+                continue
+            passed = {k: v[1] for k, v in part[2] if v[0] == "name"}
+            for name, uses in inner.items():
+                if name in passed:
+                    out.setdefault(passed[name], []).extend(uses)
+    return out
+
+
+# ── 읽기 ─────────────────────────────────────────────────────────────
+class _Got:
+    """읽은 값 · 출처 · 엇갈림."""
+
+    def __init__(self, specs: list[dict]) -> None:
+        self.specs = {s["이름"]: s for s in specs}
+        self.value: dict = {}
+        self.where: dict = {}
+        self.clash: dict = {}
+
+    def put(self, name: str, value: Any, how: str, at: Any = None, text: Any = "") -> None:
+        spec = self.specs.get(name)
+        value = _pick(spec, value) if spec else None
+        if value is None or name in SKIP:
+            return
+        mine = {"값": plain(value), "길": how, "행": at}
+        if name not in self.value:
+            self.value[name], self.where[name] = value, {"길": how, "행": at, "글": str(text)[:120]}
+        elif self.value[name] != value:
+            first = {
+                "값": plain(self.value[name]),
+                **{k: self.where[name][k] for k in ("길", "행")},
+            }
+            self.clash.setdefault(name, [first])
+            if mine not in self.clash[name]:
+                self.clash[name].append(mine)
+
+
+def _b1(got: _Got, line: dict | None, how: str = "B1") -> None:
+    if not line:
+        return
+    values, _ = hm.spec_inputs(line, list(got.specs.values()))
+    text = f"{line.get('이름') or ''} {line.get('규격') or ''}".strip()
+    for name, value in values.items():
+        got.put(name, value, how, line.get("행"), text)
+
+
+def _b6(got: _Got, line: dict | None, same: list[dict]) -> None:
+    for other in same or []:
+        text = f"{other.get('이름') or ''} {other.get('규격') or ''}"
+        mix = _MIX.search(text)
+        if not mix or not any(w in text for w in CONC):
+            continue
+        for name, value in zip(MIX_NAMES, mix.groups(), strict=True):
+            got.put(name, value, "B6", other.get("행"), text)
+        have, mine = _num(other.get("수량")), _num((line or {}).get("수량"))
+        for name, spec in got.specs.items():
+            unit = mm.plain_unit(spec.get("단위"))
+            fill = "콘크리트" in name and unit.count("/") == 1 and have and mine
+            if fill and unit.split("/") == [
+                mm.plain_unit(other.get("단위")),
+                mm.plain_unit(line.get("단위")),
+            ]:
+                got.put(
+                    name, (have / mine).quantize(Decimal("0.0001")), "B6", other.get("행"), text
+                )
+
+
+def _b2(got: _Got, picks: list[dict], text: str, keys: dict) -> None:
+    """선택값 줄 · 글에 없는 켜기 칸 = 아님(표 줄을 고르는 찾기 조건 칸은 B5 몫 · 뺌)."""
+    for one in picks or []:
+        _b1(got, {"이름": "", "규격": one.get("글"), "행": one.get("행")}, "B2")
+    flat = mm.plain_spec(text)
+    for name, spec in got.specs.items():
+        opts = spec.get("고르기") or []
+        neg = next((o for o in opts if str(o) in NEG), None)
+        if neg is None or name in got.value or name in keys:
+            continue
+        words = [name, *(hm._PAREN.sub("", str(o)) for o in opts if o != neg)]
+        if not any(len(w) > 2 and mm.plain_spec(w) in flat for w in words):
+            got.put(name, neg, "B2", None, f"글에 「{name}」 없음")
+
+
+def _b3(got: _Got, consts: list[dict], master: mf.Master, uses: dict) -> None:
+    for c in consts or []:
+        sym, value, at, text = str(c.get("기호") or ""), c.get("값"), c.get("행"), c.get("글") or ""
+        angle = _ANGLE.search(f"({c.get('덧') or ''}) {c.get('단위') or ''} {text}")
+        if angle:
+            got.put("선회각도", angle.group(1), "B3", at, text)
+        names = [n for n in (c.get("이름"), sym, *SYMBOLS.get(sym, ())) if n and n in got.specs]
+        if names:
+            got.put(names[0], value, "B3", at, f"{sym} = {plain(_num(value))}")
+            continue
+        for name, refs in uses.items():  # 표 칸 이름 = 기호 → 그 줄 조건값(K = 0.55 → 버킷조건)
+            if name in got.value or name not in got.specs:
+                continue
+            for ref, cond in refs:
+                rows = [r for r in master.get(ref).get("줄", []) if _num(r.get(sym)) == _num(value)]
+                conds = {r.get(cond) for r in rows}
+                if len(conds) == 1 and None not in conds:
+                    got.put(name, conds.pop(), "B5", at, f"{sym} = {plain(_num(value))} → {ref}")
+
+
+def _b4(got: _Got, forms: list[dict], row: dict) -> None:
+    where = places(row)
+    for form in forms or []:
+        for side in ("분자", "분모"):
+            for term in form.get(side) or []:
+                unit = mm.plain_unit(str(term.get("단위") or "").split("/")[0])
+                hits = [
+                    n
+                    for n, s in got.specs.items()
+                    if side in where.get(n, ()) and unit and mm.plain_unit(s.get("단위")) == unit
+                ]
+                value = term.get("수", term.get("값"))
+                if term.get("기호") is not None:
+                    value = (form.get("대입") or {}).get(term["기호"])
+                if len(hits) == 1 and _num(value) is not None:
+                    got.put(hits[0], value, "B4", form.get("행"), form.get("글"))
+
+
+def _ok(fit: Callable, given: dict) -> dict:
+    try:
+        return fit(given) or {}
+    except mf.FormulaError:
+        return {}
+
+
+def _b5(got: _Got, master: mf.Master, row: dict, uses: dict, fit: Callable, need: set) -> None:
+    """못 읽은 찾기 조건 칸 — 표 줄마다 품 검산 · 줄이 갈리면 그 값(같은 값 여럿 = 엇갈림)."""
+    rate = [n for n in need if n.endswith("감률") and n not in got.value]
+    zero = dict.fromkeys(rate, Decimal(0))
+    tables: dict = {}
+    for name in sorted(need):
+        for ref, cond in uses.get(name, []):
+            if name not in got.value and got.specs.get(name, {}).get("고르기"):
+                tables.setdefault(ref, []).append((name, cond))
+    for ref, conds in tables.items():
+        rows, combos = master.get(ref).get("줄", []), []
+        bound = {
+            c: got.value[n]
+            for n, refs in uses.items()
+            if n in got.value
+            for r, c in refs
+            if r == ref
+        }
+        for r in rows:
+            if all(r.get(c) is None or str(r.get(c)) == str(v) for c, v in bound.items()):
+                combo = {n: r.get(c) for n, c in conds}
+                combos += [combo] if combo not in combos else []
+        exact, scaled = [], []
+        for combo in combos:
+            fill = {n: v if v is not None else got.specs[n]["고르기"][0] for n, v in combo.items()}
+            res = _ok(fit, {**got.value, **zero, **fill})
+            if res.get("맞음"):
+                exact.append(combo)
+            elif rate and (res.get("배") or 0) > 1:
+                scaled.append(combo)
+        live = exact or scaled  # 그대로 같은 줄이 감률 배 줄보다 먼저
+        if not live or (len(live) == len(combos) > 1):
+            continue
+        for name, _ in conds:
+            seen = {str(c[name]) for c in live if c[name] is not None}
+            for v in [str(o) for o in got.specs[name]["고르기"] if str(o) in seen]:
+                got.put(name, v, "B5", None, f"{ref} 줄 = 엑셀 품")
+    if rate:  # 감률 = 엑셀 품 ÷ 우리 품(감률 0)이 모든 노무 · 기계 줄에서 같은 배
+        res = _ok(fit, {**got.value, **zero})
+        k = res.get("배")
+        if k and k > 1:
+            cut = (Decimal(1) - Decimal(1) / Decimal(str(k))) * 100
+            cut = (
+                cut.quantize(Decimal("1"))
+                if abs(cut - cut.quantize(Decimal("1"))) < Decimal("0.5")
+                else cut
+            )
+            if _ok(fit, {**got.value, rate[0]: cut}).get("맞음"):
+                got.put(
+                    rate[0],
+                    cut,
+                    "B5",
+                    None,
+                    f"품 × {plain(Decimal(str(k)).quantize(Decimal('0.01')))}",
+                )
+
+
+def bind(master: mf.Master, key: str, src: dict, fit: Callable | None = None) -> dict:
+    """옵션값 읽기 → `{입력값, 출처, 엇갈림, 안씀, 입력필요, 비움, 기본}` — 설계 642-A 2-5 ④-3."""
+    row = master.logic(key)
+    specs = specs_of(row)
+    got = _Got(specs)
+    line, block = src.get("줄"), src.get("블록") or {}
+    _b1(got, line)
+    if not line and block:
+        _b1(got, {"이름": block.get("이름"), "규격": "", "행": (block.get("행") or [None])[0]})
+    _b6(got, line, src.get("같은줄") or [])
+    uses = finds(master, row) if not isinstance(row.get("흐름"), dict) else {}
+    _b3(got, src.get("상수") or [], master, uses)
+    if not isinstance(row.get("흐름"), dict):
+        _b4(got, src.get("식") or src.get("대입식") or [], row)
+    whole = " ".join(
+        [
+            *(block.get("글") or []),
+            str((line or {}).get("이름") or ""),
+            str((line or {}).get("규격") or ""),
+        ]
+    )
+    direct = {} if isinstance(row.get("흐름"), dict) else ma._uses(row)[0]
+    _b2(got, src.get("선택값") or [], whole, direct)
+    if fit:
+        _b5(got, master, row, uses, fit, _needed(master, key, row, got.value))
+    need = _needed(master, key, row, got.value)
+    base = ma.defaults(master, row)
+    unread = [s["이름"] for s in specs if s["이름"] not in got.value]
+    skip = [n for n in unread if n in SKIP]
+    want = [n for n in unread if n in need and n not in SKIP and n not in got.clash]
+    unused = [n for n in unread if n not in skip and n not in want and n not in got.clash]
+    return {
+        "입력값": {k: plain(v) for k, v in got.value.items() if k not in got.clash},
+        "출처": {k: v for k, v in got.where.items() if k not in got.clash},
+        "엇갈림": got.clash,
+        "안씀": unused,
+        "입력필요": want,
+        "비움": skip,
+        "기본": {n: plain(base.get(n)) for n in [*want, *unused, *got.clash]},
+    }
+
+
+def _needed(master: mf.Master, key: str, row: dict, have: dict) -> set:
+    """못 읽은 칸 중 쓰이는 것 — 빈 품 줄이 기대는 칸(기본값으로 0 이 되는 줄 = 꺼진 줄 · 뺌) +
+    품 있는 줄의 요소 글에 든 칸(기계 · 지역 등 단가 몫)."""
+    if isinstance(row.get("흐름"), dict):
+        return {s["이름"] for s in specs_of(row)} - set(have)
+    lines = quantities(master, key, have)
+    base = {k: v for k, v in ma.defaults(master, row).items() if v is not None and k not in have}
+    probe = (
+        quantities(master, key, {**base, **have}) if any(x["품"] is None for x in lines) else lines
+    )
+    items = [*row.get("호표", []), *({"수량": x["식"]} for x in row.get("덧줄", []))]
+    need: set = set()
+    for item, now, then in zip(items, lines, probe, strict=True):
+        if now.get("까닭") and then["품"] != 0:
+            need |= deps(row, item["수량"])
+        elif now["품"] not in (None, 0):
+            need |= _element_names(row, item.get("요소"))
+    # ponytail: 0 이 되는 줄 = 꺼진 줄로 봄(기본값 하나로 판정) — 값마다 다른 줄이 나오면 칸마다 검산으로
+    return need - set(have)
diff --git a/M02_MasterTemplete/M02_Hopyo_Solve.py b/M02_MasterTemplete/M02_Hopyo_Solve.py
new file mode 100644
index 000000000..6ee2a525e
--- /dev/null
+++ b/M02_MasterTemplete/M02_Hopyo_Solve.py
@@ -0,0 +1,251 @@
+"""M02 일위대가 실무자료 블록 풀이 검산 · 판정(PLAN 785-2 · 요구 642 · 설계 642-A 2-5 ④-4 · ④-5) —
+후보 기초마다 옵션값 읽기(`M02_Hopyo_Bind`) → 엔진 한 번(품 · 금액 참고) → 엑셀 단위 줄과 짝 · 판정.
+
+짝(같은 묶음끼리): L 노무 = 직종 이름 · X 기계 = 시간 단위 로직 줄 · M 자재 = 뜻 낱말(남은 하나끼리) ·
+R 율 = 덧줄 율(같은 율 › 남은 하나끼리) · E 값 · S 하위 = 엑셀만.
+품 같음(`same`) = 엑셀 자릿수 반올림 폭 안(0.67 ↔ 0.6667) 또는 0.5 % · 금액은 참고(노임 · 단가 해가 다름).
+줄 판정 = 품 같음 · 품 다름 · 입력 필요 · 엑셀만 · 우리만(우리 줄 품 0 = 꺼진 줄 · 안 보임).
+절 판정 = 기초 풂(품 다름 없는 후보 하나) · 후보 여럿 · 기초 없음 /
+블록 판정 = 기초로 풂 · 기초+덧(엑셀만 줄 → `Units` 잇기) · 줄 조합(기초 없음뿐) · 고를 것 n.
+서버 단독 · 읽기만 · 자동 고름 없음(제안 · 사용자 확인).
+"""
+
+from __future__ import annotations
+
+from decimal import Decimal
+from statistics import median
+from typing import Any, Callable
+
+from M02_MasterTemplete import M02_Hopyo_Bind as hb
+from M02_MasterTemplete import M02_Hopyo_Match as hm
+
+mf, mm, ma = hb.mf, hb.mm, hb.ma
+SAME, DIFF, NEED, EXCEL, OURS = "품 같음", "품 다름", "입력 필요", "엑셀만", "우리만"
+SOLVED, SOME, NONE = "기초 풂", "후보 여럿", "기초 없음"
+BY_BASE, BASE_PLUS, BY_LINES, PICK = "기초로 풂", "기초+덧", "줄 조합", "고를 것"
+SHARE = Decimal("0.005")
+HOURS = {"시간", "hr", "h", "시"}
+
+
+def _d(value: Any) -> Decimal | None:
+    try:
+        return None if value is None else Decimal(str(round(float(value), 10)))
+    except (ArithmeticError, TypeError, ValueError):
+        return None
+
+
+def same(excel: Any, ours: Any) -> bool:
+    """품 같음 — 엑셀 적힌 자릿수의 반올림 폭 안 또는 0.5 % 안."""
+    e, o = _d(excel), _d(ours)
+    if e is None or o is None:
+        return False
+    gap = abs(e - o)
+    places = -e.normalize().as_tuple().exponent
+    width = Decimal(5) * Decimal(10) ** -(places + 1) if 0 <= places <= 4 else Decimal(0)
+    return gap <= width or gap <= abs(e) * SHARE
+
+
+def _kind(line: dict) -> str | None:
+    kind = line.get("종류")
+    if kind in ("로직", "기계"):
+        return "X" if str(line.get("단위") or "").strip() in HOURS else "S"
+    return {"인력": "L", "재료": "M", "율": "R"}.get(kind)
+
+
+def _strict(item: dict, line: dict) -> bool:
+    kind = item.get("묶음")
+    if kind == "L":
+        return hm.tidy(line.get("이름")) == hm.tidy(item.get("직종") or item.get("이름"))
+    if kind == "M":
+        return hm.near(hm.words(item.get("이름")), hm.words(line.get("이름")))
+    if kind == "R":
+        return same(item.get("품"), line.get("품"))
+    return kind == "X"
+
+
+def _excel(item: dict, share: Decimal) -> dict:
+    q = _d(item.get("품"))
+    return {
+        "묶음": item.get("묶음"),
+        "이름": item.get("이름"),
+        "품": hb.plain(q / share if q is not None and item.get("묶음") != "R" else q),
+        "행": item.get("행"),
+        **({"별도": True} if item.get("어떻게") == "별도" else {}),
+    }
+
+
+def _row(item: dict | None, line: dict | None, share: Decimal) -> dict:
+    ex = _excel(item, share) if item else None
+    us = {k: hb.plain(line.get(k)) for k in ("이름", "종류", "단위", "품")} if line else None
+    if line and line.get("까닭"):
+        us["까닭"] = line["까닭"]
+    if ex is None:
+        verdict = NEED if line.get("까닭") else OURS
+    elif us is None:
+        verdict = EXCEL
+    elif us["품"] is None:
+        verdict = NEED if line.get("까닭") else DIFF
+    else:
+        verdict = SAME if same(ex["품"], us["품"]) else DIFF
+    out = {"엑셀": ex, "우리": us, "판정": verdict}
+    names = f"{(ex or {}).get('이름') or ''}|{(us or {}).get('이름') or ''}"
+    if item and line and item.get("묶음") == "X" and "타이어" in names and "무한궤도" in names:
+        out["표지"] = "기계 갈래 엇갈림"
+    return out
+
+
+def pair(lines: list[dict], items: list[dict], share: Any = 1) -> list[dict]:
+    """엑셀 단위 줄 ↔ 우리 줄 짝 → 줄 판정(엑셀 차례 · 남은 우리 줄 뒤)."""
+    share = _d(share) or Decimal(1)
+    used: set = set()
+    got: dict = {}
+    late = []
+    for i, item in enumerate(items):
+        pool = [j for j, ln in enumerate(lines) if j not in used and _kind(ln) == item.get("묶음")]
+        hits = [j for j in pool if _strict(item, lines[j])]
+        exact = [j for j in hits if lines[j].get("이름") == (item.get("직종") or item.get("이름"))]
+        if hits:
+            got[i] = (exact or hits)[0]
+            used.add(got[i])
+        else:
+            late.append(i)
+    for i in late:  # 남은 하나끼리(결속선 ↔ 어닐링철선)
+        kind = items[i].get("묶음")
+        pool = [j for j, ln in enumerate(lines) if j not in used and _kind(ln) == kind]
+        rest = [k for k in late if items[k].get("묶음") == kind and k not in got]
+        if len(pool) == 1 and len(rest) == 1 and kind in ("M", "R"):
+            got[i] = pool[0]
+            used.add(pool[0])
+    rows = [_row(item, lines[got[i]] if i in got else None, share) for i, item in enumerate(items)]
+    for j, line in enumerate(lines):
+        if (
+            j not in used
+            and line.get("품") != 0
+            and (line.get("품") is not None or line.get("까닭"))
+        ):
+            rows.append(_row(None, line, share))
+    return rows
+
+
+def _usable(items: list[dict]) -> list[dict]:
+    return [x for x in items if not x.get("밖")]
+
+
+def fitter(master: mf.Master, key: str, items: list[dict], share: Any = 1) -> Callable:
+    """입력값 → `{맞음, 배}` — 맞음 = 짝 하나 이상 · 모두 품 같음 / 배 = 노무 · 기계 줄이 모두 같은 배
+    (자재 · 율 줄은 같음) — 표 거꾸로 · 감률 읽기(B5)가 씀."""
+    items = _usable(items)
+
+    def fit(given: dict) -> dict:
+        rows = pair(hb.quantities(master, key, given), items, share)
+        both = [r for r in rows if r["엑셀"] and r["우리"] and r["엑셀"]["품"] and r["우리"]["품"]]
+        ok = bool(both) and all(r["판정"] == SAME for r in both)
+        labor = [r for r in both if r["엑셀"]["묶음"] in ("L", "X")]
+        k = None
+        if labor:
+            k = median(_d(r["엑셀"]["품"]) / _d(r["우리"]["품"]) for r in labor)
+            flat = all(same(r["엑셀"]["품"], _d(r["우리"]["품"]) * k) for r in labor)
+            rest = all(r["판정"] == SAME for r in both if r not in labor)
+            k = float(k) if flat and rest else None
+        return {"맞음": ok, "배": k}
+
+    return fit
+
+
+def _money(master: mf.Master, key: str, bound: dict, given: dict) -> dict:
+    """금액 참고 — 입력 필요가 없을 때 엔진 한 번(안 씀 · 비움 = 기본 제안 · 저장 안 함)."""
+    if bound["입력필요"]:
+        return {"계": None, "까닭": f"입력 필요 {len(bound['입력필요'])}"}
+    row = master.logic(key)
+    base = ma.defaults(master, row)
+    fill = {n: base.get(n) for n in [*bound["안씀"], *bound["비움"]]}
+    try:
+        got = mf.run(master, key, mf.fill_empty(row, {**fill, **given}))
+    except mf.FormulaError as e:
+        return {"계": None, "까닭": str(e)}
+    if "결과" in got:
+        return {"결과": hb.plain(got["결과"])}
+    return {k: hb.plain(got.get(k)) for k in ("노무비", "재료비", "경비", "계")}
+
+
+def candidate(master: mf.Master, key: str, src: dict, items: list[dict], share: Any = 1) -> dict:
+    """후보 기초 하나 — 바인딩 · 줄 대조 · 판정 · 금액 참고."""
+    row = master.logic(key)
+    bound = hb.bind(master, key, src, fitter(master, key, items, share))
+    given = {**bound["입력값"], **{n: v[0]["값"] for n, v in bound["엇갈림"].items()}}
+    idle = {n: bound["기본"][n] for n in bound["안씀"] if bound["기본"].get(n) is not None}
+    rows = pair(hb.quantities(master, key, {**idle, **given}), _usable(items), share)
+    count = {v: sum(r["판정"] == v for r in rows) for v in (SAME, DIFF, NEED, EXCEL, OURS)}
+    if count[DIFF]:
+        verdict = DIFF
+    elif bound["입력필요"] or count[NEED] or bound["엇갈림"]:
+        verdict = NEED
+    else:
+        verdict = SAME if count[SAME] else EXCEL
+    return {
+        "키": key,
+        "이름": row.get("이름"),
+        "바인딩": bound,
+        "줄": rows,
+        "셈": count,
+        "판정": verdict,
+        "금액": _money(master, key, bound, given),
+    }
+
+
+def _section(master: mf.Master, block: dict, part: dict, src: dict) -> dict:
+    items = part.get("항목")
+    items = _usable(block.get("항목") or []) if items is None else items
+    mine = {**src, **{k: part[k] for k in ("선택값", "상수", "식", "대입식") if k in part}}
+    share = part.get("몫")
+    share = (share.get("값") if isinstance(share, dict) else share) or 1
+    cands = [candidate(master, k, mine, items, share) for k in part.get("후보") or []]
+    good = [c for c in cands if c["셈"][DIFF] == 0 and (c["셈"][SAME] or len(cands) == 1)]
+    verdict = NONE if not cands else SOLVED if len(good) == 1 else SOME
+    pick = good[0]["키"] if verdict == SOLVED else None
+    return {
+        "제목": part.get("제목", ""),
+        "판정": verdict,
+        "고름": pick,
+        "후보": cands,
+        "항목": items,
+    }
+
+
+def block(
+    master: mf.Master, blk: dict, parts: list[dict], src: dict | None = None, units: Any = None
+) -> dict:
+    """블록 풀이 — 절마다 후보 검산 · 절 판정 · 덧 줄(엑셀만 → `Units`) · 블록 판정."""
+    src = {**(src or {}), "블록": blk}
+    secs = [_section(master, blk, p, src) for p in parts]
+    extra, n = [], 0
+    for sec in secs:
+        chosen = next((c for c in sec["후보"] if c["키"] == sec["고름"]), None)
+        if sec["판정"] == SOME:
+            n += 1
+        if chosen:
+            b = chosen["바인딩"]
+            n += len(b["입력필요"]) + len(b["엇갈림"]) + chosen["셈"][DIFF]
+            alone = [r for r in chosen["줄"] if r["판정"] == EXCEL]
+            lone = [x for x in sec["항목"] if any(r["엑셀"]["행"] == x.get("행") for r in alone)]
+        else:
+            lone = sec["항목"] if sec["판정"] == NONE else []
+        for item in lone:
+            if units is None:
+                from M02_MasterTemplete import M02_Hopyo_Units as hu
+
+                units = hu.Units()
+            link = units.line(item)
+            extra.append(
+                {"절": sec["제목"], "행": item.get("행"), "이름": item.get("이름"), **link}
+            )
+            n += link.get("상태") != "이어짐"
+    for sec in secs:
+        sec.pop("항목")
+    if secs and all(s["판정"] == NONE for s in secs):
+        verdict = BY_LINES
+    elif n:
+        verdict = PICK
+    else:
+        verdict = BASE_PLUS if extra else BY_BASE
+    return {"번": blk.get("번"), "판정": verdict, "고를수": n, "절": secs, "덧": extra}
diff --git a/resources/master_data/scripts/master_auto.py b/resources/master_data/scripts/master_auto.py
index f9940947e..a4499faaa 100644
--- a/resources/master_data/scripts/master_auto.py
+++ b/resources/master_data/scripts/master_auto.py
@@ -88,6 +88,49 @@ def _lowest(master: mf.Master, uses: list):
     return (both or next((s for s in sets if s), [None]))[0]
 
 
+def _first_row(master: mf.Master, uses: list):
+    """찾기 조건 칸의 표 첫 줄 값 — 범위 줄이면 아래 끝(열린 아래 끝 = 위 끝) · 빈 칸 줄은 건넘."""
+    for ref, cond in uses:
+        try:
+            rows = master.get(ref).get("줄", [])
+        except mf.FormulaError:
+            continue
+        for r in rows:
+            got = r.get(cond)
+            if isinstance(got, list):
+                got = next((v for v in got if v is not None), None)
+            if got is not None:
+                return got
+    return None
+
+
+def _holds_zero(span) -> bool:
+    low, high = span[0], span[1]
+    return (low is None or Decimal(str(low)) <= 0) and (high is None or Decimal(str(high)) >= 0)
+
+
+def defaults(master: mf.Master, row: dict) -> dict:
+    """「기본」 제안(PLAN 785-2 · 639-1a) — 「기본」 칸 › 고르기 첫째 › 가드 0 › 0 을 품은 범위 0 ›
+    찾기 조건 표 첫 줄 › None(못 정함 = 사용자 입력). 1 을 지어 넣지 않음 · `values` 와 따로."""
+    specs = mf.inputs_of(row) if isinstance(row.get("흐름"), dict) else row.get("입력", [])
+    finds = {} if isinstance(row.get("흐름"), dict) else _uses(row)[0]
+    guard = guards(row)
+    out = {}
+    for spec in specs:
+        name, span = spec["이름"], spec.get("범위")
+        if spec.get("기본") not in (None, ""):
+            out[name] = spec["기본"]
+        elif spec.get("고르기"):
+            out[name] = spec["고르기"][0]
+        elif name in guard:
+            out[name] = Decimal(0)
+        elif span and _holds_zero(span):
+            out[name] = Decimal(0)
+        else:
+            out[name] = _first_row(master, finds.get(name, []))
+    return out
+
+
 def values(master: mf.Master, row: dict) -> dict:
     """로직 줄 하나의 입력마다 자동값 · 흐름 로직은 「설계 때 정할 것」 예시값."""
     if isinstance(row.get("흐름"), dict):