<think>
Okay, I need to implement the two functions, live_count and live_next, based on the given problem statement. Let me start by understanding what each function is supposed to do.

First, live_count takes a list of neighbours and returns how many are alive. So, the function needs to count the number of True values in the neighbours list. Wait, but the problem says that each neighbour is a cell, so maybe each element in the neighbours list is a boolean indicating if the neighbor is alive. So, the live_count function is simply counting the number of True in the list. That's straightforward. So, the code for live_count would be sum(neighbours), since True is 1 and False is 0 when summed.

Next, the live_next function determines if a cell should be alive in the next round. The rules are: a living cell survives if it has 2 or 3 live neighbors. A dead cell comes alive if it has exactly 3 live neighbors. So, the function takes the current alive status of the cell and the list of neighbors. 

So, the steps for live_next are:
- If the cell is currently alive (alive is True), check if the live_count is 2 or 3. If yes, it survives; else, it dies.
- If the cell is dead (alive is False), check if the live_count is exactly 3. If yes, it comes alive; else, remains dead.

So, the function needs to first calculate the count using live_count, then apply the rules based on the current alive status.

Wait, but the live_count function is part of the interface. So, the live_next function will use the live_count function to get the number of alive neighbors. So, the code for live_next would be:

def live_next(alive: bool, neighbours: list) -> bool:
    count = live_count(neighbours)
    if alive:
        return count == 2 or count == 3
    else:
        return count == 3

But wait, the problem says that live_next is supposed to return whether the cell is alive in the next round. So, for a living cell, it survives if neighbors are 2 or 3. For a dead cell, it becomes alive if neighbors are exactly 3. So the logic is correct.

Now, I need to make sure that the functions are correctly implemented. Let me test some edge cases.

For example, if neighbours is empty, then live_count returns 0. So, if a cell is alive, it would die because 0 is not 2 or 3. If it's dead, it would stay dead because 0 is not 3. That makes sense.

Another case: if a cell is alive and has 3 neighbors, it survives. If it's dead and has 3 neighbors, it becomes alive.

What about if the neighbours list has duplicates? Since the function is counting the number of alive neighbors, duplicates don't matter. The count is just the sum of the True values.

So, the code seems correct. Now, I need to write the two functions in the solution.py file. The functions are supposed to be in the file, and the interface is as given. The code should not have any other imports or features beyond the contract.

So, the final code would be:

def live_count(neighbours: list) -> int:
    return sum(neighbours)

def live_next(alive: bool, neighbours: list) -> bool:
    count = live_count(neighbours)
    if alive:
        return count == 2 or count == 3
    else:
        return count == 3

Yes, that's the correct implementation. I don't see any issues here. The functions are pure