#include<bits/stdc++.h>

#define int long long
const int inf = 1e18;
const int INF = 2e9;

//#pragma warning(disable:4235)
//#pragma warning(disable:4996)
//#include <__msvc_int128.hpp>
//using int128_t = std::_Signed128;
//using uint128_t = std::_Unsigned128;
//using __int128_t = std::_Signed128;
#pragma GCC optimize(2)
#pragma GCC optimize(3)


using ll = long long;
using ull = unsigned long long;
using i64 = long long;


template<typename T, typename R>
std::ostream& operator<<(std::ostream& os, const std::pair<T, R>& p) {
	os << "(" << p.first << "," << p.second << ") ";
	return os;
}

void debug() {
	std::cout << "******************************debug()******************************\n";
}

template<typename T>
void debug(T x, std::string name = "x") {
	std::cerr << name << "=" << x << std::endl;
}

template<typename T>
void debug(const std::vector<T>& v, const std::string& name = "vec", size_t N = 0) {
	for (size_t i = 0; i < v.size(); ++i) {
		std::cerr << name << "[" << i << "] = " << v[i] << std::endl;
	}
}
using namespace std;
template<typename T, size_t N>
void debug(const std::vector<std::array<T, N>>& v, const std::string& name = "vec") {
	for (size_t i = 0; i < v.size(); ++i) {
		for (size_t j = 0; j < N; ++j) {
			std::cerr << name << "[" << i << "][" << j << "] = " << v[i][j] << " ";
		}
		std::cerr << std::endl << std::endl;
	}
}
using pii = std::pair<int, int>;

const int N = 6e4 + 10;

const int mod = 1e9 + 9;

template<const int T>
struct ModInt {
    const static int mod = T;
    int x;
    ModInt(signed x = 0) : x(x% mod) {}
    ModInt(long long x) : x((long long)(x% mod)) {}
    int val() { return x; }
    ModInt operator + (const ModInt& a) const { int x0 = x + a.x; return ModInt(x0 < mod ? x0 : x0 - mod); }
    ModInt operator - (const ModInt& a) const { int x0 = x - a.x; return ModInt(x0 < 0 ? x0 + mod : x0); }
    ModInt operator * (const ModInt& a) const { return ModInt(1LL * x * a.x % mod); }
    ModInt operator / (const ModInt& a) const { return *this * a.inv(); }
    bool operator == (const ModInt& a) const { return x == a.x; };
    bool operator != (const ModInt& a) const { return x != a.x; };
    void operator += (const ModInt& a) { x += a.x; if (x >= mod) x -= mod; }
    void operator -= (const ModInt& a) { x -= a.x; if (x < 0) x += mod; }
    void operator *= (const ModInt& a) { x = 1LL * x * a.x % mod; }
    void operator /= (const ModInt& a) { *this = *this / a; }
    friend ModInt operator + (int y, const ModInt& a) { int x0 = y + a.x; return ModInt(x0 < mod ? x0 : x0 - mod); }
    friend ModInt operator - (int y, const ModInt& a) { int x0 = y - a.x; return ModInt(x0 < 0 ? x0 + mod : x0); }
    friend ModInt operator * (int y, const ModInt& a) { return ModInt(1LL * y * a.x % mod); }
    friend ModInt operator / (int y, const ModInt& a) { return ModInt(y) / a; }
    friend std::ostream& operator<<(std::ostream& os, const ModInt& a) { return os << a.x; }
    friend std::istream& operator>>(std::istream& is, ModInt& t) { return is >> t.x; }

    ModInt pow(int64_t n) const {
        ModInt res(1), mul(x);
        while (n) {
            if (n & 1) res *= mul;
            mul *= mul;
            n >>= 1;
        }
        return res;
    }

    ModInt inv() const {
        int a = x, b = mod, u = 1, v = 0;
        while (b) {
            int t = a / b;
            a -= t * b; std::swap(a, b);
            u -= t * v; std::swap(u, v);
        }
        if (u < 0) u += mod;
        return u;
    }

};

using mint = ModInt<1000000009>;

void solve() {
    int n, m;
    std::cin >> m >> n;

    mint res = 0, sum = 1, v = 0;
    for (int i = 1; i <= n; ++i) {
        res += (v + 1) * m;

        v = ((v + 1) * m + (sum - 1) * v) * mint(sum + m - 1).inv();
        sum = sum - 1 + m;
    }

    std::cout << res << "\n";

}

signed main() {
	std::ios::sync_with_stdio(0);
	std::cin.tie(0);
	std::cout.tie(0);

	int t = 1;
	//std::cin >> t;

	while (t--) {
		solve();
	}
}