// Original C++ solution (slower):
// need

#include <iostream>

#include <algorithm>



// data structure

#include <bitset>

//#include <list>

#include <map>

#include <queue>

#include <set>

#include <stack>

#include <string>

#include <utility>

#include <vector>

//#include <array>

//#include <tuple>

//#include <unordered_map>

#include <unordered_set>

#include <complex>

//#include <deque>

#include<valarray>



// stream

//#include <istream>

//#include <sstream>

//#include <ostream>

#include <fstream>



// etc

#include <cmath>

#include <cassert>

#include <functional>

#include <iomanip>

//#include <typeinfo>

#include <chrono>

#include <random>

#include <numeric>





#define INIT std::ios::sync_with_stdio(false);std::cin.tie(0);

#define VAR(type, ...)type __VA_ARGS__;MACRO_VAR_Scan(__VA_ARGS__);

template<typename T> void MACRO_VAR_Scan(T& t) { std::cin >> t; }

template<typename First, typename...Rest>void MACRO_VAR_Scan(First& first, Rest&...rest) { std::cin >> first; MACRO_VAR_Scan(rest...); }

#define VEC_ROW(type, n, ...)std::vector<type> __VA_ARGS__;MACRO_VEC_ROW_Init(n, __VA_ARGS__); for(int i=0; i<n; ++i){MACRO_VEC_ROW_Scan(i, __VA_ARGS__);}

template<typename T> void MACRO_VEC_ROW_Init(int n, T& t) { t.resize(n); }

template<typename First, typename...Rest>void MACRO_VEC_ROW_Init(int n, First& first, Rest&...rest) { first.resize(n); MACRO_VEC_ROW_Init(n, rest...); }

template<typename T> void MACRO_VEC_ROW_Scan(int p, T& t) { std::cin >> t[p]; }

template<typename First, typename...Rest>void MACRO_VEC_ROW_Scan(int p, First& first, Rest&...rest) { std::cin >> first[p]; MACRO_VEC_ROW_Scan(p, rest...); }

#define OUT(d) std::cout<<d;

#define FOUT(n, d) std::cout<<std::fixed<<std::setprecision(n)<<d;

#define SOUT(n, c, d) std::cout<<std::setw(n)<<std::setfill(c)<<d;

#define SP std::cout<<" ";

#define TAB std::cout<<"\t";

#define BR std::cout<<"\n";

#define SPBR(i, n) std::cout<<(i + 1 == n ? '\n' : ' ');

#define ENDL std::cout<<std::endl;

#define FLUSH std::cout<<std::flush;

#define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;

#define MAT(type, c, m, n) std::vector<std::vector<type>> c(m, std::vector<type>(n));for(auto& r:c)for(auto& i:r)std::cin>>i;

#define ALL(a) (a).begin(),(a).end()

#define FOR(i, a, b) for(int i=(a);i<(b);++i)

#define RFOR(i, a, b) for(int i=(b)-1;i>=(a);--i)

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

#define RREP(i, n) for(int i=(n)-1;i>=0;--i)

#define FORLL(i, a, b) for(ll i=ll(a);i<ll(b);++i)

#define RFORLL(i, a, b) for(ll i=ll(b)-1;i>=ll(a);--i)

#define REPLL(i, n) for(ll i=0;i<ll(n);++i)

#define RREPLL(i, n) for(ll i=ll(n)-1;i>=0;--i)

#define IN(a, x, b) (a<=x && x<b)

#define SHOW(d) {std::cerr << #d << "\t:" << d << "\n";}

#define SHOWVECTOR(v) {std::cerr << #v << "\t:";for(const auto& xxx : v){std::cerr << xxx << " ";}std::cerr << "\n";}

#define SHOWVECTOR2(v) {std::cerr << #v << "\t:\n";for(const auto& xxx : v){for(const auto& yyy : xxx){std::cerr << yyy << " ";}std::cerr << "\n";}}

#define SHOWQUEUE(a) {auto tmp(a);std::cerr << #a << "\t:";while(!tmp.empty()){std::cerr << tmp.front() << " ";tmp.pop();}std::cerr << "\n";}

template<typename T> inline T CHMAX(T& a, const T b) { return a = (a < b) ? b : a; }

template<typename T> inline T CHMIN(T& a, const T b) { return a = (a > b) ? b : a; }

#define EXCEPTION(msg) throw std::string("Exception : " msg " [ in ") + __func__ + " : " + std::to_string(__LINE__) + " lines ]"

#define TRY(cond, msg) try {if (cond) EXCEPTION(msg);}catch (std::string s) {std::cerr << s << std::endl;}

