#define READ_NUM_TEST_CASES  false
#define USE_FAST_IO          false

////////////////////////////////////////////////////////////////////////////////
// AMALGAMATE: "include/template.hpp" BEGINS HERE
//
	
	
	#include <bits/stdc++.h>
	using namespace std;
	
	
	////////////////////////////////////////////////////////////////////////////////
	// AMALGAMATE: "include/abbrevs.hpp" BEGINS HERE
	//
		
		#define UI unsigned int
		
		#define LL long long
		#define ULL unsigned long long
		
		#define PII pair<int,int>
		
		
		#define RI ri()
		#define RUI rui()
		
		#define RLL rll()
		#define RULL rull()
		
		#define RSTR rstr()
		
		
		
		#define FO(i,a,b) for(int i=(a); i<int(b); ++i)
		#define OF(i,a,b) for(int i=(b)-1; i>=int(a); --i)
		
		#define FOR(i,n) FO(i,0,n)
		#define ROF(i,n) OF(i,0,n)
		
		
		#define MIN(a,b) ((a)<(b) ? (a) : (b))
		#define MAX(a,b) ((b)<(a) ? (a) : (b))
		
		#define REMIN(a,b) ((a) = min(a,b))
		#define REMAX(a,b) ((a) = max(a,b))
		
		#define ALL(c) (c).begin(),(c).end()
		
		#define SQR(x) ((x)*(x))
		
		
		
		bool is_pow(int x) {
			return (x&(x-1)) == 0;
		}
		
	
	//
	// AMALGAMATE: "include/abbrevs.hpp" ENDS HERE
	////////////////////////////////////////////////////////////////////////////////
	
	
	#if USE_FAST_IO
		
		////////////////////////////////////////////////////////////////////////////////
		// AMALGAMATE: "include/fast-io.hpp" BEGINS HERE
		//
			
			
			//#define FREAD  fread
			//#define FWRITE fwrite
			
			#define FREAD  fread_unlocked
			#define FWRITE fwrite_unlocked
			
			
			
			
			
			
			struct Buffer {
				FILE* const stream;
				const int buffer_size;
			
				uint8_t* const buff;
				int pos = 0;
			
				Buffer(FILE* a_stream, int a_buffer_size) :
						stream( a_stream ),
						buffer_size( a_buffer_size ),
						buff( new uint8_t[ buffer_size ] ) {
					setvbuf(stream, NULL, _IONBF, 0);
				}
			
				~Buffer() {
					delete[] buff;
				}
			};
			
			
			
			
			
			
			
			
			
			
			class In_Buffer : private Buffer {
			public:
				In_Buffer(FILE* a_stream, int a_buffer_size) : Buffer(a_stream, a_buffer_size) {
					FREAD(buff, 1, buffer_size, stream);
				}
			
			public:
				void prepare(int num_chars) {
					auto remaining = buffer_size - pos;
					if(remaining >= num_chars) return;
			
					assert(remaining >= 0); // prevent compiler warning
					memcpy(buff, buff+pos, remaining);
			
					int read = FREAD(buff+remaining, 1, pos, stream);
					int block_end = remaining + read;
					memset(buff + block_end, 0, buffer_size - block_end);
					pos = 0;
				}
			
			public:
				char get_unchecked() {
					return buff[ pos++ ];
				}
			};
			
			
			template<class INT>
			INT read_unsigned(In_Buffer& buff) {
				buff.prepare(25);
			
				char c = buff.get_unchecked();
				while(c < '-') c = buff.get_unchecked();
			
				INT r = 0;
			
				for(;;) {
					if(c < '0') return r;
					c -= '0';
					r = r*10 + c;
					c = buff.get_unchecked();
				}
			}
			
			
			template<class INT>
			INT read_signed(In_Buffer& buff) {
				buff.prepare(25);
			
				char c = buff.get_unchecked();
				while(c < '-') c = buff.get_unchecked();
			
				bool minus = false;
				if(c=='-') {
					c = buff.get_unchecked();
					minus = true;
				}
			
				INT r = 0;
			
				for(;;)
				{
					if(c < '0') return minus ? -r : r;
					r = r*10 + (c-'0');
					c = buff.get_unchecked();
				}
			}
			
			
			
			
			In_Buffer& operator>>( In_Buffer& buff, char& c) {
				buff.prepare(1);
				c = buff.get_unchecked();
				return buff;
			}
			
			
			
			In_Buffer& operator>>( In_Buffer& buff, UI& r) { r = read_unsigned<UI>(buff); return buff; }
			In_Buffer& operator>>( In_Buffer& buff, ULL& r) { r = read_unsigned<ULL>(buff); return buff; }
			
			In_Buffer& operator>>( In_Buffer& buff, int& r) { r = read_signed<int>(buff); return buff; }
			In_Buffer& operator>>( In_Buffer& buff, LL& r) { r = read_signed<LL>(buff); return buff; }
			
			In_Buffer& operator>>( In_Buffer& buff, string& r) {
				r.clear();
			
				char c = buff.get_unchecked();
				while(c <= ' ') c = buff.get_unchecked();
			
				do {
					r.push_back( c );
					c = buff.get_unchecked();
				} while(c > ' ');
			
				return buff;
			}
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			class Out_Buffer : private Buffer {
			public:
				Out_Buffer(FILE* a_stream, int a_buffer_size) : Buffer(a_stream, a_buffer_size) {}
			
				~Out_Buffer() {
					flush();
				}
			
			public:
				void prepare(int num_chars) {
					if(buffer_size - pos >= num_chars) return;
					flush();
				}
			
				void flush() {
					FWRITE(buff, 1, pos, stream);
					pos = 0;
				}
			
			public:
				void put_unchecked(const char& c) {
					buff[ pos++ ] = c;
				}
			
				void put_unchecked(const char* str, int len) {
					memcpy(buff+pos, str, len);
					pos += len;
				}
			};
			
			
			
			
			
			
			template<class INT>
			void write_signed(Out_Buffer& buff, const INT& i) {
				buff.prepare(25);
			
				if(i == 0) {
					buff.put_unchecked('0');
					return;
				}
			
				auto ci = i;
			
				if(ci < 0) {
					buff.put_unchecked('-');
					ci = -ci;
				}
			
				const int sz = 25;
				char temp[sz];
				int pos = sz;
			
				while(ci) {
					temp[ --pos ] = '0' + ci%10;
					ci/=10;
				}
			
				buff.put_unchecked(temp+pos, sz-pos);
			}
			
			
			
			template<class INT>
			void write_unsigned(Out_Buffer& buff, const INT& i) {
				buff.prepare(25);
			
				if(i==0) {
					buff.put_unchecked('0');
					return;
				}
			
				const int sz = 25;
				char temp[sz];
				int pos = sz;
			
				auto ci = i;
			
				while(ci) {
					temp[ --pos ] = '0' + ci%10;
					ci/=10;
				}
			
				buff.put_unchecked(temp+pos, sz-pos);
			}
			
			
			
			Out_Buffer& operator<<( Out_Buffer& buff, const char& c) {
				buff.prepare(1);
				buff.put_unchecked( c );
				return buff;
			}
			
			Out_Buffer& operator<<( Out_Buffer& buff, const UI& r) { write_unsigned<UI>(buff, r); return buff; }
			Out_Buffer& operator<<( Out_Buffer& buff, const ULL& r) { write_unsigned<ULL>(buff, r); return buff; }
			
			Out_Buffer& operator<<( Out_Buffer& buff, const int& r) { write_signed<int>(buff, r); return buff; }
			Out_Buffer& operator<<( Out_Buffer& buff, const LL& r) { write_signed<LL>(buff, r); return buff; }
			
			Out_Buffer& operator<<( Out_Buffer& buff, const char* cstr) { auto len = strlen(cstr); buff.prepare(len); buff.put_unchecked(cstr, len); return buff; }
			Out_Buffer& operator<<( Out_Buffer& buff, const string& str) { buff.prepare( str.size() ); buff.put_unchecked(str.data(), str.size()); return buff; }
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			
			#define BUFF_SIZE 32768
			In_Buffer  fast_cin(  stdin,  BUFF_SIZE );
			Out_Buffer fast_cout( stdout, BUFF_SIZE );
			//Out_Buffer fast_cerr( stderr, BUFF_SIZE );
			
			char fast_endl = '\n';
			
		
		//
		// AMALGAMATE: "include/fast-io.hpp" ENDS HERE
		////////////////////////////////////////////////////////////////////////////////
		
		#define cin fast_cin
		#define cout fast_cout
		#define endl fast_endl
	#else
		
		////////////////////////////////////////////////////////////////////////////////
		// AMALGAMATE: "include/slow-io.hpp" BEGINS HERE
		//
			
			struct Slow_IO_Singleton {
				Slow_IO_Singleton() {
					ios_base::sync_with_stdio( false );
			
					std::cin.tie( nullptr );
					std::cout.tie( nullptr );
			
					setlocale(LC_ALL,"C");
			
					const int buffer_size = 32768;
			
					static char stdin_buffer[ buffer_size ];
					static char stdout_buffer[ buffer_size ];
			
					cin.rdbuf()->pubsetbuf( stdin_buffer, buffer_size );
					cout.rdbuf()->pubsetbuf( stdout_buffer, buffer_size );
				}
			
				~Slow_IO_Singleton() {
			
				}
			};
			
			
			Slow_IO_Singleton slow_io_singleton;
			
		
		//
		// AMALGAMATE: "include/slow-io.hpp" ENDS HERE
		////////////////////////////////////////////////////////////////////////////////
		
		#ifndef DEBUG
			#define endl '\n'
		#endif
	#endif
	
	
	////////////////////////////////////////////////////////////////////////////////
	// AMALGAMATE: "include/abbrevs-io.hpp" BEGINS HERE
	//
		
		
		
		
		int ri()   { int r; cin >> r; return r; }
		UI  rui()  { UI r; cin >> r; return r; }
		
		LL  rll()  { LL r;  cin >> r; return r; }
		ULL rull() { ULL r; cin >> r; return r; }
		
		string rstr() {string s; cin >> s; return s; }
		
	
	//
	// AMALGAMATE: "include/abbrevs-io.hpp" ENDS HERE
	////////////////////////////////////////////////////////////////////////////////
	
	
	
	////////////////////////////////////////////////////////////////////////////////
	// AMALGAMATE: "include/debug.hpp" BEGINS HERE
	//
		
		
		#define ASS(x) assert(x)
	
	//
	// AMALGAMATE: "include/debug.hpp" ENDS HERE
	////////////////////////////////////////////////////////////////////////////////
	
	
	
	
	//
	// for salgo
	#define CONTEST_MODE
	
	namespace salgo {};
	using namespace salgo;
	//

