//#define NDEBUG #include #include #include #include namespace n91 { using i8 = std::int_fast8_t; using i32 = std::int_fast32_t; using i64 = std::int_fast64_t; using u8 = std::uint_fast8_t; using u32 = std::uint_fast32_t; using u64 = std::uint_fast64_t; using isize = std::ptrdiff_t; using usize = std::size_t; constexpr usize operator"" _z(unsigned long long x) noexcept { return static_cast(x); } class rep { const usize f, l; public: class itr { friend rep; usize i; constexpr itr(const usize x) noexcept : i(x) {} public: void operator++() noexcept { ++i; } constexpr usize operator*() const noexcept { return i; } constexpr bool operator!=(const itr x) const noexcept { return i != x.i; } }; constexpr rep(const usize first, const usize last) noexcept : f(first), l(last) {} constexpr itr begin() const noexcept { return itr(f); } constexpr itr end() const noexcept { return itr(l); } }; class revrep { const usize f, l; public: class itr { friend revrep; usize i; constexpr itr(usize x) noexcept : i(x) {} public: void operator++() noexcept { --i; } constexpr usize operator*() const noexcept { return i; } constexpr bool operator!=(const itr x) const noexcept { return i != x.i; } }; constexpr revrep(usize first, usize last) noexcept : f(--first), l(--last) {} constexpr itr begin() const noexcept { return itr(l); } constexpr itr end() const noexcept { return itr(f); } }; template using vec_alias = std::vector; template auto md_vec(const usize n, const T& value) { return std::vector(n, value); } template auto md_vec(const usize n, Args... args) { return std::vector(n, md_vec(args...)); } template constexpr T difference(const T& a, const T& b) { return a < b ? b - a : a - b; } template T scan() { T ret; std::cin >> ret; return ret; } } // namespace n91 #include namespace n91 { constexpr std::uint_fast64_t totient(std::uint_fast64_t x) noexcept { using u64 = std::uint_fast64_t; u64 ret = x; for (u64 i = static_cast(2); i * i <= x; ++i) { if (x % i == static_cast(0)) { ret -= ret / i; x /= i; while (x % i == static_cast(0)) { x /= i; } } } if (x != static_cast(1)) { ret -= ret / x; } return ret; } template (1)> class modint { using u64 = std::uint_fast64_t; static_assert(Modulus < static_cast(1) << static_cast(32), "Modulus must be less than 2**32"); u64 a; constexpr modint& negate() noexcept { if (a != static_cast(0)) { a = Modulus - a; } return *this; } public: constexpr modint(const u64 x = static_cast(0)) noexcept : a(x% Modulus) {} constexpr u64& value() noexcept { return a; } constexpr const u64& value() const noexcept { return a; } constexpr modint operator+() const noexcept { return modint(*this); } constexpr modint operator-() const noexcept { return modint(*this).negate(); } constexpr modint operator+(const modint rhs) const noexcept { return modint(*this) += rhs; } constexpr modint operator-(const modint rhs) const noexcept { return modint(*this) -= rhs; } constexpr modint operator*(const modint rhs) const noexcept { return modint(*this) *= rhs; } constexpr modint operator/(const modint rhs) const noexcept { return modint(*this) /= rhs; } constexpr modint& operator+=(const modint rhs) noexcept { a += rhs.a; if (a >= Modulus) { a -= Modulus; } return *this; } constexpr modint& operator-=(const modint rhs) noexcept { if (a < rhs.a) { a += Modulus; } a -= rhs.a; return *this; } constexpr modint& operator*=(const modint rhs) noexcept { a = a * rhs.a % Modulus; return *this; } constexpr modint& operator/=(modint rhs) noexcept { u64 exp = InverseExp; while (exp) { if (exp % static_cast(2) != static_cast(0)) { *this *= rhs; } rhs *= rhs; exp /= static_cast(2); } return *this; } constexpr bool operator==(const modint rhs) const noexcept { return a == rhs.a; } constexpr bool operator!=(const modint rhs) const noexcept { return a != rhs.a; } }; template class modint_constant { public: static constexpr T value = static_cast(v); using value_type = T; }; } // namespace n91 #include #include #include #include namespace n91 { class prime_sieve { public: using size_type = std::size_t; private: std::vector prime, factor; public: prime_sieve() {} explicit prime_sieve(const size_type size) : prime(), factor(size, 0) { assert(size >= 2); factor[0] = 1; for (size_type i{ 2 }; i != size; ++i) { const size_type fi = factor[i]; if (fi == 0) { factor[i] = i; prime.push_back(i); } for (const size_type p : prime) { if (p > fi) { break; } const size_type ip = i * p; if (ip >= size) { break; } factor[ip] = p; } } } size_type len() const noexcept { return factor.size(); } bool is_prime(const size_type i) const noexcept { assert(i < len()); return factor[i] == i; } std::vector factorize(size_type i) const noexcept { assert(i != 0); std::vector ret; while (i != 1) { ret.push_back(factor[i]); i /= factor[i]; } return std::move(ret); } template void divisor_zeta(C& c) const noexcept { const size_type n{ c.size() }; assert(n <= len()); for (size_type i{ 0 }; i != prime.size() && prime[i] < n; ++i) { for (size_type j{ 1 }; j * prime[i] < n; ++j) { c[j * prime[i]] += c[j]; } } } template void divisor_mobius(C& c) const noexcept { const size_type n{ c.size() }; assert(n <= len()); for (size_type i{ 0 }; i != prime.size() && prime[i] < n; ++i) { for (size_type j{ (n - 1) / prime[i] }; j != 0; --j) { c[j * prime[i]] -= c[j]; } } } template void multiple_zeta(C& c) const noexcept { const size_type n{ c.size() }; assert(n <= len()); for (size_type i{ 0 }; i != prime.size() && prime[i] < n; ++i) { for (size_type j{ (n - 1) / prime[i] }; j != 0; --j) { c[j] += c[j * prime[i]]; } } } template void multiple_mobius(C& c) const noexcept { const size_type n{ c.size() }; assert(n <= len()); for (size_type i{ 0 }; i != prime.size() && prime[i] < n; ++i) { for (size_type j{ 1 }; j * prime[i] < n; ++j) { c[j] -= c[j * prime[i]]; } } } }; } // namespace n91 #include #include #include #include #include #include namespace n91 { constexpr usize lm(const usize a, const usize b) { if (b < a) { return a - b; } else { return 0_z; } } void main_() { using mint = modint(1000000007)>; const usize h = scan(); const usize w = scan(); const usize n = std::max({ h, w, 2_z }); std::vector a(n), b(n); for (const auto i : rep(1_z, n)) { a[i] = lm(h, i); b[i] = lm(w, i); } const prime_sieve ps{ n }; ps.multiple_zeta(a); ps.multiple_zeta(b); for (const auto i : rep(0_z, n)) { a[i] *= b[i]; } ps.multiple_mobius(a); mint ans = a[1_z] * static_cast(2); mint h_ = static_cast(h); mint w_ = static_cast(w); ans += (h_ - static_cast(1)) * w_ + h_ * (w_ - static_cast(1)); std::cout << ans.value() << std::endl; } } // namespace n91 int main() { n91::main_(); return 0; }