void CHECKTIME(std::function<void()> f) { auto start = std::chrono::system_clock::now(); f(); auto end = std::chrono::system_clock::now(); auto res = std::chrono::duration_cast<std::chrono::nanoseconds>((end - start)).count(); std::cerr << "[Time:" << res << "ns  (" << res / (1.0e9) << "s)]\n"; }



template<typename S, typename T>

std::ostream& operator<<(std::ostream& os, std::pair<S, T> p) {

	os << "(" << p.first << ", " << p.second << ")";

	return os;

}



#define int ll

using ll = long long;

using ull = unsigned long long;

using PAIR = std::pair<int, int>;

using PAIRLL = std::pair<ll, ll>;

constexpr int INFINT = 1 << 30;                          // 1.07x10^ 9

constexpr int INFINT_LIM = (1LL << 31) - 1;              // 2.15x10^ 9

constexpr ll INFLL = 1LL << 60;                          // 1.15x10^18

constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62);  // 9.22x10^18

constexpr double EPS = 1e-7;

constexpr int MOD = 1000000007;

constexpr double PI = 3.141592653589793238462643383279;



ll powMod(ll n, ll p, ll mod) {

	ll res = 1;

	while (p) {

		if (p & 1) {

			res *= n; res %= mod;

		}

		n *= n; n %= mod;

		p >>= 1;

	}

	return res;

}



int dp[41][1 << 18];



signed main() {

	INIT;

	VAR(int, n, x, y, z);

	int len = x + y + z + 1;

	int ans = powMod(10, n, MOD);

	int bad = 0;

	bad |= 1 << (x + y + z);

	bad |= 1 << (0 + y + z);

	bad |= 1 << (0 + 0 + z);

	dp[0][1] = 1;

	REP(i, n) REP(bit, (1 << len)) FOR(d, 1, 11) {

		int b = (bit << d) + 1;

		b &= (1 << len) - 1;

		if ((b&bad) == bad) continue;

		dp[i + 1][b] += dp[i][bit];

		dp[i + 1][b] %= MOD;

	}

	REP(bit, 1 << len) {

		ans += MOD - dp[n][bit];

		ans %= MOD;

	}

	OUT(ans)BR;

	return 0;

}

// Optimized solution to the same problem (faster):
// need

#include <iostream>

#include <algorithm>



// data structure

#include <bitset>

#include <map>

#include <queue>

#include <set>

#include <stack>

#include <string>

#include <utility>

#include <vector>

#include <array>

#include <unordered_map>

#include <complex>

//#include <deque>

#include <valarray>



// stream

//#include <istream>

//#include <sstream>

//#include <ostream>

//#include <fstream>



// etc

#include <cassert>

#include <cmath>

#include <functional>

#include <iomanip>

#include <chrono>

#include <random>

#include <numeric>



// input

#define INIT std::ios::sync_with_stdio(false);std::cin.tie(0);

#define VAR(type, ...)type __VA_ARGS__;MACRO_VAR_Scan(__VA_ARGS__);

template<typename T> void MACRO_VAR_Scan(T& t) { std::cin >> t; }

template<typename First, typename...Rest>void MACRO_VAR_Scan(First& first, Rest&...rest) { std::cin >> first; MACRO_VAR_Scan(rest...); }

#define VEC_ROW(type, n, ...)std::vector<type> __VA_ARGS__;MACRO_VEC_ROW_Init(n, __VA_ARGS__); for(int i=0; i<n; ++i){MACRO_VEC_ROW_Scan(i, __VA_ARGS__);}

template<typename T> void MACRO_VEC_ROW_Init(int n, T& t) { t.resize(n); }

template<typename First, typename...Rest>void MACRO_VEC_ROW_Init(int n, First& first, Rest&...rest) { first.resize(n); MACRO_VEC_ROW_Init(n, rest...); }

template<typename T> void MACRO_VEC_ROW_Scan(int p, T& t) { std::cin >> t[p]; }

template<typename First, typename...Rest>void MACRO_VEC_ROW_Scan(int p, First& first, Rest&...rest) { std::cin >> first[p]; MACRO_VEC_ROW_Scan(p, rest...); }

#define VEC(type, c, n) std::vector<type> c(n);for(auto& i:c)std::cin>>i;

#define MAT(type, c, m, n) std::vector<std::vector<type>> c(m, std::vector<type>(n));for(auto& r:c)for(auto& i:r)std::cin>>i;



// output

#define OUT(d) std::cout<<d;

#define FOUT(n, d) std::cout<<std::fixed<<std::setprecision(n)<<d;

#define SOUT(n, c, d) std::cout<<std::setw(n)<<std::setfill(c)<<d;

#define SP std::cout<<" ";

#define TAB std::cout<<"\t";

#define BR std::cout<<"\n";