//
// AMALGAMATE: "include/template.hpp" ENDS HERE
////////////////////////////////////////////////////////////////////////////////


//#define assert(x)






//
// snippets/int-pow.hpp
//
template<class T, class E, class OP>
T int_pow(T a, E exp, const OP& op, const T& neutral) {
	// assert(exp >= 0);
	if(exp < 0) return 1;

	auto r = neutral;
	while(exp != 0) {
		if((exp & 1) != 0) {
			op(r, a);
			--exp;
		}
		else{
			exp >>= 1;
			op(a, a);
		}
	}
	return r;
}

template<class T, class E>
T int_pow(const T& a, const E& exp) {
	auto lambda = [](T& aa, const T& bb){ aa *= bb; };
	return int_pow<T,E,decltype(lambda)>(a, exp, lambda, T(1));
}







//
// snippets/modulo.hpp
//
uint32_t MOD = 1e9 + 7;

class Modulo {
public:
	using H = uint32_t;
	H h = 0;

public:
	Modulo() = default;
	Modulo(H x) : h( x % MOD ) {}

	Modulo(const Modulo&) = default;

public:
	Modulo& operator+=(const Modulo& o) {
		h += o.h;
		if(h >= MOD) h -= MOD;
		return *this;
	}

	Modulo& operator-=(const Modulo& o) {
		h = MOD + h - o.h;
		if(h >= MOD) h -= MOD;
		return *this;
	}

