//#define _GLIBCXX_DEBUG
#include <bits/stdc++.h>
using namespace std;
#define rep(i, n) for(int i=0; i<n; ++i)
#define all(v) v.begin(), v.end()
#define rall(v) v.rbegin(), v.rend()
using ll = int64_t;
using ull = uint64_t;
using ld = long double;
using P = pair<int, int>;
using vs = vector<string>;
using vi = vector<int>;
using vvi = vector<vi>;
template<class T> using PQ = priority_queue<T>;
template<class T> using PQG = priority_queue<T, vector<T>, greater<T>>;
const int INF = 0xccccccc;
const ll LINF = 0xcccccccccccccccLL;
template<typename T1, typename T2>
inline bool chmax(T1 &a, T2 b) {return a < b && (a = b, true);}
template<typename T1, typename T2>
inline bool chmin(T1 &a, T2 b) {return a > b && (a = b, true);}
template<typename T1, typename T2>
istream &operator>>(istream &is, pair<T1, T2> &p) { return is >> p.first >> p.second;}
template<typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) { return os << p.first << ' ' << p.second;}



//head



int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  int h, w, a, b;
  cin >> h >> w >> a >> b;
  vector<vector<vvi>> dp(h+1, vector<vvi>(w+1, vvi(1<<w, vi(a+1))));
  dp[0][0][0][0] = 1;
  rep(i, h) {
    rep(j, w) {
      rep(k, 1<<w) {
        rep(l, a+1) {
          dp[i][j+1][k&~(1<<j)][l] += dp[i][j][k][l];
          if(~k>>j&1 and l != a) {
            if(j != w-1 and ~k>>j+1&1) dp[i][j+1][k^(1<<j+1)][l+1] += dp[i][j][k][l];
            dp[i][j+1][k^(1<<j)][l+1] += dp[i][j][k][l];
          }
        }
      }
    }
    rep(k, 1<<w) {
      rep(l, a+1) {
        dp[i+1][0][k][l] = dp[i][w][k][l];
      }
    }
  }
  cout << dp[h][0][0][a] << endl;
}

//================code===================//

//#define TLE

#ifdef TLE
#pragma GCC optimize("O3")
#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")
#endif

#include <bits/stdc++.h>
#include <unordered_map>
#include <unordered_set>
#include <random>
#include <ctime>


#define ci(t) cin>>t
#define co(t) cout<<t
#define LL long long

#define ld double
#define fa(i,a,b) for(LL i=(a);i<(LL)(b);++i)
#define fd(i,a,b) for(LL i=(a);i>(LL)(b);--i)
#define setp tuple<LL,LL,LL>
#define setl pair<LL,LL>
#define micro 0.000001

using namespace std;

LL gcd(LL a, LL b) { return a % b ? gcd(b, a % b) : b; }


#ifdef OHSOLUTION
#define ce(t) cerr<<t
#define AT cerr << "\n=================ANS=================\n"
#define AE cerr << "\n=====================================\n"
#define DB(a) cerr << __LINE__ << ": " << #a << " = " << (a) << endl;
#define __builtin_popcount __popcnt
#define __builtin_popcountll __popcnt64
#else
#define AT
#define AE
#define ce(t)
#endif

pair <int, int> vu[9] = { {0,-1},{1,0},{0,1} ,{-1,0},{0,0},{1,1}, {-1,1} , {1,-1},{-1,-1} }; //RDLU EWSN

template<typename T, typename U> void ckmax(T& a, U b) { a = a < b ? b : a; }
template<typename T, typename U> void ckmin(T& a, U b) { a = a > b ? b : a; }
struct gcmp { bool operator()(LL a, LL b) { return a < b; } bool operator()(setl& a, setl& b) { return a.second < b.second; } };
struct lcmp { bool operator()(LL a, LL b) { return a > b; } bool operator()(setl& a, setl& b) { return a.second > b.second; } };

const int max_v = 1e4 + 7;
const int max_k = 1027;
const int INF = 1e9 + 7;
const LL LNF = (LL)5e18 + 7ll;
LL mod = 1e9+7;
template<typename T, typename U> void MOD(T& a, U b) { a += b; if (a >= mod) a -= mod; }

int r, c;
int ans = 0;
bool arr[17][17];

void dfs(int idx, int a, int b)
{
	if (a < 0 || b < 0) return;

	if (idx == r*c)
	{
		++ans;
		return;
	}

	int nr = idx / c;
	int nc = idx % c;

	if (arr[nr][nc]) dfs(idx + 1, a, b);
	else
	{	
		if (nr + 1 != r)
		{
			arr[nr + 1][nc] = 1;
			dfs(idx + 1, a - 1, b);
			arr[nr + 1][nc] = 0;
		}

		if (nc + 1 != c && !arr[nr][nc+1])
		{
			arr[nr][nc + 1] = 1;
			dfs(idx + 1, a - 1, b);
			arr[nr][nc + 1] = 0;
		}

		dfs(idx + 1, a, b - 1);
	}
}
 
int main()
{
#ifdef OHSOLUTION
	freopen("input.txt", "r", stdin);
#endif
	ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);
	int a, b; ci(r >> c >> a >> b);

	dfs(0, a, b);
	co(ans);
	return 0;
}