#define SPBR(i, n) std::cout<<(i + 1 == n ? '\n' : ' ');

#define ENDL std::cout<<std::endl;

#define FLUSH std::cout<<std::flush;

#define SHOW(d) {std::cerr << #d << "\t:" << d << "\n";}

#define SHOWVECTOR(v) {std::cerr << #v << "\t:";for(const auto& xxx : v){std::cerr << xxx << " ";}std::cerr << "\n";}

#define SHOWVECTOR2(v) {std::cerr << #v << "\t:\n";for(const auto& xxx : v){for(const auto& yyy : xxx){std::cerr << yyy << " ";}std::cerr << "\n";}}

#define SHOWQUEUE(a) {auto tmp(a);std::cerr << #a << "\t:";while(!tmp.empty()){std::cerr << tmp.front() << " ";tmp.pop();}std::cerr << "\n";}



// utility

#define ALL(a) (a).begin(),(a).end()

#define FOR(i, a, b) for(int i=(a);i<(b);++i)

#define RFOR(i, a, b) for(int i=(b)-1;i>=(a);--i)

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

#define RREP(i, n) for(int i=int(n)-1;i>=0;--i)

#define FORLL(i, a, b) for(ll i=ll(a);i<ll(b);++i)

#define RFORLL(i, a, b) for(ll i=ll(b)-1;i>=ll(a);--i)

#define REPLL(i, n) for(ll i=0;i<ll(n);++i)

#define RREPLL(i, n) for(ll i=ll(n)-1;i>=0;--i)

#define IN(a, x, b) (a<=x && x<b)

template<typename T> inline T CHMAX(T& a, const T b) { return a = (a < b) ? b : a; }

template<typename T> inline T CHMIN(T& a, const T b) { return a = (a > b) ? b : a; }

#define EXCEPTION(msg) throw std::string("Exception : " msg " [ in ") + __func__ + " : " + std::to_string(__LINE__) + " lines ]"

#define TRY(cond, msg) try {if (cond) EXCEPTION(msg);}catch (std::string s) {std::cerr << s << std::endl;}

void CHECKTIME(std::function<void()> f) { auto start = std::chrono::system_clock::now(); f(); auto end = std::chrono::system_clock::now(); auto res = std::chrono::duration_cast<std::chrono::nanoseconds>((end - start)).count(); std::cerr << "[Time:" << res << "ns  (" << res / (1.0e9) << "s)]\n"; }



// test

template<class T> std::vector<std::vector<T>> VV(int n) {

	return std::vector<std::vector<T>>(n);

}

template<class T> std::vector<std::vector<T>> VV(int n, int m, T init = T()) {

	return std::vector<std::vector<T>>(n, std::vector<T>(m, init));

}

template<typename S, typename T>

std::ostream& operator<<(std::ostream& os, std::pair<S, T> p) {

	os << "(" << p.first << ", " << p.second << ")"; return os;

}



// type/const



#define int ll

using ll = long long;

using ull = unsigned long long;

using ld = long double;

using PAIR = std::pair<int, int>;

using PAIRLL = std::pair<ll, ll>;

constexpr int INFINT = 1 << 30;                          // 1.07x10^ 9

constexpr int INFINT_LIM = (1LL << 31) - 1;              // 2.15x10^ 9

constexpr ll INFLL = 1LL << 60;                          // 1.15x10^18

constexpr ll INFLL_LIM = (1LL << 62) - 1 + (1LL << 62);  // 9.22x10^18

constexpr double EPS = 1e-9;

constexpr int MOD = 1000000007;

constexpr double PI = 3.141592653589793238462643383279;



ll powMod(ll n, ll p, ll mod) {

	ll res = 1;

	while (p) {

		if (p & 1) res *= n; res %= mod;

		n *= n; n %= mod;

		p >>= 1;

	}

	return res;

}



int dp[42][1 << 17];



signed main() {

	INIT;

	VAR(int, n, x, y, z);

	int K = x + y + z;

	int ans = powMod(10, n, MOD);

	int ng = 0;

	ng |= 1 << (x + y + z - 1);

	ng |= 1 << (0 + y + z - 1);

	ng |= 1 << (0 + 0 + z - 1);

	int mask = (1 << K) - 1;

	dp[0][0] = 1;

	REP(i, n) REP(j, 1 << K) REP(k, 10) {

		int to = (j * 2 + 1) << k;

		to &= mask;

		if ((to&ng) == ng) continue;

		(dp[i + 1][to] += dp[i][j]) %= MOD;

	}

	REP(j, 1 << K) {

		(ans += MOD - dp[n][j]) %= MOD;

	}

	OUT(ans)BR;

	return 0;

}

// Fastest known solution for this problem: