diff options
Diffstat (limited to 'tools/terrain_map_preview_renderer.py')
| -rw-r--r-- | tools/terrain_map_preview_renderer.py | 679 |
1 files changed, 679 insertions, 0 deletions
diff --git a/tools/terrain_map_preview_renderer.py b/tools/terrain_map_preview_renderer.py new file mode 100644 index 0000000..86d72d7 --- /dev/null +++ b/tools/terrain_map_preview_renderer.py @@ -0,0 +1,679 @@ +#!/usr/bin/env python3 +""" +Software 3D renderer for terrain Land.msh + Land.map overlay. + +Output format: binary PPM (P6), dependency-free. +""" + +from __future__ import annotations + +import argparse +import math +import struct +from pathlib import Path +from typing import Any + +import archive_roundtrip_validator as arv + +MAGIC_NRES = b"NRes" + + +def _entry_payload(blob: bytes, entry: dict[str, Any]) -> bytes: + start = int(entry["data_offset"]) + end = start + int(entry["size"]) + return blob[start:end] + + +def _parse_nres(blob: bytes, source: str) -> dict[str, Any]: + if blob[:4] != MAGIC_NRES: + raise RuntimeError(f"{source}: not an NRes payload") + return arv.parse_nres(blob, source=source) + + +def _by_type(entries: list[dict[str, Any]]) -> dict[int, list[dict[str, Any]]]: + out: dict[int, list[dict[str, Any]]] = {} + for row in entries: + out.setdefault(int(row["type_id"]), []).append(row) + return out + + +def _get_single(by_type: dict[int, list[dict[str, Any]]], type_id: int, label: str) -> dict[str, Any]: + rows = by_type.get(type_id, []) + if not rows: + raise RuntimeError(f"missing resource type {type_id} ({label})") + return rows[0] + + +def _downsample_faces( + faces: list[tuple[int, int, int]], + max_faces: int, +) -> list[tuple[int, int, int]]: + if max_faces <= 0 or len(faces) <= max_faces: + return faces + step = len(faces) / max_faces + out: list[tuple[int, int, int]] = [] + pos = 0.0 + while len(out) < max_faces and int(pos) < len(faces): + out.append(faces[int(pos)]) + pos += step + return out + + +def load_terrain_msh( + path: Path, + *, + max_faces: int, +) -> tuple[list[tuple[float, float, float]], list[tuple[int, int, int]], dict[str, int]]: + blob = path.read_bytes() + parsed = _parse_nres(blob, str(path)) + by_type = _by_type(parsed["entries"]) + + res3 = _get_single(by_type, 3, "positions") + res21 = _get_single(by_type, 21, "terrain faces") + + pos_blob = _entry_payload(blob, res3) + if len(pos_blob) % 12 != 0: + raise RuntimeError(f"{path}: type 3 payload size is not divisible by 12") + vertex_count = len(pos_blob) // 12 + positions = [struct.unpack_from("<3f", pos_blob, i * 12) for i in range(vertex_count)] + + face_blob = _entry_payload(blob, res21) + if len(face_blob) % 28 != 0: + raise RuntimeError(f"{path}: type 21 payload size is not divisible by 28") + all_faces: list[tuple[int, int, int]] = [] + raw_face_count = len(face_blob) // 28 + dropped = 0 + for i in range(raw_face_count): + off = i * 28 + i0, i1, i2 = struct.unpack_from("<HHH", face_blob, off + 8) + if i0 >= vertex_count or i1 >= vertex_count or i2 >= vertex_count: + dropped += 1 + continue + all_faces.append((i0, i1, i2)) + + faces = _downsample_faces(all_faces, max_faces) + meta = { + "vertex_count": vertex_count, + "face_count_raw": raw_face_count, + "face_count_valid": len(all_faces), + "face_count_rendered": len(faces), + "face_dropped_invalid": dropped, + } + return positions, faces, meta + + +def load_areal_map(path: Path) -> tuple[list[dict[str, Any]], dict[str, int]]: + blob = path.read_bytes() + parsed = _parse_nres(blob, str(path)) + by_type = _by_type(parsed["entries"]) + chunk = _get_single(by_type, 12, "ArealMapGeometry") + + payload = _entry_payload(blob, chunk) + areal_count = int(chunk["attr1"]) + ptr = 0 + areals: list[dict[str, Any]] = [] + for idx in range(areal_count): + if ptr + 56 > len(payload): + raise RuntimeError(f"{path}: truncated areal header at index={idx}") + class_id = struct.unpack_from("<I", payload, ptr + 40)[0] + vertex_count, poly_count = struct.unpack_from("<II", payload, ptr + 48) + verts_off = ptr + 56 + verts_size = 12 * vertex_count + if verts_off + verts_size > len(payload): + raise RuntimeError(f"{path}: areal[{idx}] vertices out of bounds") + verts = [struct.unpack_from("<3f", payload, verts_off + 12 * i) for i in range(vertex_count)] + + links_off = verts_off + verts_size + links_size = 8 * (vertex_count + 3 * poly_count) + p = links_off + links_size + for _ in range(poly_count): + if p + 4 > len(payload): + raise RuntimeError(f"{path}: areal[{idx}] poly header out of bounds") + n = struct.unpack_from("<I", payload, p)[0] + p += 4 * (3 * n + 1) + if p > len(payload): + raise RuntimeError(f"{path}: areal[{idx}] poly data out of bounds") + + areals.append( + { + "index": idx, + "class_id": class_id, + "vertices": verts, + } + ) + ptr = p + + if ptr + 8 > len(payload): + raise RuntimeError(f"{path}: missing cells section") + cells_x, cells_y = struct.unpack_from("<II", payload, ptr) + ptr += 8 + for _x in range(cells_x): + for _y in range(cells_y): + if ptr + 2 > len(payload): + raise RuntimeError(f"{path}: cells section truncated") + hit_count = struct.unpack_from("<H", payload, ptr)[0] + ptr += 2 + 2 * hit_count + if ptr > len(payload): + raise RuntimeError(f"{path}: cells section out of bounds") + if ptr != len(payload): + raise RuntimeError(f"{path}: trailing bytes in chunk12 parse ({len(payload) - ptr})") + + meta = { + "areal_count": areal_count, + "cells_x": cells_x, + "cells_y": cells_y, + } + return areals, meta + + +def _color_for_class(class_id: int) -> tuple[int, int, int]: + x = (class_id * 1103515245 + 12345) & 0x7FFFFFFF + r = 60 + (x & 0x7F) + g = 60 + ((x >> 7) & 0x7F) + b = 60 + ((x >> 14) & 0x7F) + return r, g, b + + +def _write_ppm(path: Path, width: int, height: int, rgb: bytearray) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + with path.open("wb") as handle: + handle.write(f"P6\n{width} {height}\n255\n".encode("ascii")) + handle.write(rgb) + + +def _write_obj( + path: Path, + terrain_positions: list[tuple[float, float, float]], + terrain_faces: list[tuple[int, int, int]], + areals: list[dict[str, Any]], + *, + include_areals: bool, +) -> None: + path.parent.mkdir(parents=True, exist_ok=True) + with path.open("w", encoding="utf-8", newline="\n") as out: + out.write("# Exported by terrain_map_preview_renderer.py\n") + out.write("o terrain\n") + for x, y, z in terrain_positions: + out.write(f"v {x:.9g} {y:.9g} {z:.9g}\n") + for i0, i1, i2 in terrain_faces: + # OBJ indices are 1-based. + out.write(f"f {i0 + 1} {i1 + 1} {i2 + 1}\n") + + if include_areals and areals: + base = len(terrain_positions) + area_vertex_counts: list[int] = [] + out.write("o areal_edges\n") + for area in areals: + verts = area["vertices"] + area_vertex_counts.append(len(verts)) + for x, y, z in verts: + out.write(f"v {x:.9g} {y:.9g} {z:.9g}\n") + + ptr = base + for area_idx, area in enumerate(areals): + cnt = area_vertex_counts[area_idx] + if cnt < 2: + ptr += cnt + continue + # closed polyline. + line = [str(ptr + i + 1) for i in range(cnt)] + line.append(str(ptr + 1)) + out.write("l " + " ".join(line) + "\n") + ptr += cnt + + +def _render_scene( + terrain_positions: list[tuple[float, float, float]], + terrain_faces: list[tuple[int, int, int]], + areals: list[dict[str, Any]], + *, + width: int, + height: int, + yaw_deg: float, + pitch_deg: float, + wireframe: bool, + areal_overlay: bool, +) -> bytearray: + all_positions = list(terrain_positions) + if areal_overlay: + for area in areals: + all_positions.extend(area["vertices"]) + if not all_positions: + raise RuntimeError("scene is empty") + + xs = [p[0] for p in all_positions] + ys = [p[1] for p in all_positions] + zs = [p[2] for p in all_positions] + cx = (min(xs) + max(xs)) * 0.5 + cy = (min(ys) + max(ys)) * 0.5 + cz = (min(zs) + max(zs)) * 0.5 + span = max(max(xs) - min(xs), max(ys) - min(ys), max(zs) - min(zs)) + radius = max(span * 0.5, 1e-3) + + yaw = math.radians(yaw_deg) + pitch = math.radians(pitch_deg) + cyaw = math.cos(yaw) + syaw = math.sin(yaw) + cpitch = math.cos(pitch) + spitch = math.sin(pitch) + camera_dist = radius * 3.2 + scale = min(width, height) * 0.96 + + # Terrain transform cache. + vx: list[float] = [] + vy: list[float] = [] + vz: list[float] = [] + sx: list[float] = [] + sy: list[float] = [] + for x, y, z in terrain_positions: + x0 = x - cx + y0 = y - cy + z0 = z - cz + x1 = cyaw * x0 + syaw * z0 + z1 = -syaw * x0 + cyaw * z0 + y2 = cpitch * y0 - spitch * z1 + z2 = spitch * y0 + cpitch * z1 + camera_dist + if z2 < 1e-3: + z2 = 1e-3 + vx.append(x1) + vy.append(y2) + vz.append(z2) + sx.append(width * 0.5 + (x1 / z2) * scale) + sy.append(height * 0.5 - (y2 / z2) * scale) + + def project_point(x: float, y: float, z: float) -> tuple[float, float, float]: + x0 = x - cx + y0 = y - cy + z0 = z - cz + x1 = cyaw * x0 + syaw * z0 + z1 = -syaw * x0 + cyaw * z0 + y2 = cpitch * y0 - spitch * z1 + z2 = spitch * y0 + cpitch * z1 + camera_dist + if z2 < 1e-3: + z2 = 1e-3 + px = width * 0.5 + (x1 / z2) * scale + py = height * 0.5 - (y2 / z2) * scale + return px, py, z2 + + rgb = bytearray([14, 16, 20] * (width * height)) + zbuf = [float("inf")] * (width * height) + light_dir = (0.35, 0.45, 1.0) + l_len = math.sqrt(light_dir[0] ** 2 + light_dir[1] ** 2 + light_dir[2] ** 2) + light = (light_dir[0] / l_len, light_dir[1] / l_len, light_dir[2] / l_len) + + def edge(ax: float, ay: float, bx: float, by: float, px: float, py: float) -> float: + return (px - ax) * (by - ay) - (py - ay) * (bx - ax) + + for i0, i1, i2 in terrain_faces: + x0 = sx[i0] + y0 = sy[i0] + x1 = sx[i1] + y1 = sy[i1] + x2 = sx[i2] + y2 = sy[i2] + area = edge(x0, y0, x1, y1, x2, y2) + if area == 0.0: + continue + + ux = vx[i1] - vx[i0] + uy = vy[i1] - vy[i0] + uz = vz[i1] - vz[i0] + wx = vx[i2] - vx[i0] + wy = vy[i2] - vy[i0] + wz = vz[i2] - vz[i0] + nx = uy * wz - uz * wy + ny = uz * wx - ux * wz + nz = ux * wy - uy * wx + n_len = math.sqrt(nx * nx + ny * ny + nz * nz) + if n_len > 0.0: + nx /= n_len + ny /= n_len + nz /= n_len + intensity = nx * light[0] + ny * light[1] + nz * light[2] + if intensity < 0.0: + intensity = 0.0 + shade = int(45 + 185 * intensity) + color = (min(255, shade + 6), min(255, shade + 14), min(255, shade + 28)) + + minx = int(max(0, math.floor(min(x0, x1, x2)))) + maxx = int(min(width - 1, math.ceil(max(x0, x1, x2)))) + miny = int(max(0, math.floor(min(y0, y1, y2)))) + maxy = int(min(height - 1, math.ceil(max(y0, y1, y2)))) + if minx > maxx or miny > maxy: + continue + + z0 = vz[i0] + z1 = vz[i1] + z2 = vz[i2] + inv_area = 1.0 / area + for py in range(miny, maxy + 1): + fy = py + 0.5 + row = py * width + for px in range(minx, maxx + 1): + fx = px + 0.5 + w0 = edge(x1, y1, x2, y2, fx, fy) + w1 = edge(x2, y2, x0, y0, fx, fy) + w2 = edge(x0, y0, x1, y1, fx, fy) + if area > 0: + if w0 < 0 or w1 < 0 or w2 < 0: + continue + else: + if w0 > 0 or w1 > 0 or w2 > 0: + continue + bz0 = w0 * inv_area + bz1 = w1 * inv_area + bz2 = w2 * inv_area + depth = bz0 * z0 + bz1 * z1 + bz2 * z2 + idx = row + px + if depth >= zbuf[idx]: + continue + zbuf[idx] = depth + p = idx * 3 + rgb[p + 0] = color[0] + rgb[p + 1] = color[1] + rgb[p + 2] = color[2] + + def draw_line( + xa: float, + ya: float, + xb: float, + yb: float, + color: tuple[int, int, int], + ) -> None: + x0i = int(round(xa)) + y0i = int(round(ya)) + x1i = int(round(xb)) + y1i = int(round(yb)) + dx = abs(x1i - x0i) + sx_step = 1 if x0i < x1i else -1 + dy = -abs(y1i - y0i) + sy_step = 1 if y0i < y1i else -1 + err = dx + dy + x = x0i + y = y0i + while True: + if 0 <= x < width and 0 <= y < height: + p = (y * width + x) * 3 + rgb[p + 0] = color[0] + rgb[p + 1] = color[1] + rgb[p + 2] = color[2] + if x == x1i and y == y1i: + break + e2 = 2 * err + if e2 >= dy: + err += dy + x += sx_step + if e2 <= dx: + err += dx + y += sy_step + + if wireframe: + wf = (225, 232, 246) + for i0, i1, i2 in terrain_faces: + draw_line(sx[i0], sy[i0], sx[i1], sy[i1], wf) + draw_line(sx[i1], sy[i1], sx[i2], sy[i2], wf) + draw_line(sx[i2], sy[i2], sx[i0], sy[i0], wf) + + if areal_overlay: + for area in areals: + verts = area["vertices"] + if len(verts) < 2: + continue + color = _color_for_class(int(area["class_id"])) + projected = [project_point(x, y, z + 0.35) for x, y, z in verts] + for i in range(len(projected)): + x0, y0, _ = projected[i] + x1, y1, _ = projected[(i + 1) % len(projected)] + draw_line(x0, y0, x1, y1, color) + + return rgb + + +def cmd_render(args: argparse.Namespace) -> int: + msh_path = Path(args.land_msh).resolve() + map_path = Path(args.land_map).resolve() if args.land_map else None + output_path = Path(args.output).resolve() + + positions, faces, terrain_meta = load_terrain_msh(msh_path, max_faces=int(args.max_faces)) + areals: list[dict[str, Any]] = [] + map_meta: dict[str, int] = {"areal_count": 0, "cells_x": 0, "cells_y": 0} + if map_path: + areals, map_meta = load_areal_map(map_path) + + rgb = _render_scene( + positions, + faces, + areals, + width=int(args.width), + height=int(args.height), + yaw_deg=float(args.yaw), + pitch_deg=float(args.pitch), + wireframe=bool(args.wireframe), + areal_overlay=bool(args.overlay_areals), + ) + _write_ppm(output_path, int(args.width), int(args.height), rgb) + + print(f"Rendered terrain : {msh_path}") + if map_path: + print(f"Areal overlay : {map_path}") + print(f"Output : {output_path}") + print( + "Terrain geometry : " + f"vertices={terrain_meta['vertex_count']}, " + f"faces={terrain_meta['face_count_rendered']}/{terrain_meta['face_count_valid']} " + f"(raw={terrain_meta['face_count_raw']}, dropped={terrain_meta['face_dropped_invalid']})" + ) + if map_path: + print( + "Areal map : " + f"areals={map_meta['areal_count']}, cells={map_meta['cells_x']}x{map_meta['cells_y']}" + ) + return 0 + + +def cmd_export_obj(args: argparse.Namespace) -> int: + msh_path = Path(args.land_msh).resolve() + map_path = Path(args.land_map).resolve() if args.land_map else None + output_path = Path(args.output).resolve() + + positions, faces, terrain_meta = load_terrain_msh(msh_path, max_faces=int(args.max_faces)) + areals: list[dict[str, Any]] = [] + if map_path and bool(args.include_areals): + areals, _ = load_areal_map(map_path) + + _write_obj( + output_path, + positions, + faces, + areals, + include_areals=bool(args.include_areals), + ) + + areal_vertices = sum(len(a["vertices"]) for a in areals) + print(f"Terrain source : {msh_path}") + if map_path: + print(f"Areal source : {map_path}") + print(f"OBJ output : {output_path}") + print( + "Terrain geometry : " + f"vertices={terrain_meta['vertex_count']}, " + f"faces={terrain_meta['face_count_rendered']}/{terrain_meta['face_count_valid']}" + ) + if bool(args.include_areals): + print(f"Areal edges : areals={len(areals)}, extra_vertices={areal_vertices}") + return 0 + + +def cmd_render_turntable(args: argparse.Namespace) -> int: + msh_path = Path(args.land_msh).resolve() + map_path = Path(args.land_map).resolve() if args.land_map else None + output_dir = Path(args.output_dir).resolve() + output_dir.mkdir(parents=True, exist_ok=True) + + frames = int(args.frames) + if frames <= 0: + raise RuntimeError("--frames must be > 0") + + positions, faces, terrain_meta = load_terrain_msh(msh_path, max_faces=int(args.max_faces)) + areals: list[dict[str, Any]] = [] + if map_path: + areals, _ = load_areal_map(map_path) + + yaw_start = float(args.yaw_start) + yaw_end = float(args.yaw_end) + if frames == 1: + yaws = [yaw_start] + else: + step = (yaw_end - yaw_start) / (frames - 1) + yaws = [yaw_start + i * step for i in range(frames)] + + prefix = str(args.prefix) + for i, yaw in enumerate(yaws): + rgb = _render_scene( + positions, + faces, + areals, + width=int(args.width), + height=int(args.height), + yaw_deg=yaw, + pitch_deg=float(args.pitch), + wireframe=bool(args.wireframe), + areal_overlay=bool(args.overlay_areals), + ) + out = output_dir / f"{prefix}_{i:03d}.ppm" + _write_ppm(out, int(args.width), int(args.height), rgb) + + print(f"Turntable source : {msh_path}") + if map_path: + print(f"Areal source : {map_path}") + print(f"Output dir : {output_dir}") + print(f"Frames : {frames} ({yaws[0]:.3f} -> {yaws[-1]:.3f} yaw)") + print( + "Terrain geometry : " + f"vertices={terrain_meta['vertex_count']}, faces={terrain_meta['face_count_rendered']}" + ) + return 0 + + +def cmd_render_batch(args: argparse.Namespace) -> int: + maps_root = Path(args.maps_root).resolve() + output_dir = Path(args.output_dir).resolve() + msh_paths = sorted(maps_root.rglob("Land.msh")) + if not msh_paths: + raise RuntimeError(f"no Land.msh files under {maps_root}") + + rendered = 0 + skipped = 0 + for msh_path in msh_paths: + map_path = msh_path.with_name("Land.map") + if not map_path.exists(): + skipped += 1 + continue + rel = msh_path.parent.relative_to(maps_root) + out = output_dir / f"{rel.as_posix().replace('/', '__')}.ppm" + cmd_render( + argparse.Namespace( + land_msh=str(msh_path), + land_map=str(map_path), + output=str(out), + max_faces=args.max_faces, + width=args.width, + height=args.height, + yaw=args.yaw, + pitch=args.pitch, + wireframe=args.wireframe, + overlay_areals=args.overlay_areals, + ) + ) + rendered += 1 + + print(f"Batch summary: rendered={rendered}, skipped_no_map={skipped}, output_dir={output_dir}") + return 0 + + +def build_parser() -> argparse.ArgumentParser: + parser = argparse.ArgumentParser( + description="Software 3D terrain renderer (Land.msh + optional Land.map overlay)." + ) + sub = parser.add_subparsers(dest="command", required=True) + + render = sub.add_parser("render", help="Render one terrain map to PPM.") + render.add_argument("--land-msh", required=True, help="Path to Land.msh") + render.add_argument("--land-map", help="Path to Land.map (optional)") + render.add_argument("--output", required=True, help="Output .ppm path") + render.add_argument("--max-faces", type=int, default=220000, help="Face limit (default: 220000)") + render.add_argument("--width", type=int, default=1280, help="Image width (default: 1280)") + render.add_argument("--height", type=int, default=720, help="Image height (default: 720)") + render.add_argument("--yaw", type=float, default=38.0, help="Yaw angle in degrees (default: 38)") + render.add_argument("--pitch", type=float, default=26.0, help="Pitch angle in degrees (default: 26)") + render.add_argument("--wireframe", action="store_true", help="Draw terrain wireframe overlay") + render.add_argument( + "--overlay-areals", + action="store_true", + help="Draw ArealMap polygon overlay", + ) + render.set_defaults(func=cmd_render) + + export_obj = sub.add_parser("export-obj", help="Export terrain (and optional areal edges) to OBJ.") + export_obj.add_argument("--land-msh", required=True, help="Path to Land.msh") + export_obj.add_argument("--land-map", help="Path to Land.map (optional)") + export_obj.add_argument("--output", required=True, help="Output .obj path") + export_obj.add_argument("--max-faces", type=int, default=0, help="Face limit (0 = all)") + export_obj.add_argument( + "--include-areals", + action="store_true", + help="Export areal polygons as OBJ polyline object", + ) + export_obj.set_defaults(func=cmd_export_obj) + + turn = sub.add_parser("render-turntable", help="Render turntable frame sequence to PPM.") + turn.add_argument("--land-msh", required=True, help="Path to Land.msh") + turn.add_argument("--land-map", help="Path to Land.map (optional)") + turn.add_argument("--output-dir", required=True, help="Output directory for frames") + turn.add_argument("--prefix", default="frame", help="Frame filename prefix (default: frame)") + turn.add_argument("--frames", type=int, default=36, help="Frame count (default: 36)") + turn.add_argument("--yaw-start", type=float, default=0.0, help="Start yaw in degrees (default: 0)") + turn.add_argument("--yaw-end", type=float, default=360.0, help="End yaw in degrees (default: 360)") + turn.add_argument("--pitch", type=float, default=26.0, help="Pitch angle in degrees (default: 26)") + turn.add_argument("--max-faces", type=int, default=160000, help="Face limit (default: 160000)") + turn.add_argument("--width", type=int, default=960, help="Image width (default: 960)") + turn.add_argument("--height", type=int, default=540, help="Image height (default: 540)") + turn.add_argument("--wireframe", action="store_true", help="Draw terrain wireframe overlay") + turn.add_argument( + "--overlay-areals", + action="store_true", + help="Draw ArealMap polygon overlay", + ) + turn.set_defaults(func=cmd_render_turntable) + + batch = sub.add_parser("render-batch", help="Render all MAPS/**/Land.msh under root.") + batch.add_argument( + "--maps-root", + default="tmp/gamedata/DATA/MAPS", + help="Root directory with MAPS subfolders (default: tmp/gamedata/DATA/MAPS)", + ) + batch.add_argument("--output-dir", required=True, help="Directory for output PPM files") + batch.add_argument("--max-faces", type=int, default=90000, help="Face limit per map (default: 90000)") + batch.add_argument("--width", type=int, default=960, help="Image width (default: 960)") + batch.add_argument("--height", type=int, default=540, help="Image height (default: 540)") + batch.add_argument("--yaw", type=float, default=38.0, help="Yaw angle in degrees (default: 38)") + batch.add_argument("--pitch", type=float, default=26.0, help="Pitch angle in degrees (default: 26)") + batch.add_argument("--wireframe", action="store_true", help="Draw terrain wireframe overlay") + batch.add_argument( + "--overlay-areals", + action="store_true", + help="Draw ArealMap polygon overlay", + ) + batch.set_defaults(func=cmd_render_batch) + + return parser + + +def main() -> int: + parser = build_parser() + args = parser.parse_args() + return int(args.func(args)) + + +if __name__ == "__main__": + raise SystemExit(main()) |