def course_schedule_brute_force(number_of_courses, prerequisites, queries):
    results = []
    for query in queries:
        course_a = query[0]
        course_b = query[1]
        
        if can_take_course(number_of_courses, prerequisites, course_a, course_b):
            results.append(True)
        else:
            results.append(False)
    return results

def can_take_course(number_of_courses, prerequisites, course_a, course_b):
    # Use a recursive depth-first search to find a path
    return has_path(prerequisites, course_a, course_b, set())

def has_path(prerequisites, current_course, target_course, visited):
    if current_course == target_course:
        return True

    if current_course in visited:
        return False

    visited.add(current_course)
    
    # Iterate through prerequisites to explore neighbors.
    for prerequisite, course in prerequisites:
        if prerequisite == current_course:

            # Recursively search for path to target
            if has_path(prerequisites, course, target_course, visited):
                return True

    # Mark as unvisited for other paths.
    visited.remove(current_course)

    # If no path found, return false
    return False

def course_schedule_iv(number_of_courses, prerequisites, queries):
    adjacency_list = [[] for _ in range(number_of_courses)]
    for source, destination in prerequisites:
        adjacency_list[source].append(destination)

    reachable = [[False] * number_of_courses for _ in range(number_of_courses)]

    # Iterate over all courses to find reachable nodes.
    for start_course in range(number_of_courses):
        visited = [False] * number_of_courses
        queue = [start_course]
        visited[start_course] = True

        while queue:
            current_course = queue.pop(0)
            reachable[start_course][current_course] = True

            for neighbor in adjacency_list[current_course]:
                if not visited[neighbor]:
                    visited[neighbor] = True
                    queue.append(neighbor)

    result = []
    # Evaluate each query to determine prerequisite relationship.
    for course_a, course_b in queries:
        result.append(reachable[course_a][course_b])

    return result