#include <iostream>
#include <iomanip>
using namespace std;

const int MAXS = 15;
const int EMPTY = 0;
const int NOSQ = -1;

int grid[MAXS][MAXS];
int	numr, numc;
int pcount;

bool nextEmptySq(int rows, int cols, int& newr, int& newc)
{
	if (++newc == cols) {
		newr++;
		newc=0;
	}
	while (newr < rows) {
		if (grid[newr][newc] == EMPTY)
			return true;
		if (++newc == cols) {
			newr++;
			newc=0;
		}
	}
	return false;
}

bool okToPlace(double v, int r, int c)
{
	if (grid[r][c] == v)
		return false;
	for(int row=0; row<r; row++) {
		if (grid[row][c] == v)
			return false;
	}
	for(int col=0; col<c; col++) {
		if (grid[r][col] == v)
			return false;
	}
	return true;
}

int input(int m)
{
	int minr, minc, maxr, maxc, r, c;
	int rlist[MAXS], clist[MAXS];
	cin >> r >> c;
	rlist[0] = minr = maxr = r;
	clist[0] = minc = maxc = c;
	for(int i=1; i<m; i++) {
		cin >> r >> c;
		if (r < minr)
			minr = r;
		else if (r > maxr)
			maxr = r;
		if (c < minc)
			minc = c;
		else if (c > maxc)
			maxc = c;
		rlist[i] = r, clist[i] = c;
	}
	numr = maxr-minr+1;
	numc = maxc-minc+1;
	for(int r=0; r<numr; r++)
		for(int c=0; c<numc; c++)
			grid[r][c] = NOSQ;
	for(int i=0; i<m; i++) {
		grid[rlist[i]-minr][clist[i]-minc] = EMPTY;
	}
	return numr<numc ? numr : numc;
}

int numSub(int target, int n)
{
	if (target <= 0 || target >= n)
		return 0;
	else
		return 2*(n-target);
}

int numDiv(int target, int n)
{
	if (target <= 1)
		return 0;
	else
		return 2*(n/target);
}

void countPlacements(int a[], bool used[], int i, int n, int row, int col)
{
	if (i == n) {
		pcount++;
	}
	else {
		nextEmptySq(numr, numc, row, col);
		int lastused = -1;
		for(int j=0; j<n; j++) {
			if (!used[j] && a[j] != lastused && okToPlace(a[j], row, col)) {
				used[j] = true;
				lastused = grid[row][col] = a[j];
				countPlacements(a, used, i+1, n, row, col);
				used[j] = false;
				grid[row][col] = EMPTY;
			}
		}
	}
}

long countPlacements(int a[], int n)
{
/*
	cout << a[0];
	for(int i=1; i<n; i++)
		cout << ' ' << a[i];
	cout << endl;
/**/
	bool used[MAXS] = {0};
	countPlacements(a, used, 0, n, 0, -1);
//cout << "pcount = " << pcount << endl;
	return 0;
}

bool partition(int target, int sum, int currval, int i, int max, int a[], int n, int rep, int maxrep)
{
//cout << "sum, currval, i, rep = " << sum << ',' << currval << ',' << i << ',' << rep << endl;
	int nrem = n-i;
	if (target < sum+nrem*currval)
		return false;
	if (target > sum+nrem*max)
		return true;
	if (nrem == 1 && (rep < maxrep || target-sum != currval)) {
		a[i] = target - sum;
		pcount += countPlacements(a, n);
		return true;
	}
	if (rep < maxrep) {
		a[i] = currval;
		if (!partition(target, sum+currval, currval, i+1, max, a, n, rep+1, maxrep))
			;
	}
	for(int val=currval+1; val<=max; val++) {
		a[i] = val;
		if (!partition(target, sum+val, val, i+1, max, a, n, 1, maxrep))
			;
	}
	return true;
}
bool partition_m(long target, long prod, int currval, int i, int max, int a[], int n, int rep, int maxrep)
{
//cout << "prod, currval, i, rep = " << prod << ',' << currval << ',' << i << ',' << rep << endl;
	int nrem = n-i;
	if (nrem == 0) {
		if (prod == target) {
			pcount += countPlacements(a, n);
			return true;
		}
		return false;
	}
	long long rem = target/prod;
	long long tmp = currval;
	long long tmp2 = max;
	for(int ii=1; ii<nrem; ii++) {
		tmp *= currval;
		tmp2 *= max;
	}
	if (rem < tmp)
		return false;
	if (rem > tmp2)
		return true;
//cout << "here, rem = " << rem << endl;
	if (rep < maxrep && rem%currval == 0) {
		a[i] = currval;
		if (!partition_m(target, prod*currval, currval, i+1, max, a, n, rep+1, maxrep))
			;
	}
	for(int val=currval+1; val<=max; val++) {
		if (rem%val == 0) {
			a[i] = val;
			if (!partition_m(target, prod*val, val, i+1, max, a, n, 1, maxrep))
				;
		}
	}
	return true;
}

int main()
{
	int n, m, target;
	char op;
	int comps[MAXS];

	cin >> n;
		cin >> m >> target >> op;
		int maxrep = input(m);
		pcount = 0;
		switch (op) {
		case '-' : cout << numSub(target, n); break;
		case '/' : cout << numDiv(target, n); break;
		case '+' : if (partition(target, 0, 1, 0, n, comps, m, 0, maxrep))
						cout << pcount;
					break;
		case '*' : if (partition_m(target, 1, 1, 0, n, comps, m, 0, maxrep))
						cout << pcount;
					break;
		}
		cout << endl;
//	int sets[MAXS] = {1, 1, 1, 1, 1, 2};
//	long ans = countPlacements(sets, 6, numr, numc);
//	cout << ans << endl;
}