from collections import deque


def generate_streptosquarus(n):
    if n == 1:
        return 1

    # All possible moves from a square
    moves = [(0, 1), (1, 0), (0, -1), (-1, 0)]

    # Generate all possible shapes by adding a square to each exposed edge
    def generate_shapes(current_shape):
        new_shapes = set()
        for x, y in current_shape:
            for dx, dy in moves:
                new_pos = (x + dx, y + dy)
                if new_pos not in current_shape:
                    new_shape = current_shape | {new_pos}
                    new_shapes.add(frozenset(new_shape))
        return new_shapes

    # Normalize shapes by rotating and flipping to remove duplicates
    def normalize(shape):
        # Convert frozenset to a sorted list of tuples to allow rotations and flips
        shape = sorted(shape)

        def rotate(shape):
            return sorted((y, -x) for x, y in shape)

        def flip(shape):
            return sorted((-x, y) for x, y in shape)

        # Generate all unique rotations and flips of the shape
        unique_transforms = {tuple(shape)}
        for _ in range(3):  # Rotate three more times
            shape = rotate(shape)
            unique_transforms.add(tuple(shape))

        # Flip the shape and get all its rotations
        shape = flip(shape)
        unique_transforms.add(tuple(shape))
        for _ in range(3):  # Rotate three more times
            shape = rotate(shape)
            unique_transforms.add(tuple(shape))

        # Normalize to ensure all shapes start from (0, 0)
        def normalize_shape(transform):
            min_x = min(x for x, y in transform)
            min_y = min(y for x, y in transform)
            return tuple((x - min_x, y - min_y) for x, y in transform)

        normalized_shapes = set(normalize_shape(transform) for transform in unique_transforms)
        return min(normalized_shapes)  # Return the smallest normalized shape

    # Use a set to store all unique shapes
    unique_shapes = set()

    # Starting queue with a single square
    queue = deque([frozenset([(0, 0)])])
    while queue:
        shape = queue.popleft()
        if len(shape) == n:
            norm_shape = normalize(shape)
            unique_shapes.add(norm_shape)
        else:
            for new_shape in generate_shapes(shape):
                queue.append(new_shape)

    return len(unique_shapes)


# Example usage
def main():
    print("Enter a positive integer or 'q' to quit.")
    while True:
        user_input = input("Enter a integer number or 'q' to quit: ")
        if user_input.lower() == 'q':
            print("Program has ended.")
            break
        try:
            n = int(user_input)
            if n < 1:
                print("Warning: Please enter a positive integer.")
            elif n > 6:
                print("Warning: Calculations for numbers greater than 6 may be slow.")
            result = generate_streptosquarus(n)
            print(f"Number of possible shapes for a streptosquarus of size {n}: {result}")
        except ValueError:
            print("Warning: Please enter a valid integer or 'q' to quit.")


if __name__ == "__main__":
    main()