INFINITY = 999999999999999


def deep_copy(graph):
    return [[graph[i][j] for j in range(len(graph[i]))] for i in range(len(graph))]


def dfs(graph, start, dest, path):
    num_vertices = len(graph)
    visited = [False for _ in range(num_vertices)]
    queue = [start]
    visited[start] = True
    path[start] = None
    while len(queue) > 0:
        node = queue.pop()
        for i in range(num_vertices):
            if not visited[i] and graph[node][i] > 0:
                queue.append(i)
                path[i] = node
                visited[i] = True
    return visited[dest]


def find_path_flow(dest, path, residual_graph):
    res = INFINITY
    cur = dest
    while path[cur] is not None:
        parent = path[cur]
        graph_c = residual_graph[parent][cur]
        res = min(res, graph_c)
        cur = parent
    return res


def update_capacities(dest, path_flow, path, residual_graph):
    cur = dest
    while path[cur] is not None:
        parent = path[cur]
        residual_graph[parent][cur] -= path_flow
        residual_graph[cur][parent] += path_flow
        cur = parent


def max_flow(graph, source, dest):
    res = 0
    path = [None for _ in range(len(graph))]
    while dfs(graph, source, dest, path):
        path_flow = find_path_flow(dest, path, graph)
        update_capacities(dest, path_flow, path, graph)
        path = [None for _ in range(len(graph))]
        res += path_flow
    return res


def main():
    num_policeman = int(input())
    nums = read_int_list()
    num_vertex = nums[0]
    num_edges = nums[1]
    museum = nums[2] - 1
    refuge = nums[3] - 1
    vertex_weight = read_int_list()
    vertex_weight[museum] = INFINITY
    vertex_weight[refuge] = INFINITY

    graph = read_graph(num_edges, num_vertex, vertex_weight)

    if museum == refuge or graph[refuge][museum + num_vertex] > 0 \
            or graph[museum + num_vertex][refuge]:
        print("NO")
        return

    flow = max_flow(graph, refuge, museum + num_vertex)
    if flow <= num_policeman:
        print("YES")
    else:
        print("NO")


def read_graph(num_edges, num_vertex, vertex_weight):
    graph = [[0 for _ in range(2 * num_vertex)] for _ in range(2 * num_vertex)]
    for _ in range(num_edges):
        edge = read_int_list()
        one, two = edge[0] - 1, edge[1] - 1
        graph[one][one + num_vertex] = vertex_weight[one]
        graph[one + num_vertex][one] = vertex_weight[one]
        graph[two][two + num_vertex] = vertex_weight[two]
        graph[two + num_vertex][two] = vertex_weight[two]
        graph[one + num_vertex][two] = INFINITY
        graph[two][one + num_vertex] = INFINITY

    return graph


def read_int_list():
    return list(map(lambda x: int(x), input().split(" ")))


if __name__ == '__main__':
    main()