// depends on: -

/*
usage:

tools::pow2(5) => 25
*/

namespace tools {
  template <typename T> constexpr T pow2(const T x) {
    return x * x;
  }
}
// depends on: -

/*
a == tools:quo(a, b) * b + tools::mod(a, b)
0 <= tools::mod(a, b) < std::abs(b)
*/

#include <utility>

namespace tools {
  template <typename T> constexpr T quo(const T lhs, const T rhs) {
    return lhs > 0 ? lhs / rhs : rhs > 0 ? -((-lhs - 1 + rhs) / rhs) : (-lhs - 1 + -rhs) / -rhs;
  }
  template <typename T> constexpr T mod(const T lhs, const T rhs) {
    return lhs - quo(lhs, rhs) * rhs;
  }
}
// depends on: -

/*
usage:

static_assert(tools::is_prime(P), "P must be prime.");
*/

#include <cstdint>
#include <limits>

namespace tools {
  namespace detail {
    namespace is_prime {
      constexpr std::uint_fast32_t mid(const std::uint_fast32_t low, const std::uint_fast32_t high) {
        return (low + high) / 2;
      }

      // precondition: low*low <= n, high*high > n.
      constexpr std::uint_fast32_t ceilsqrt(const std::uint_fast32_t n, const std::uint_fast32_t low, const std::uint_fast32_t high) {
        return low + 1 >= high
          ? high
          : (mid(low, high) * mid(low, high) == n)
          ? mid(low, high)
          : (mid(low, high) * mid(low, high) <  n)
          ? ceilsqrt(n, mid(low, high), high)
          : ceilsqrt(n, low, mid(low, high));
      }

      // returns ceiling(sqrt(n))
      constexpr std::uint_fast32_t ceilsqrt(const std::uint_fast32_t n) {
        return n < 3
          ? n
          : ceilsqrt(n, 1, std::uint_fast32_t(1) << (std::numeric_limits<std::uint_fast32_t>::digits / 2));
      }

      // returns true if n is divisible by an odd integer in
      // [2 * low + 1, 2 * high + 1).
      constexpr bool find_factor(const std::uint_fast32_t n, const std::uint_fast32_t low, const std::uint_fast32_t high) {
        return low + 1 >= high
          ? (n % (2 * low + 1)) == 0
          : (find_factor(n, low, mid(low, high)) || find_factor(n, mid(low, high), high));
      }
    }
  }

  constexpr bool is_prime(const std::uint_fast32_t n) {
    return n > 1
      && (n == 2
        || (n % 2 == 1
          && (n == 3
            || !detail::is_prime::find_factor(n, 1, (detail::is_prime::ceilsqrt(n) + 1) / 2))));
  }
}
// depends on: is_prime.cpp, quo_and_mod.cpp, pow2.cpp

/*
usage:

constexpr const std::uint_fast32_t p = 3;
tools::int_mod<p>(5) + tools::int_mod<p>(4) // => 0
*/

#include <cstdint>
#include <stdexcept>

namespace tools {
  template <std::uint_fast32_t P> class int_mod {
    static_assert(is_prime(P), "P must be prime.");

  private:
    std::uint_fast32_t m_value;

    constexpr static std::uint_fast32_t add_impl(const std::uint_fast32_t lhs, const std::uint_fast32_t rhs) {
      return (lhs + rhs) % P;
    }

    constexpr static std::uint_fast32_t sub_impl(const std::uint_fast32_t lhs, const std::uint_fast32_t rhs) {
      return (lhs - rhs + P) % P;
    }

    constexpr static std::uint_fast32_t mul_impl(const std::uint_fast32_t lhs, const std::uint_fast32_t rhs) {
      return static_cast<std::uint_fast32_t>(static_cast<std::uint_fast64_t>(lhs) * static_cast<std::uint_fast64_t>(rhs) % static_cast<std::uint_fast64_t>(P));
    }

    constexpr int_mod<P> pow_impl(const std::uint_fast32_t exponent) const {
      return exponent == 0
        ? int_mod<P>(1)
        : exponent % 2 == 0
          ? pow2(this->pow_impl(exponent / 2))
          : this->pow_impl(exponent - 1) * *this;
    }

  public:
    int_mod() :
      m_value(0) {
    }

    int_mod(const std::int_fast32_t value) :
      m_value(static_cast<std::uint_fast32_t>(mod(value, static_cast<std::int_fast32_t>(P)))) {
    }

    int_mod(const int_mod<P>& other) :
      int_mod(other.m_value) {
    }

    constexpr operator std::uint_fast32_t() const {
      return m_value;
    }

    constexpr friend int_mod<P> operator+(const int_mod<P>& lhs, const int_mod<P>& rhs) {
      return int_mod<P>(int_mod<P>::add_impl(lhs.m_value, rhs.m_value));
    }

    int_mod<P>& operator+=(const int_mod<P>& other) {
      m_value = int_mod<P>::add_impl(m_value, other.m_value);
      return *this;
    }

    constexpr friend int_mod<P> operator-(const int_mod<P>& lhs, const int_mod<P>& rhs) {
      return int_mod<P>(int_mod<P>::sub_impl(lhs.m_value, rhs.m_value));
    }

    int_mod<P>& operator-=(const int_mod<P>& other) {
      m_value = int_mod<P>::sub_impl(m_value, other.m_value);
      return *this;
    }

    constexpr friend int_mod<P> operator*(const int_mod<P>& lhs, const int_mod<P>& rhs) {
      return int_mod<P>(int_mod<P>::mul_impl(lhs.m_value, rhs.m_value));
    }

    int_mod<P>& operator*=(const int_mod<P>& other) {
      m_value = int_mod<P>::mul_impl(m_value, other.m_value);
      return *this;
    }

    constexpr int_mod<P> inv() const {
      return m_value > 0
        ? this->pow_impl(P - 2)
        : (throw std::invalid_argument("cannot divide by zero"));
    }

    constexpr int_mod<P> pow(const std::int_fast32_t exponent) const {
      return exponent >= 0
        ? this->pow_impl(static_cast<std::uint_fast32_t>(exponent))
        : this->pow_impl(static_cast<std::uint_fast32_t>(-exponent)).inv();
    }

    constexpr friend int_mod<P> operator/(const int_mod<P>& lhs, const int_mod<P>& rhs) {
      return lhs * rhs.inv();
    }

    int_mod<P>& operator/=(const int_mod<P>& other) {
      m_value = int_mod<P>::mul_impl(m_value, other.inv().m_value);
      return *this;
    }
  };
}
#include <iostream>
#include <cstdint>
#include <unordered_map>
#include <utility>

