#include <iostream>
#include <vector>
#include <numeric>
#include <algorithm>
#include <climits>

constexpr int SINT_MAX = std::numeric_limits<int>::max();
constexpr int SINT_MIN = std::numeric_limits<int>::min();

using namespace std;
using vi = vector<int>;
using vvi = vector<vi>;
using ll = long long;
using vll = vector<ll>;
using vvll = vector<vll>;

template<class T>
T choose(bool b, T t, T f)
{
    if (b) return t;
    else return f;    
}

const char *YesNo(bool b)
{
    return choose(b, "Yes", "No");
}

const char *YESNO(bool b)
{
    return choose(b, "YES", "NO");
}

template<class NumT>
NumT diffabs(NumT l, NumT r)
{
    if (l < r) return r-l;
    else return l-r;    
}

struct myinout_t {} io;

template<class T>
myinout_t &operator >>(myinout_t &my, T &i)
{
    cin >> i;
    return my;
}

myinout_t &operator >>(myinout_t &my, int &i)
{
    int r = scanf("%d", &i);
    if (r != 1) exit(EXIT_FAILURE);
    return my;
}

myinout_t &operator >>(myinout_t &my, ll &i)
{
    int r = scanf("%lld", &i);
    if (r != 1) exit(EXIT_FAILURE);
    return my;
}

template<class T>
myinout_t &operator <<(myinout_t &my, const T &i)
{
    cout << i;
    return my;
}

myinout_t &operator <<(myinout_t &my, int i)
{
    printf("%d", i);
    return my;
}

myinout_t &operator <<(myinout_t &my, ll i)
{
    printf("%lld", i);
    return my;
}

myinout_t &operator <<(myinout_t &my, double i)
{
    printf("%.20f", i);
    return my;
}

constexpr char BR = '\n';


///////////////////////////////////////////////////

const int MAX_N = 60;         // n の最大値
vector<vector<long long>> com;  // 前計算の結果を保存
void bi_init() {
    com.assign(MAX_N, vector<long long>(MAX_N));
    com[0][0] = 1;
    for (int i = 1; i < MAX_N; ++i) {
        com[i][0] = 1;
        for (int j = 1; j < MAX_N; j++) {
            com[i][j] = (com[i - 1][j - 1] + com[i - 1][j]);
        }
    }
}
long long bi(int n, int k) {
    return com[n][k];
}
ll hbi(int n, int m)
{
    return bi(n+m, m);
}

vector<char> f(int rest_a, int rest_b, ll K)
{
    if (rest_a == 0)
    {
        return vector<char>(rest_b, 'b');
    }
    if (rest_b == 0)
    {
        return vector<char>(rest_a, 'a');
    }

    ll biA = hbi(rest_a - 1, rest_b);
    if (K <= biA)
    {
        vector<char> t = f(rest_a - 1, rest_b, K);
        t.push_back('a');
        return t;
    }
    else
    {
        vector<char> t = f(rest_a, rest_b - 1, K - biA);
        t.push_back('b');
        return t;
    }
}

int main()
{
    int A , B;
    ll K;
    io >> A >> B >> K;

    bi_init();

    vector<char> ans =  f(A, B, K);
    reverse(ans.begin(), ans.end());
    for (char c : ans)
    {
        io << c;
    }
    io << BR;
}
// atcoder/abc186/F/main.cpp
// author: @___Johniel
// github: https://github.com/johniel/

#include <bits/stdc++.h>

#define each(i, c) for (auto& i : c)
#define unless(cond) if (!(cond))

using namespace std;

template<typename P, typename Q> ostream& operator << (ostream& os, pair<P, Q> p) { os << "(" << p.first << "," << p.second << ")"; return os; }
template<typename P, typename Q> istream& operator >> (istream& is, pair<P, Q>& p) { is >> p.first >> p.second; return is; }
template<typename T> ostream& operator << (ostream& os, vector<T> v) { os << "("; for (auto& i: v) os << i << ","; os << ")"; return os; }
template<typename T> istream& operator >> (istream& is, vector<T>& v) { for (auto& i: v) is >> i; return is; }
template<typename T> ostream& operator << (ostream& os, set<T> s) { os << "#{"; for (auto& i: s) os << i << ","; os << "}"; return os; }
template<typename K, typename V> ostream& operator << (ostream& os, map<K, V> m) { os << "{"; for (auto& i: m) os << i << ","; os << "}"; return os; }

