// https://prologin.org/train/2024/semifinal/chemins-hnitbjorg
#include <iostream>
#include <vector>
#include <queue>
#include <utility>
#include <unordered_map>
using namespace std;

const int MOD = 1000000007;

// Structure pour représenter un sommet du graphe
struct Vertex
{
	int id;
	int value;
	Vertex(int _id, int _value) : id(_id), value(_value) {}
};

// Structure pour représenter le graphe
class Graph
{
private:
	// Liste d'adjacence pour représenter les arêtes
	unordered_map<int, vector<int>> adjacencyList;

	// Map pour stocker les sommets
	unordered_map<int, Vertex> vertices;

public:
	// Ajouter un sommet
	void addVertex(int id, int value)
	{
		vertices.insert(make_pair(id, Vertex(id, value)));
	}

	// Ajouter une arête (non dirigée)
	void addEdge(int from, int to)
	{
		adjacencyList[from].push_back(to);
		adjacencyList[to].push_back(from);
	}

	// Obtenir la valeur d'un sommet
	int getValue(int id) const { return vertices.at(id).value; }

	void print() const
	{
		for(auto &elt : adjacencyList)
		{
			cout << getValue(elt.first) << " : ";
			for(auto &x : elt.second)
				cout << getValue(x) << ' ';
			cout << '\n';
		}
	}

	// Tous les chemins possibles de s à d par parcours en largeur
	// (Breadth First Search)
	int allPaths(int s, int d)
	{
		if(s == d)
			return 1;

		queue<pair<int, int>> q; // paires {sommet, dernier sommet atteint}

		q.push({s, -1}); // s n'a pas de précédent (parent)

		int count = 0;

		while(!q.empty())
		{
			int current = q.front().first;
			int prev = q.front().second;
			q.pop();

			// Pour tous les voisins directs de current
			for(int neighbor : adjacencyList[current])
			{
				if(neighbor == d && getValue(neighbor) > getValue(current))
				{
					count = (count + 1) % MOD;
				}
				else if(getValue(neighbor) > getValue(current) &&
						neighbor != prev)
				{
					q.push({neighbor, current});
				}
			}
		}
		return count;
	} // allPaths()
}; // Graph

// PROGRAMME PRINCIPAL
int main(void)
{
	int N = 0;
	cin >> N; // nombre de sommets

	Graph g;

	int h = 0;
	for(int i = 0; i < N; i++)
	{
		cin >> h;
		g.addVertex(i + 1, h);
	}


	int A = 0;
	cin >> A; // nombre d'arêtes

	int a = 0, b = 0;
	for(int i = 0; i < A; i++)
	{
		cin >> a >> b;
		g.addEdge(a, b);
	}

	int src = 0, dst = 0; // source, destination
	cin >> src >> dst;

	//g.print();

	cout << g.allPaths(src, dst) << '\n';

	return 0;
} // main()