#include <bitset>

constexpr const std::uint_fast32_t P = 1000000007u;

std::uint_fast32_t calc_next_state(
  const std::uint_fast32_t state,
  const std::uint_fast32_t next_term
) {
  return (state << next_term) | (1u << (next_term - 1u));
}
tools::int_mod<P> calc_case_count_sub(
  std::uint_fast32_t state,
  std::uint_fast32_t left_term_count,
  std::uint_fast32_t xyz_mask,
  std::uint_fast32_t state_mask,
  std::uint_fast32_t next_term
);
tools::int_mod<P> calc_case_count(
  const std::uint_fast32_t state,
  const std::uint_fast32_t left_term_count,
  const std::uint_fast32_t xyz_mask,
  const std::uint_fast32_t state_mask
) {
  static std::unordered_map<std::uint_fast32_t, tools::int_mod<P>> cache;
  const auto iterator = cache.find((left_term_count << 16u) | state);
  if (iterator != cache.end()) {
    return iterator->second;
  }
  const tools::int_mod<P> case_count = left_term_count == 0u
    ? tools::int_mod<P>(1)
    : calc_case_count_sub(state, left_term_count, xyz_mask, state_mask, 1u)
    + calc_case_count_sub(state, left_term_count, xyz_mask, state_mask, 2u)
    + calc_case_count_sub(state, left_term_count, xyz_mask, state_mask, 3u)
    + calc_case_count_sub(state, left_term_count, xyz_mask, state_mask, 4u)
    + calc_case_count_sub(state, left_term_count, xyz_mask, state_mask, 5u)
    + calc_case_count_sub(state, left_term_count, xyz_mask, state_mask, 6u)
    + calc_case_count_sub(state, left_term_count, xyz_mask, state_mask, 7u)
    + calc_case_count_sub(state, left_term_count, xyz_mask, state_mask, 8u)
    + calc_case_count_sub(state, left_term_count, xyz_mask, state_mask, 9u)
    + calc_case_count_sub(state, left_term_count, xyz_mask, state_mask, 10u);
  cache.insert(std::make_pair((left_term_count << 16u) | state, case_count));
  return case_count;
}
tools::int_mod<P> calc_case_count_sub(
  const std::uint_fast32_t state,
  const std::uint_fast32_t left_term_count,
  const std::uint_fast32_t xyz_mask,
  const std::uint_fast32_t state_mask,
  const std::uint_fast32_t next_term
) {
  const std::uint_fast32_t next_state = calc_next_state(state, next_term);
  return (next_state & xyz_mask) == xyz_mask ? tools::int_mod<P>(0) : calc_case_count(next_state & state_mask, left_term_count - 1u, xyz_mask, state_mask);
}

int main() {
  std::uint_fast32_t n, x, y, z;
  std::cin >> n >> x >> y >> z;
  const tools::int_mod<P> case_count = calc_case_count(0u, n, (1u << (x + y + z - 1u)) | (1u << (y + z - 1u)) | (1u << (z - 1u)), (1u << (x + y + z - 1u)) - 1u);
  std::cout << static_cast<std::uint_fast32_t>(tools::int_mod<P>(10).pow(n) - case_count) << std::endl;
  return 0;
}

Measured memory_bytes: 118096