[C] DP | Time: O(m * n), Space: O(m)

//--------kernel--------
#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <stdlib.h>
#include <math.h>

static bool isReachableFromHorse(
	const int horseRow,
	const int horseCol,

	const int targetRow,
	const int targetCol
){
	const int rowDiffAbs = abs(horseRow - targetRow);
	const int colDiffAbs = abs(horseCol - targetCol);
	return (1 == rowDiffAbs && 2 == colDiffAbs) ||
		(2 == rowDiffAbs && 1 == colDiffAbs);
}

static bool isBlockedByHorse(
	const int horseRow,
	const int horseCol,

	const int targetRow,
	const int targetCol
){
	return (targetRow == horseRow && targetCol == horseCol) ||
		isReachableFromHorse(horseRow, horseCol, targetRow, targetCol);
}

int64_t wayCntToReachTarget(
	const int horseRow,
	const int horseCol,

	const int targetRow,
	const int targetCol
){
	int64_t * dp = (int64_t *)malloc(sizeof (int64_t) * (1 + targetCol));
	if (NULL == dp){
		abort();
	}

	//init dp as first row
	dp[0] = isBlockedByHorse(horseRow, horseCol, 0, 0)? 0 : 1;
	for (int col = 1; col <= targetCol; col += 1){
		dp[col] = isBlockedByHorse(horseRow, horseCol, 0, col)? 0 : dp[col - 1];
	}

	//row 1 to targetRow
	for (int row = 1; row <= targetRow; row += 1){
		if (isBlockedByHorse(horseRow, horseCol, row, 0)){
			dp[0] = 0;
		}
		for (int col = 1; col <= targetCol; col += 1){
			dp[col] = isBlockedByHorse(horseRow, horseCol, row, col)? 0 :
				(dp[col - 1] + dp[col]);
		}
	}

	//save result before free()
	const int64_t finalWayCnt = dp[targetCol];

	free(dp);
	dp = NULL;

	return finalWayCnt;
}

//--------main--------
#include <stdio.h>

int main(void){
	int targetRow, targetCol, horseRow, horseCol;
	scanf("%d%d%d%d", &targetRow, &targetCol, &horseRow, &horseCol);

	const int64_t finalWayCnt = wayCntToReachTarget(horseRow, horseCol, targetRow, targetCol);

	printf("%lld", finalWayCnt);

	return 0;
}