#pragma GCC optimize("Ofast")
  #include "bits/stdc++.h"
  using namespace std;
  #include <ext/pb_ds/assoc_container.hpp>
  #include <ext/pb_ds/tree_policy.hpp>
  using namespace __gnu_pbds;
  /*
              common mistakes
            1) long long vs int overflow
            2) read question carefully please!!!! it can cost you a lot
            3) unorderedmap is O(1) look up but worst case can be bad
            4) maps have higher constant so many lookups can cause TLE
            5) leaving debugs or cerrs in the program at times can cause TLE
  */
  #define IOS { ios :: sync_with_stdio(false); cin.tie(0); cout.tie(0); }
  #define umapii unordered_map <int,int>
  #define umapll unordered_map<ll,ll>
  #define mapll map<ll,ll>
  #define mapii map<int,int>
  #define ll long long
  #define pi pair<int,int>
  #define pll pair<ll,ll>
  #define pb push_back
  #define eb emplace_back
  #define fi first
  #define se second
  #define vs vector<string>
  #define vi vector<int>
  #define vll vector<ll>
  #define vpi vector<pi>
  #define vpll vector<pll>
  #define vvi vector<vi>
  #define vvll vector<vll>
  #define all(v) (v).begin(),(v).end()
  #define FOR(i,a,b) for(int i=a;i<=b;i++)
  #define MP(a,b) make_pair(a,b)
  #define debug(x)       cerr<< #x <<" : "<< x << endl;
  #define debuga(A,N)    cerr<< #A <<" : [";for(int i = 0; i<N;i++) cerr<<A[i]<<" "; cerr<<"]\n";
  #define debuga2(A,N,M) cerr<< #A << " : \n"; for(int i=0;i<N;i++){cerr<<"[";for(int j=0;j<M;++j) cerr<<A[i][j]<<" ";cerr<<"]\n";}
  #define debugp(p)      cerr<< #p <<" : "<<"("<<(p).first<<","<<(p).second<<")\n";
  #define debugv(v)      cerr<< #v <<" : "<<"[";for(int i = 0; i< (v).size(); i++) cerr<<v[i]<<" "; cerr<<"]\n";
  #define debugv2(v)     cerr<< #v << " : \n"; for(int i=0;i<v.size();i++){cerr<<"[";for(int j=0;j<(v[0].size());++j) cerr<<v[i][j]<<" ";cerr<<"]\n";}
  #define debugs(m)      cerr<< #m <<" : [ "; for(auto itr = m.begin(); itr!=m.end();itr++) cerr<<*itr<<" "; cerr<<"]\n";
  #define debugm(m)      cerr<< #m <<" : [ "; for(auto itr = m.begin();itr!=m.end(); itr++) cerr<<"("<<itr->first<<","<<itr->second<<") ";cerr<<"]\n";

  /*STL:
        (1) PRIORITY_QUEUE pq:
        -> priority_queue < int > pq; // max_heap
        -> priority_queue < int , vector < int > , greater < int > > pq; // min_heap 
        -> pq.top()   --> returns the maximum or minimum element
        -> pq.push()  --> push element into the queue
        -> pq.pop()   --> remove top most element
        -> pq.empty() --> checks whether queue is empty or not

        (2) set / multiset  ss; 
        --> ss.insert(key); (insertion)
        --> ss.erase(ss.find(key)) .. (deletion)
        --> ss.find(key) != ss.end() ..existence check
        --> ss.lower_bound(x) -> smallest value which is greater than or equals to x
        --> ss.upper_bound(x) --> first value strictly greater than x
      
        (3) common functions
        lower_bound(v.begin(),v.end(),x) - v.begin() --> smallest value greater than or equals to x
        upper_bound(v.begin(), v.end(),x)- v.begin() --> smallest value greater than x
        memset(dp , val , sizeof(dp)) -> sets the value of array dp to val
  */

  template <typename T>
  class Modular {
  public:
    using Type = typename decay<decltype(T::value)>::type;
  
    constexpr Modular() : value() {}
    template <typename U>
    Modular(const U& x) {
      value = normalize(x);
    }
  
    template <typename U>
    static Type normalize(const U& x) {
      Type v;
      if (-mod() <= x && x < mod()) v = static_cast<Type>(x);
      else v = static_cast<Type>(x % mod());
      if (v < 0) v += mod();
      return v;
    }
  
    const Type& operator()() const { return value; }
    template <typename U>
    explicit operator U() const { return static_cast<U>(value); }
    constexpr static Type mod() { return T::value; }
    Modular& operator+=(const Modular& other) { if ((value += other.value) >= mod()) value -= mod(); return *this; }
    Modular& operator-=(const Modular& other) { if ((value -= other.value) < 0) value += mod(); return *this; }
    template <typename U> Modular& operator+=(const U& other) { return *this += Modular(other); }
    template <typename U> Modular& operator-=(const U& other) { return *this -= Modular(other); }
    Modular& operator++() { return *this += 1; }
    Modular& operator--() { return *this -= 1; }
    Modular operator++(int) { Modular result(*this); *this += 1; return result; }
    Modular operator--(int) { Modular result(*this); *this -= 1; return result; }
    Modular operator-() const { return Modular(-value); }
  
    template <typename U = T>
    typename enable_if<is_same<typename Modular<U>::Type, int>::value, Modular>::type& operator*=(const Modular& rhs) {
  #ifdef _WIN32
      uint64_t x = static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value);
      uint32_t xh = static_cast<uint32_t>(x >> 32), xl = static_cast<uint32_t>(x), d, m;
      asm(
        "divl %4; \n\t"
        : "=a" (d), "=d" (m)
        : "d" (xh), "a" (xl), "r" (mod())
      );
      value = m;
  #else
      value = normalize(static_cast<int64_t>(value) * static_cast<int64_t>(rhs.value));
  #endif
      return *this;
    }
    template <typename U = T>
    typename enable_if<is_same<typename Modular<U>::Type, int64_t>::value, Modular>::type& operator*=(const Modular& rhs) {
      int64_t q = static_cast<int64_t>(static_cast<long double>(value) * rhs.value / mod());
      value = normalize(value * rhs.value - q * mod());
      return *this;
    }
    template <typename U = T>
    typename enable_if<!is_integral<typename Modular<U>::Type>::value, Modular>::type& operator*=(const Modular& rhs) {
      value = normalize(value * rhs.value);
      return *this;
    }
  
    Modular& operator/=(const Modular& other) { return *this *= Modular(inverse(other.value, mod())); }
  
    template <typename U>
    friend const Modular<U>& abs(const Modular<U>& v) { return v; }
  
    template <typename U>
    friend bool operator==(const Modular<U>& lhs, const Modular<U>& rhs);
  
    template <typename U>
    friend bool operator<(const Modular<U>& lhs, const Modular<U>& rhs);
  
    template <typename U>
    friend std::istream& operator>>(std::istream& stream, Modular<U>& number);
  
  private:
    Type value;
  };
  
  template <typename T> bool operator==(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value == rhs.value; }
  template <typename T, typename U> bool operator==(const Modular<T>& lhs, U rhs) { return lhs == Modular<T>(rhs); }
  template <typename T, typename U> bool operator==(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) == rhs; }
  
  template <typename T> bool operator!=(const Modular<T>& lhs, const Modular<T>& rhs) { return !(lhs == rhs); }
  template <typename T, typename U> bool operator!=(const Modular<T>& lhs, U rhs) { return !(lhs == rhs); }
  template <typename T, typename U> bool operator!=(U lhs, const Modular<T>& rhs) { return !(lhs == rhs); }
  
  template <typename T> bool operator<(const Modular<T>& lhs, const Modular<T>& rhs) { return lhs.value < rhs.value; }
  
  template <typename T> Modular<T> operator+(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }
  template <typename T, typename U> Modular<T> operator+(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) += rhs; }
  template <typename T, typename U> Modular<T> operator+(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) += rhs; }
  
  template <typename T> Modular<T> operator-(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }
  template <typename T, typename U> Modular<T> operator-(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) -= rhs; }
  template <typename T, typename U> Modular<T> operator-(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) -= rhs; }
  
  template <typename T> Modular<T> operator*(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }
  template <typename T, typename U> Modular<T> operator*(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) *= rhs; }
  template <typename T, typename U> Modular<T> operator*(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) *= rhs; }
  
  template <typename T> Modular<T> operator/(const Modular<T>& lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }
  template <typename T, typename U> Modular<T> operator/(const Modular<T>& lhs, U rhs) { return Modular<T>(lhs) /= rhs; }
  template <typename T, typename U> Modular<T> operator/(U lhs, const Modular<T>& rhs) { return Modular<T>(lhs) /= rhs; }

  template<typename T, typename U>
  Modular<T> power(const Modular<T>& a, const U& b) {
    assert(b >= 0);
    Modular<T> x = a, res = 1;
    U p = b;
    while (p > 0) {
      if (p & 1) res *= x;
      x *= x;
      p >>= 1;
    }
    return res;
  }
  template <typename T>
  bool IsZero(const Modular<T>& number) {
    return number() == 0;
  }
  template <typename T>
  string to_string(const Modular<T>& number) {
    return to_string(number());
  }
  template <typename T>
  std::ostream& operator<<(std::ostream& stream, const Modular<T>& number) {
    return stream << number();
  }
  template <typename T>
  std::istream& operator>>(std::istream& stream, Modular<T>& number) {
    typename common_type<typename Modular<T>::Type, int64_t>::type x;
    stream >> x;
    number.value = Modular<T>::normalize(x);
    return stream;
  }
  constexpr int md = 1000000007;
  using Mint = Modular<std::integral_constant<decay<decltype(md)>::type, md>>;

  ll modexp(ll x, ll ex) {
      ll ans = 1ll;
      while (ex > 0) {
          if (ex & 1ll) ans = (ans * x) % md;
          ex >>= 1ll;
          x = (x * x) % md;
      }
      return ans;
  }

  const int inf = 1e9 + 7;

  int main(){
      IOS;
      int n , m;
      cin >> n >> m;
      cout << (n * (n - 1) /2 + (m * (m - 1) / 2)) << '\n';
  }


Measured memory_bytes: 256