#include <iostream>
#include <iomanip>
#include <algorithm>
#include <string>
#include <vector>
#include <map>
#include <set>
#include <cstdio>
#include <cstring>
using namespace std;

template <int64_t M>
class mint {
public:
        mint() :v(-1) {}
        mint(int n) : v(n % M) {}

        int64_t get() const { return v; }

        mint &operator+=(const mint &r) {
                v = (v + r.v) % M;
                return *this;
        }
        mint &operator-=(const mint &r) {
                v = (v - r.v + M) % M;
                return *this;
        }
        mint &operator*=(const mint &r) {
                v = (v * r.v) % M;
                return *this;
        }
        mint &operator/=(const mint &r) {
                return (*this) *= r.inv();
        }

        mint pow(int r) const {
                mint k = *this, ret = 1;
                while (r > 0) {
                        if (r % 2 != 0) ret *= k;
                        r /= 2;
                        k *= k;
                }
                return ret;
        }

        mint inv() const {
                return pow(M - 2);
        }

private:
        int64_t v;
};

template <int64_t M>
inline mint<M> operator+(mint<M> l, const mint<M> &r) {
        return l += r;
}

template <int64_t M>
inline mint<M> operator-(mint<M> l, const mint<M> &r) {
        return l -= r;
}

template <int64_t M>
inline mint<M> operator*(mint<M> l, const mint<M> &r) {
        return l *= r;
}

template <int64_t M>
inline mint<M> operator/(mint<M> l, const mint<M> &r) {
        return l /= r;
}

template <int64_t M>
inline ostream &operator<<(ostream &os, const mint<M> &r) {
        return os << r.get();
}

typedef mint<1000000007> MINT;

int n, ls[3];

// bool flg[41][5][8];
// MINT tbl[41][5][8];

// MINT solve(int pos, int ph, int acc)
// {
//     if (ph == 0 || ph == 4) acc = 0;

//     if (ph >= 1 && ph <= 3 && ls[ph-1] < acc) {
//         return 0;
//     }

//     if (ph >= 1 && ph <= 3 && ls[ph-1] == acc) {
//         return solve(pos, ph+1, 0);
//     }

//     if (pos >= n) {
//         return (ph == 4) ? 1 : 0;
//     }

//     MINT &ret = tbl[pos][ph][acc];
//     if (flg[pos][ph][acc]) return ret;

//     cout << pos << ", " << ph << ", " << acc << endl;

//     ret = 0;

//     // if (ph == 0) ret += solve(pos, ph+1, 0);

//     for (int i = 1; i <= 10; i++) {
//         if (ph == 0) {
//             ret += solve(pos + 1, ph, 0);
//             ret += solve(pos + 1, ph + 1, i);
//         } else {
//             ret += solve(pos + 1, ph, acc + i);
//         }
//     }

//     flg[pos][ph][acc] = true;
//     return ret;
// }

// MINT tbl[41][1000000];

// MINT solve(int pos, int prev)
// {
//     // cout << pos << ", " << prev << endl;

//     if (pos > n) return 0;

//     int ttt = prev, nc = pos;
//     bool ok = true;
//     for (int i = 0; i < 3; i++) {
//         int r = ls[2-i];

//         while (nc > 0 && r > 0) {
//             int d = ttt % 10 + 1;
//             ttt /= 10;
//             nc--;
//             r -= d;
//         }

//         if (r != 0) {
//             ok = false;
//             break;
//         }
//     }

//     if (ok) {
//         MINT ret = 1;
//         for (int i = pos; i < n; i++) ret *= 10;
//         // cout << "* " << pos << ", " << prev << " = " << ret << endl;
//         return ret;
//     }

//     MINT &ret = tbl[pos][prev];
//     if (ret.get() >= 0) return ret;

//     ret = 0;
//     for (int i = 1; i <= 10; i++) {
//         ret += solve(pos + 1, (prev * 10 + i - 1) % 1000000);
//     }

//     return ret;
// }

MINT tbl[2][1 << 18];

int trans[18][10];
int trans2[1<<18][10];

int main()
{
    cin >> n >> ls[0] >> ls[1] >> ls[2];

    int s1 = 0;
    int s2 = ls[0];
    int s3 = ls[0] + ls[1];
    int se = ls[0] + ls[1] + ls[2];

    for (int st = 0; st < 18; st++) {
        for (int d = 1; d <= 10; d++) {
            int next = 1;

            if (st < s2) {
                int ofs = st + d;
                if (ofs <  ls[0]) next |= (1 << (s1 + ofs));
                if (ofs == ls[0]) next |= (1 << s2);

            } else if (st >= s2 && st < s3) {
                int ofs = st - s2 + d;
                if (ofs <  ls[1]) next |= (1 << (s2 + ofs));
                if (ofs == ls[1]) next |= (1 << s3);

            } else if (st >= s3 && st < se) {
                int ofs = st - s3 + d;
                if (ofs <  ls[2]) next |= (1 << (s3 + ofs));
                if (ofs == ls[2]) next |= (1 << se);

            } else {
                next |= (1 << st);
            }

            // cout << st << ", " << d << " -> " << next << endl;

            trans[st][d-1] = next;
        }
    }

    for (int b = 0; b < (1<<18); b++) {
        for (int d = 1; d <= 10; d++) {
            trans2[b][d-1] = 0;

            for (int st = 0; st < 18; st++) {
                if (b & (1 << st)) {
                    trans2[b][d-1] |= trans[st][d-1];
                }
            }
        }
    }

    memset(tbl, 0, sizeof(tbl));
    tbl[0][1] = 1;
    int cur = 0;

    for (int i = 0; i < n; i++) {
        memset(tbl[cur^1], 0, sizeof(tbl[0]));

        for (int b = 0; b < (1<<18); b++) {
            for (int d = 1; d <= 10; d++) {
                tbl[cur^1][trans2[b][d-1]] += tbl[cur][b];
            }
        }

        cur ^= 1;
    }

    MINT ans = 0;
    for (int b = 0; b < (1<<18); b++) {
        if (b & (1 << se)) {
            ans += tbl[cur][b];
        }
    }

    cout << ans << endl;

    return 0;
}

Measured memory_bytes: 14592