def solution(n: int) -> str:
    """Return the n=70 Ramsey book-graph construction in column-major order."""
    if n != 70:
        raise ValueError("This construction is defined only for n = 70")

    q = 139
    block_size = 69
    vertex_count = 278

    def quadratic_character(x: int) -> int:
        x %= q
        if x == 0:
            return 0
        return 1 if pow(x, (q - 1) // 2, q) == 1 else -1

    a = [0] * block_size
    b = [0] * block_size
    power = 1
    for t in range(block_size):
        a[t] = 1 if t == 0 else quadratic_character(power - 1)
        b[t] = -quadratic_character(power + 1)
        power = power * 4 % q

    seidel = [[0] * vertex_count for _ in range(vertex_count)]

    def put(row: int, column: int, value: int) -> None:
        seidel[row][column] = value
        seidel[column][row] = value

    # The two exceptional vertices u and v.
    put(0, 1, -1)
    signs_from_u = (1, 1, -1, -1)
    signs_from_v = (-1, 1, 1, -1)
    for group in range(4):
        start = 2 + group * block_size
        for local in range(block_size):
            put(0, start + local, signs_from_u[group])
            put(1, start + local, signs_from_v[group])

    # Blocks are ordered A0, A1, B0, B1.  X[r,s] = a[s-r]
    # and Y[r,s] = b[s-r], with all subscripts taken modulo 69.
    def x(row: int, column: int) -> int:
        return a[(column - row) % block_size]

    def y(row: int, column: int) -> int:
        return b[(column - row) % block_size]

    def fill_block(
        row_group: int,
        column_group: int,
        entry,
        multiplier: int = 1,
    ) -> None:
        row_start = 2 + row_group * block_size
        column_start = 2 + column_group * block_size
        for row in range(block_size):
            for column in range(block_size):
                if row_group == column_group and row == column:
                    continue
                seidel[row_start + row][column_start + column] = (
                    multiplier * entry(row, column)
                )

    # Diagonal blocks (the omitted +/-I terms only zero their diagonals).
    fill_block(0, 0, y)
    fill_block(1, 1, y, -1)
    fill_block(2, 2, y)
    fill_block(3, 3, y, -1)

    # Strictly upper block triangle; mirror it to preserve exact symmetry.
    upper_blocks = (
        (0, 1, y, -1),
        (0, 2, x, -1),
        (0, 3, x, 1),
        (1, 2, x, -1),
        (1, 3, x, -1),
        (2, 3, y, 1),
    )
    for row_group, column_group, entry, multiplier in upper_blocks:
        row_start = 2 + row_group * block_size
        column_start = 2 + column_group * block_size
        for row in range(block_size):
            for column in range(block_size):
                value = multiplier * entry(row, column)
                seidel[row_start + row][column_start + column] = value
                seidel[column_start + column][row_start + row] = value

    return "".join(
        "1" if seidel[row][column] == 1 else "0"
        for column in range(1, vertex_count)
        for row in range(column)
    )