	Modulo& operator*=(const Modulo& o) {
		h = (1ULL * h * o.h) % MOD;
		return *this;
	}

	Modulo& operator/=(const Modulo& o) {
		const auto TOTIENT = MOD-1;
		*this *= int_pow(o, TOTIENT-1);
		return *this;
	}

	bool operator==(const Modulo& o) const { return h == o.h; }
	bool operator!=(const Modulo& o) const { return h != o.h; }


	Modulo operator+(const Modulo& o) const { return Modulo(*this) += o; }
	Modulo operator-(const Modulo& o) const { return Modulo(*this) -= o; }
	Modulo operator*(const Modulo& o) const { return Modulo(*this) *= o; }
	Modulo operator/(const Modulo& o) const { return Modulo(*this) /= o; }



	Modulo& operator--()    { if(h == 0) h = MOD; --h; return *this; }
	Modulo& operator++()    { ++h; if(h == MOD) h = 0; return *this; }
	Modulo  operator--(int) { auto m = *this; --(*this); return m; }
	Modulo  operator++(int) { auto m = *this; ++(*this); return m; }



	explicit operator H() const { return h; }
};

ostream& operator<<(ostream& os, const Modulo& modulo) {
	return os << modulo.h;
}













struct Range {
	int fi = -1;
	int la = -1;

