#include <iostream>
#include <vector>
#include <math.h>
#include <algorithm>
#include <queue>

#define REP(i, n) for(int i = 0; i < n; i++)


using namespace std;

int H, W, A, B;
//---------------------------------------------------------------------------------------------------
bool used[16][16];
int dfs(int x, int y, int a) {
    // 最後まで探索して、長方形のタイルを使い切っているなら、組合せを+1する
    if (H == y) return a == 0;

    // 横の端まで行ったら次の行へ
    if (W == x) return dfs(0, y + 1, a);

    // 既に置かれているなら何もできないので、次のマスへ
    if (used[y][x]) return dfs(x + 1, y, a);

    int res = 0;

    // 縦置き
    if (y + 1 < H && !used[y + 1][x] && 0 < a) {
        used[y][x] = used[y + 1][x] = true;
        res += dfs(x + 1, y, a - 1);
        used[y][x] = used[y + 1][x] = false;
    }

    // 横置き
    if (x + 1 < W && !used[y][x + 1] && 0 < a) {
        used[y][x] = used[y][x + 1] = true;
        res += dfs(x + 1, y, a - 1);
        used[y][x] = used[y][x + 1] = false;
    }

    // 何も置かない
    res += dfs(x + 1, y, a);

    return res;
}
//---------------------------------------------------------------------------------------------------
int main() {
    cin >> H >> W >> A >> B;
    cout << dfs(0, 0, A) << endl;
}
#include <iostream>
#include <bits/stdc++.h>
using namespace std;
typedef long long int ll;
typedef long double db;
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
using namespace __gnu_pbds;

template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
template <typename T>
using ordered_multiset = tree<T, null_type, less_equal<T>, rb_tree_tag, tree_order_statistics_node_update>;
#define pll pair<ll,ll>
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define ub(v,val) upper_bound(v.begin(),v.end(),val)
#define np(str) next_permutation(str.begin(),str.end())
#define lb(v,val) lower_bound(v.begin(),v.end(),val)
#define sortv(vec) sort(vec.begin(),vec.end())
#define rev(p) reverse(p.begin(),p.end());
#define v vector
#define pi 3.14159265358979323846264338327950288419716939937510
#define len length()
#define repc(i,s,e) for(ll i=s;i<e;i++)
#define fi first
#define se second
#define mset(a,val) memset(a,val,sizeof(a));
#define mt make_tuple
#define repr(i,n) for(i=n-1;i>=0;i--)
#define rep(i,n) for(i=0;i<n;i++)
#define IOS ios::sync_with_stdio(0); cin.tie(0); cout.tie(0);
#define at(s,pos) *(s.find_by_order(pos))
#define set_ind(s,val) s.order_of_key(val)
long long int M = 1e9 + 7 ;
long long int inf = 9 * 1e18;
//CLOCK
ll begtime = clock();
#define time() cout << "\n\nTime elapsed: " << (clock() - begtime)*1000/CLOCKS_PER_SEC << " ms\n\n";
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
//CLOCK ENDED
ll n, m;
// modular exponentiation
ll binpow(ll val, ll deg)
{
	if (deg < 0)
		return 0;
	if (!deg)
		return 1 % M;
	if (deg & 1)
		return binpow(val, deg - 1) * val % M;
	ll res = binpow(val, deg >> 1);
	return (res * res) % M;
}
//binomial
ll modinv(ll n) {
	return binpow(n, M - 2);
}
ll a, b;


int main() {
	// your code goes here
	IOS;
#ifndef ONLINE_JUDGE
	freopen("input.txt", "r", stdin);
	freopen("output.txt", "w", stdout);
#endif
	ll i, j, t, k, x, y, z,  N;

	cin >> n >> m;
	cin >> a >> b;
	ll nways = 0;

	x = n * m;
	ll p1[1ll << x] = {0}, p2[1ll << x] = {0};
	rep(i, 1ll << x) {
		ll flg = 0;
		ll row = 0;
		ll mat[n][m];
		mset(mat, 0);
		rep(j, x) {
			if ((i >> j) & 1) {
				mat[row][j % m] = 1ll;
			}
			if ((j + 1ll) % m == 0)row++;
		}
		ll cnt = 0;
		rep(j, n) {
			ll par = 0;
			rep(k, m) {
				// cout << mat[j][k] << ' ';
				if (mat[j][k]) {
					if (par == 0) {
						par = 1ll;
					}
					else if (par == 1ll) {
						if (mat[j][k - 1ll]) {
							par = 0;
							cnt++;
						}
						else {
							flg = 1ll;
						}
					}
				}
			}
			// cout << '\n';
			if (par) flg = 1ll;
		}
		if (flg == 0) {
			p1[i] = cnt;

		}
		// cout << '\n';
		flg = 0;
		cnt = 0;
		rep(k, m) {
			ll par = 0;
			rep(j, n) {
				if (mat[j][k]) {
					if (par == 0) {
						par = 1ll;
					}
					else if (par == 1ll) {
						if (mat[j - 1ll][k]) {
							par = 0;
							cnt++;
						}
						else {
							flg = 1ll;
						}
					}
				}
			}
			if (par) flg = 1ll;
		}
		if (flg == 0) {
			p2[i] = cnt;
		}
	}
	for (i = 0; i < (1ll << x); i++) {
		if (p1[i]) {
			if (p1[i] < a) {
				y = ((1ll << x) - 1ll)^i;
				for (j = y; j > 0; j = y & (j - 1ll)) {
					if (p2[j]) {
						if (p2[j] == a - p1[i])
							nways++;
					}
				}
			}
		}
	}
	rep(i, 1ll << x) {
		if (p1[i] == a) nways++;
		if (p2[i] == a) nways++;
	}
	if (a == 0) {
		cout << 1;
	}
	else
		cout << nways;


	return 0;



}