template<typename T> inline T setmax(T& a, T b) { return a = std::max(a, b); }
template<typename T> inline T setmin(T& a, T b) { return a = std::min(a, b); }

using lli = long long int;
using ull = unsigned long long;
using point = complex<double>;
using str = string;
template<typename T> using vec = vector<T>;

constexpr array<int, 8> di({0, 1, -1, 0, 1, -1, 1, -1});
constexpr array<int, 8> dj({1, 0, 0, -1, 1, -1, -1, 1});
constexpr lli mod = 1e9 + 7;

template<typename T>
struct SegTree {
  int n;
  int origin_size;
  vector<T> v;
  using F = function<T(T, T)>;
  F fn;
  T e;
  SegTree(int n_, T e_, F fn_) {
    origin_size = n_;
    e = e_;
    fn = fn_;
    n = 1;
    while (n < n_) n *= 2;
    v.resize(2 * n - 1, e);
  }

  void update(size_t k, T a) {
    k += n - 1;
    v[k] = a;
    while (k > 0) {
      k = (k - 1) / 2;
      v[k] = fn(v[k * 2 + 1], v[k * 2 + 2]);
    }
    return ;
  }

  T operator [] (size_t idx) const {
    return v.at(idx + n - 1);
  }

  inline T operator () () const {
    return query(0, origin_size, 0, 0, n);
  }

  inline T operator () (size_t a) const {
    return query(a, a+1, 0, 0, n);
  }

  inline T operator () (size_t a, size_t b) const {
    return query(a, b, 0, 0, n);
  }

  inline T query(size_t a, size_t b) const {
    assert(a < b);
    assert(b <= origin_size);
    return query(a, b, 0, 0, n);
  }

  T query(size_t a, size_t b, size_t k, size_t l, size_t r) const {
    if (r <= a || b <= l) return e;
    if (a <= l && r <= b) return v.at(k);

    T vl = query(a, b, k * 2 + 1, l, (l + r) / 2);
    T vr = query(a, b, k * 2 + 2, (l + r) / 2, r);

    return fn(vl, vr);
  }
};

int main(int argc, char *argv[])
{
  ios_base::sync_with_stdio(0);
  cin.tie(0);
  cout.setf(ios_base::fixed);
  cout.precision(15);

  lli h, w;
  int m;
  while (cin >> h >> w >> m) {
    vec<pair<lli, lli>> v(m);
    cin >> v;
    each (i, v) --i.first, --i.second;

    const int N = 2 * 1e5 + 5;
    const lli inf = 1LL << 60;
    static lli mn[N];
    fill(mn, mn + N, h);
    each (i, v) {
      setmin(mn[i.second], i.first);
    }

    lli sum = 0;
    for (int j = 0; j < w; ++j) {
      if (mn[j] == 0) break;
      sum += mn[j];
    }

    static vec<int> u[N];
    fill(u, u + N, vec<int>());
    each (i, v) {
      u[i.first].push_back(i.second);
    }
    for (int i = 0; i < N; ++i) {
      sort(u[i].begin(), u[i].end());
    }
    if (u[0].size()) {
      for (int j = u[0].front(); j < w; ++j) {
        u[0].push_back(j);
      }
    }

    SegTree<int> segtree(N, 0, [] (int a , int b) { return a + b; });
    for (int i = 1; i < h; ++i) {
      if (u[i].size() && u[i].front() == 0) break;
      each (j, u[i - 1]) {
        segtree.update(j, 1);
      }
      sum += segtree.query(0, (u[i].empty() ? w : u[i].front()));
    }
    cout << sum << endl;
  }

  return 0;
}