	bool operator<(const Range& o) const {
		return pair{fi,la} < pair{o.fi, o.la};
	}

	int num() const { return la-fi+1; }
};

struct Test_Case {

	int n = RI;
	int m = RI;
	int num_lake = RI;
	int num_sea = RI;

	int num_not_reachable = 0;

	struct Vert {
		vector<int> tos;

		Range range;

		bool reachable = false;

		bool vis = false;
	};

	bool is_sea(int iv) {
		return num_lake <= iv && iv < num_lake + num_sea;
	}

	vector<Vert> verts;

	void dfs0(int iv) {
		auto& v = verts[iv];
		if(v.reachable) return;
		v.reachable = true;

		for(auto to : v.tos) {
			dfs0(to);
		}
	}

	void dfs(int iv) {
		auto& v = verts[iv];
		if(v.vis) return;
		v.vis = true;


		deque<Range> ranges;
		if(is_sea(iv)) ranges.push_back({ iv-num_lake, iv-num_lake });

		for(auto& to : v.tos) {
			dfs(to);

			auto& r = verts[to].range;
			if(r.fi != -1) {
				ranges.push_back(r);
			}
		}

		// auto asd = ranges;

		if(!ranges.empty()) {
			sort(ALL(ranges));

			while(ranges.size() > 1 && ranges[0].la >= ranges[1].fi - 1) {
				ranges[1].fi = ranges[0].fi;
				ranges.pop_front();
			}

			while(ranges.size() > 1 && ranges.back().la - num_sea >= ranges[0].fi - 1) {
				ranges.back().la = ranges[0].la + num_sea;
				ranges.pop_front();
			}

			// if(ranges.size() != 1) {
			// 	cout << "DBG ranges at vert " << iv << endl;
			// 	for(auto& r : asd) cout << r.fi << " -> " << r.la << endl;
			// 	cout << endl;

			// }

			assert(ranges.size() == 1);

			if(ranges[0].la - ranges[0].fi + 1 >= num_sea) {
				v.range = {0, num_sea-1};
			}
			else {
				v.range = ranges[0];
			}
		}
	}

	void subtask_a(const vector<Range>& ranges) {
		vector<Modulo> dp( ranges.size()+1 );

		dp[0] = 0;
		dp[1] = int_pow(Modulo(2), num_sea - ranges[0].num());

		// cout << "dp[1] == " << dp[1] << endl;

		int i_end = 0;
		FO(i, 1, ranges.size()) {
			// int num_new = ranges[i].la - ranges[i-1].la;
			dp[i+1] = dp[i];

			if(i_end >= 0) --i_end;

			while(i_end+1 < (int)ranges.size() && ranges[i_end+1].la < ranges[i-1].fi) ++i_end;

			while(i_end == -1 || ranges[i_end].la < ranges[i].fi) {
				int end_pos = ranges[i].fi-1;
				if(i_end+1 < (int)ranges.size()) REMIN(end_pos, ranges[i_end+1].la);

				int start_pos = ranges[i-1].fi;
				if(i_end >= 0) REMAX(start_pos, ranges[i_end].la + 1);

				// cout << endl << "dp step   i_end == " << i_end << "   start_pos == " << start_pos << "   end_pos == " << end_pos << endl;

				dp[i+1] += (int_pow(Modulo(2), num_sea) - dp[i_end+1])
					/ int_pow(Modulo(2), ranges[i].la - start_pos +1)
					* (int_pow(Modulo(2), end_pos - start_pos +1) - 1);

				// cout << "dp += " << (int_pow(Modulo(2), num_sea) - dp[i_end+1]) << " / " <<
					// int_pow(Modulo(2), ranges[i].la - start_pos +1) << " * " <<
					// (int_pow(Modulo(2), end_pos - start_pos +1) - 1) << endl;
				
				++i_end;
			}

			// cout << "dp[" << i+1 << "] == " << dp[i+1] << endl;
		}

		auto r = int_pow(Modulo(2), num_sea) - dp[ ranges.size() ];

		r *= int_pow(Modulo(2), num_not_reachable);

		cout << r << endl;
	}

