import sys
from enum import Enum, auto
from typing import Callable, cast


class Cell(Enum):
    AIR = auto()
    ROCK = auto()
    SAND = auto()

    def __str__(self) -> str:
        return {Cell.AIR: ".", Cell.ROCK: "#", Cell.SAND: "O"}[self]


def print_blocks(blocks: dict[tuple[int, int], Cell]):
    """
    Print the given set of blocks on a grid.

    Args:
        blocks: Set of blocks to print.
    """
    x_min, y_min, x_max, y_max = (
        min(x for x, _ in blocks),
        0,
        max(x for x, _ in blocks),
        max(y for _, y in blocks),
    )

    for y in range(y_min, y_max + 1):
        print(
            "".join(str(blocks.get((x, y), Cell.AIR)) for x in range(x_min, x_max + 1))
        )


def flow(
    blocks: dict[tuple[int, int], Cell],
    stop_fn: Callable[[int, int], bool],
    fill_fn: Callable[[int, int], Cell],
) -> dict[tuple[int, int], Cell]:
    """
    Flow sands onto the given set of blocks

    Args:
        blocks: Blocks containing ROCK position. Modified in-place.
        stop_fn: Function called with the last (assumed) position of a grain of
            sand BEFORE adding it to blocks. If the function returns True, the grain
            is added and a new one is flowed, otherwise, the whole procedure stops
            and the function returns (without adding the final grain).
        fill_fn: Function called when the target position of a grain (during the
            flowing process) is missing from blocks.

    Returns:
        The input blocks.
    """

    y_max = max(y for _, y in blocks)

    while True:
        x, y = 500, 0

        while y <= y_max:
            moved = False
            for cx, cy in ((x, y + 1), (x - 1, y + 1), (x + 1, y + 1)):
                if (cx, cy) not in blocks and fill_fn(cx, cy) == Cell.AIR:
                    x, y = cx, cy
                    moved = True
                elif blocks[cx, cy] == Cell.AIR:
                    x, y = cx, cy
                    moved = True

                if moved:
                    break

            if not moved:
                break

        if stop_fn(x, y):
            break

        blocks[x, y] = Cell.SAND

    return blocks


# === inputs ===

lines = sys.stdin.read().splitlines()

paths: list[list[tuple[int, int]]] = []
for line in lines:
    parts = line.split(" -> ")
    paths.append(
        [
            cast(tuple[int, int], tuple(int(c.strip()) for c in part.split(",")))
            for part in parts
        ]
    )


blocks: dict[tuple[int, int], Cell] = {}
for path in paths:
    for start, end in zip(path[:-1], path[1:]):
        x_start = min(start[0], end[0])
        x_end = max(start[0], end[0]) + 1
        y_start = min(start[1], end[1])
        y_end = max(start[1], end[1]) + 1

        for x in range(x_start, x_end):
            for y in range(y_start, y_end):
                blocks[x, y] = Cell.ROCK

print_blocks(blocks)
print()

x_min, y_min, x_max, y_max = (
    min(x for x, _ in blocks),
    0,
    max(x for x, _ in blocks),
    max(y for _, y in blocks),
)

# === part 1 ===

blocks_1 = flow(
    blocks.copy(), stop_fn=lambda x, y: y > y_max, fill_fn=lambda x, y: Cell.AIR
)
print_blocks(blocks_1)
print(f"answer 1 is {sum(v == Cell.SAND for v in blocks_1.values())}")
print()

# === part 2 ===

blocks_2 = flow(
    blocks.copy(),
    stop_fn=lambda x, y: x == 500 and y == 0,
    fill_fn=lambda x, y: Cell.AIR if y < y_max + 2 else Cell.ROCK,
)
blocks_2[500, 0] = Cell.SAND
print_blocks(blocks_2)
print(f"answer 2 is {sum(v == Cell.SAND for v in blocks_2.values())}")