	void subtask_b(const vector<Range>&) {
		
	}

	void solve() {
		// cout << "Case #" << icase+1 << ": ";
		verts.resize(n);
		FOR(i,m) {
			int a = RI-1;
			string edge = RSTR;
			int b = RI-1;

			if(edge == "->") {
				verts[a].tos.push_back(b);
			}
			else {
				verts[a].tos.push_back(b);
				verts[b].tos.push_back(a);
			}
		}

		FOR(i, num_lake) {
			dfs0(i);
		}

		// delete not-reachable sea settlements
		n = 0;
		vector<int> v_remap( verts.size() );
		FOR(i, verts.size()) {
			if(is_sea(i) && !verts[i].reachable) {
				// delete!
				++num_not_reachable;
			}
			else {
				v_remap[i] = n;
				verts[n] = verts[i];
				++n;
			}
		}
		verts.resize(n);

		for(auto& v : verts) {
			for(auto& to : v.tos) {
				to = v_remap[to];
			}
		}

		num_sea -= num_not_reachable;

		// cout << "deleted " << num_not_reachable << " not-reachable sea settlements" << endl;

		FOR(asd,10) FOR(i,n) {
			dfs(i);
		}

		// cout << "ranges:" << endl;
		// FOR(i, num_lake) {
		// 	cout << i+1 << ": " << verts[i].range.fi << " -> " << verts[i].range.la << endl;
		// }

		int full_range_at = -1;

		auto is_full = [&](const auto& range) {
			return range.fi == 0 && range.la == num_sea-1;
		};

		FOR(i, num_lake) {
			if(is_full(verts[i].range)) {
				full_range_at = i;
				break;
			}
		}

		vector<Range> ranges;
		FOR(i, num_lake) ranges.push_back( verts[i].range );

		auto cycle = [&](const auto& v, int at) {
			vector<Range> r;
			FO(i, at, num_lake) {
				r.push_back( v[i] );
			}
			FO(i, 0, at) {
				r.push_back( v[i] );
			}
			return r;
		};

		if(full_range_at != -1) {
			ranges = cycle(ranges, full_range_at);
		}


		{
			decltype(ranges) res;
			for(auto& r : ranges) {
				if(!is_full(r)) res.push_back(r);
			}
			ranges = std::move(res);
		}

		int num_inc = 0;
		int num_dec = 0;
		FOR(i, ranges.size()) {
			int j = (i+1) % ranges.size();

			if(ranges[i].fi < ranges[j].fi) ++num_inc;
			if(ranges[i].la < ranges[j].la) ++num_inc;

			if(ranges[i].fi > ranges[j].fi) ++num_dec;
			if(ranges[i].la > ranges[j].la) ++num_dec;
		}

		if(num_dec > num_inc) {
			reverse(ALL(ranges));
		}

		auto fix = [&](auto& vec) {
			FO(i, 1, vec.size()) {
				if(vec[i-1].fi > vec[i].fi) {
					vec[i].fi += num_sea;
					vec[i].la += num_sea;
				}
			}
		};

		fix(ranges);

		int break_before = -1;
		FOR(i, ranges.size()) {
			int j = (i+1) % ranges.size();

			auto i_range = ranges[i];
			auto j_range = ranges[j];

			if(i_range.fi > j_range.fi || i_range.la > j_range.la) {
				j_range.fi += num_sea;
				j_range.la += num_sea;
			}

			if(i_range.la < j_range.fi) {
				break_before = j;
				break;
			}
		}

		if(break_before != -1) {
			ranges = cycle(ranges, break_before);
		}

		fix(ranges);

		// cout << "RANGES:" << endl;
		// for(auto& r : ranges) cout << r.fi << " -> " << r.la << endl;
		// cout << endl;

		if(full_range_at != -1 || break_before != -1) {
			// cout << "SUBTASK A" << endl;
			subtask_a(ranges);
		}
		else {
			// cout << "SUBTASK B" << endl;
			subtask_b(ranges);
		}
	}

	int icase = -1;
}; // struct Test_Case



int main() {
	int num_cases = READ_NUM_TEST_CASES ? RI : 1;
	
	FOR(i, num_cases) {
		Test_Case tc;
		tc.icase = i;
		tc.solve();
	}

	return 0;
}