#include <bits/stdc++.h>
using namespace std;
template <class T>
void splitstr(const string &s, vector<T> &out) {
  istringstream in(s);
  out.clear();
  copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
template <class T>
void initArray(T *arr, int size, T value) {
  for (int i = 0; i < size; i++) {
    arr[i] = value;
  }
}
template <class T>
T readValue(string s) {
  T result;
  istringstream sin(s);
  sin >> result;
  return result;
}
template <class T>
inline T gcd(T a, T b) {
  return (!a) ? b : gcd(b % a, a);
}
template <class T>
inline T mod(T a, T p) {
  a %= p;
  return (a < 0) ? a + p : a;
}
template <class T>
inline T numbits(T n) {
  return (!n) ? 0 : 1 + numbits(n & (n - 1));
}
template <class T>
inline T inverse(T a, T m) {
  a = mod<T>(a, m);
  return (a == 1) ? 1 : mod<T>((1 - m * inverse<T>(m % a, a)) / a, m);
}
template <class T>
inline bool isPrime(T a) {
  T lim = (T)sqrt((double)a);
  for (T i = 2; i < lim; i++)
    if (a % i == 0) return false;
  return true;
}
template <class T>
inline T power(T a, T p, T mod) {
  if (!p) return 1;
  T temp = power(a, p >> 1, mod);
  temp = (temp * temp) % mod;
  if (p & 1) temp = (temp * a) % mod;
  return temp;
}
void get_primes(int start, int end, vector<int> &vi) {
  int *p = new int[end + 1];
  initArray<int>(p, end + 1, 0);
  p[1] = 1;
  for (int i = 2; i <= end; i++) {
    if (!p[i]) {
      if (i >= start) vi.push_back(i);
      for (int j = 2 * i; j <= end; j += i) p[j] = 1;
    }
  }
}
bool dfs(int current, int final, int total, int *visited, int **edges,
         bool flow) {
  if (current == final) return true;
  if (visited[current]) return false;
  visited[current] = true;
  for (int i = 0; i < total; i++)
    if (edges[current][i] && dfs(i, final, total, visited, edges, flow)) {
      if (flow) {
        edges[current][i]--;
        edges[i][current]++;
      }
      return true;
    }
  return false;
}
int flow(int in, int out, int total, int **edges) {
  int result = 0;
  int *visited = new int[total];
  while (initArray<int>(visited, total, 0),
         dfs(in, out, total, visited, edges, true))
    result++;
  return result;
}
void create_set(int x, int *P, int *rank) {
  P[x] = x;
  rank[x] = 0;
}
int find_set(int x, int *P) {
  if (x != P[x]) P[x] = find_set(P[x], P);
  return P[x];
}
bool merge_sets(int x, int y, int *P, int *rank) {
  int Px = find_set(x, P);
  int Py = find_set(y, P);
  if (Px == Py) return false;
  if (rank[Px] > rank[Py])
    P[Py] = Px;
  else
    P[Px] = Py;
  if (rank[Px] == rank[Py]) rank[Py]++;
  return true;
}
int read_cum_freq(int index, int *tree) {
  int sum = 0;
  while (index) {
    sum += tree[index];
    index -= (index & -index);
  }
  return sum;
}
void upd_freq(int index, int mxIndex, int value, int *tree) {
  while (index <= mxIndex) {
    tree[index] += value;
    index += (index & -index);
  }
}
int read_freq(int index, int *tree) {
  return read_cum_freq(index, tree) - read_cum_freq(index - 1, tree);
}
void build_failure_function(const string &str, int *temp_arr) {
  temp_arr[0] = temp_arr[1] = 0;
  for (int i = 2; i <= static_cast<int>(str.size()); i++) {
    temp_arr[i] = -1;
    for (int ind = temp_arr[i - 1]; temp_arr[i] == -1; ind = temp_arr[ind]) {
      if (str[ind] == str[i - 1]) {
        temp_arr[i] = ind + 1;
      } else if (ind == 0) {
        temp_arr[i] = 0;
      }
    }
  }
}
void KMP(const string &s1, const string &s2, int *res) {
  int *temp_arr = new int[s2.size() + 1];
  build_failure_function(s2, temp_arr);
  int i = 0;
  int ind = 0;
  while (i < static_cast<int>(s1.size())) {
    if (s1[i] == s2[ind]) {
      res[i] = ++ind;
      if (res[i] == s2.size()) {
        ind = temp_arr[ind - 1];
      }
      i++;
    } else if (ind == 0) {
      res[i++] = 0;
    } else {
      ind = temp_arr[ind];
    }
  }
  delete[] temp_arr;
}
FILE *stream1, *stream2;
void setup(int value) {
  freopen("in.txt", "r", stdin);
  if (value) {
    freopen("out.txt", "w", stdout);
  }
}
char get_ch(int i, int j) { return (char)('a' + ((i + 5 * j) % 26)); }
void make_swap(int &a, int &b) {
  int c = a;
  a = b;
  b = c;
}
char arr[101][101];
int main() {
  int n, m, a, b, c, i, j, q, p;
  cin >> n >> m >> a >> b >> c;
  if ((n % 2) && (m % 2)) {
    std::cout << "IMPOSSIBLE" << std::endl;
  } else {
    memset(arr, 0, sizeof(arr));
    bool use_swap = false;
    if (n % 2) {
      use_swap = true;
      make_swap(a, b);
      make_swap(n, m);
    }
    for (i = 0; i < n; i += 2) {
      for (j = 1; j < m; j += 2) {
        if (c) {
          c--;
          arr[i][j - 1] = arr[i][j] = arr[i + 1][j - 1] = arr[i + 1][j] =
              get_ch(i, j - 1);
        } else if (a >= 2) {
          a -= 2;
          arr[i][j - 1] = arr[i][j] = get_ch(i, j - 1);
          arr[i + 1][j - 1] = arr[i + 1][j] = get_ch(i + 1, j - 1);
        } else if (b >= 2) {
          b -= 2;
          arr[i][j - 1] = arr[i + 1][j - 1] = get_ch(i, j - 1);
          arr[i][j] = arr[i + 1][j] = get_ch(i, j);
        } else {
          std::cout << "IMPOSSIBLE" << std::endl;
          return 0;
        }
      }
      if (m & 1) {
        if (b) {
          b--;
          arr[i][m - 1] = arr[i + 1][m - 1] = get_ch(i, m - 1);
        } else {
          std::cout << "IMPOSSIBLE" << std::endl;
          return 0;
        }
      }
    }
    if (use_swap) {
      for (q = 0; q < m; q++) {
        for (p = 0; p < n; p++) std::cout << arr[p][q];
        std::cout << std::endl;
      }
    } else {
      for (q = 0; q < n; q++) {
        for (p = 0; p < m; p++) std::cout << arr[q][p];
        std::cout << std::endl;
      }
    }
  }
  return 0;
}

### Prompt

In CPP, your task is to solve the following problem:

Once Bob decided to lay a parquet floor in his living room. The living room is of size n × m metres. Bob had planks of three types: a planks 1 × 2 meters, b planks 2 × 1 meters, and c planks 2 × 2 meters. Help Bob find out, if it is possible to parquet the living room with such a set of planks, and if it is possible, find one of the possible ways to do so. Bob doesn't have to use all the planks.

Input

The first input line contains 5 space-separated integer numbers n, m, a, b, c (1 ≤ n, m ≤ 100, 0 ≤ a, b, c ≤ 104), n and m — the living room dimensions, a, b and c — amount of planks 1 × 2, 2 × 1 и 2 × 2 respectively. It's not allowed to turn the planks.

Output

If it is not possible to parquet the room with such a set of planks, output IMPOSSIBLE. Otherwise output one of the possible ways to parquet the room — output n lines with m lower-case Latin letters each. Two squares with common sides should contain the same letters, if they belong to one and the same plank, and different letters otherwise. Different planks can be marked with one and the same letter (see examples). If the answer is not unique, output any.

Examples

Input

2 6 2 2 1


Output

aabcca
aabdda


Input

1 1 100 100 100


Output

IMPOSSIBLE


Input

4 4 10 10 10


Output

aabb
aabb
bbaa
bbaa

### Response

```cpp
#include <bits/stdc++.h>
using namespace std;
template <class T>
void splitstr(const string &s, vector<T> &out) {
  istringstream in(s);
  out.clear();
  copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}
template <class T>
void initArray(T *arr, int size, T value) {
  for (int i = 0; i < size; i++) {
    arr[i] = value;
  }
}
template <class T>
T readValue(string s) {
  T result;
  istringstream sin(s);
  sin >> result;
  return result;
}
template <class T>
inline T gcd(T a, T b) {
  return (!a) ? b : gcd(b % a, a);
}
template <class T>
inline T mod(T a, T p) {
  a %= p;
  return (a < 0) ? a + p : a;
}
template <class T>
inline T numbits(T n) {
  return (!n) ? 0 : 1 + numbits(n & (n - 1));
}
template <class T>
inline T inverse(T a, T m) {
  a = mod<T>(a, m);
  return (a == 1) ? 1 : mod<T>((1 - m * inverse<T>(m % a, a)) / a, m);
}
template <class T>
inline bool isPrime(T a) {
  T lim = (T)sqrt((double)a);
  for (T i = 2; i < lim; i++)
    if (a % i == 0) return false;
  return true;
}
template <class T>
inline T power(T a, T p, T mod) {
  if (!p) return 1;
  T temp = power(a, p >> 1, mod);
  temp = (temp * temp) % mod;
  if (p & 1) temp = (temp * a) % mod;
  return temp;
}
void get_primes(int start, int end, vector<int> &vi) {
  int *p = new int[end + 1];
  initArray<int>(p, end + 1, 0);
  p[1] = 1;
  for (int i = 2; i <= end; i++) {
    if (!p[i]) {
      if (i >= start) vi.push_back(i);
      for (int j = 2 * i; j <= end; j += i) p[j] = 1;
    }
  }
}
bool dfs(int current, int final, int total, int *visited, int **edges,
         bool flow) {
  if (current == final) return true;
  if (visited[current]) return false;
  visited[current] = true;
  for (int i = 0; i < total; i++)
    if (edges[current][i] && dfs(i, final, total, visited, edges, flow)) {
      if (flow) {
        edges[current][i]--;
        edges[i][current]++;
      }
      return true;
    }
  return false;
}
int flow(int in, int out, int total, int **edges) {
  int result = 0;
  int *visited = new int[total];
  while (initArray<int>(visited, total, 0),
         dfs(in, out, total, visited, edges, true))
    result++;
  return result;
}
void create_set(int x, int *P, int *rank) {
  P[x] = x;
  rank[x] = 0;
}
int find_set(int x, int *P) {
  if (x != P[x]) P[x] = find_set(P[x], P);
  return P[x];
}
bool merge_sets(int x, int y, int *P, int *rank) {
  int Px = find_set(x, P);
  int Py = find_set(y, P);
  if (Px == Py) return false;
  if (rank[Px] > rank[Py])
    P[Py] = Px;
  else
    P[Px] = Py;
  if (rank[Px] == rank[Py]) rank[Py]++;
  return true;
}
int read_cum_freq(int index, int *tree) {
  int sum = 0;
  while (index) {
    sum += tree[index];
    index -= (index & -index);
  }
  return sum;
}
void upd_freq(int index, int mxIndex, int value, int *tree) {
  while (index <= mxIndex) {
    tree[index] += value;
    index += (index & -index);
  }
}
int read_freq(int index, int *tree) {
  return read_cum_freq(index, tree) - read_cum_freq(index - 1, tree);
}
void build_failure_function(const string &str, int *temp_arr) {
  temp_arr[0] = temp_arr[1] = 0;
  for (int i = 2; i <= static_cast<int>(str.size()); i++) {
    temp_arr[i] = -1;
    for (int ind = temp_arr[i - 1]; temp_arr[i] == -1; ind = temp_arr[ind]) {
      if (str[ind] == str[i - 1]) {
        temp_arr[i] = ind + 1;
      } else if (ind == 0) {
        temp_arr[i] = 0;
      }
    }
  }
}
void KMP(const string &s1, const string &s2, int *res) {
  int *temp_arr = new int[s2.size() + 1];
  build_failure_function(s2, temp_arr);
  int i = 0;
  int ind = 0;
  while (i < static_cast<int>(s1.size())) {
    if (s1[i] == s2[ind]) {
      res[i] = ++ind;
      if (res[i] == s2.size()) {
        ind = temp_arr[ind - 1];
      }
      i++;
    } else if (ind == 0) {
      res[i++] = 0;
    } else {
      ind = temp_arr[ind];
    }
  }
  delete[] temp_arr;
}
FILE *stream1, *stream2;
void setup(int value) {
  freopen("in.txt", "r", stdin);
  if (value) {
    freopen("out.txt", "w", stdout);
  }
}
char get_ch(int i, int j) { return (char)('a' + ((i + 5 * j) % 26)); }
void make_swap(int &a, int &b) {
  int c = a;
  a = b;
  b = c;
}
char arr[101][101];
int main() {
  int n, m, a, b, c, i, j, q, p;
  cin >> n >> m >> a >> b >> c;
  if ((n % 2) && (m % 2)) {
    std::cout << "IMPOSSIBLE" << std::endl;
  } else {
    memset(arr, 0, sizeof(arr));
    bool use_swap = false;
    if (n % 2) {
      use_swap = true;
      make_swap(a, b);
      make_swap(n, m);
    }
    for (i = 0; i < n; i += 2) {
      for (j = 1; j < m; j += 2) {
        if (c) {
          c--;
          arr[i][j - 1] = arr[i][j] = arr[i + 1][j - 1] = arr[i + 1][j] =
              get_ch(i, j - 1);
        } else if (a >= 2) {
          a -= 2;
          arr[i][j - 1] = arr[i][j] = get_ch(i, j - 1);
          arr[i + 1][j - 1] = arr[i + 1][j] = get_ch(i + 1, j - 1);
        } else if (b >= 2) {
          b -= 2;
          arr[i][j - 1] = arr[i + 1][j - 1] = get_ch(i, j - 1);
          arr[i][j] = arr[i + 1][j] = get_ch(i, j);
        } else {
          std::cout << "IMPOSSIBLE" << std::endl;
          return 0;
        }
      }
      if (m & 1) {
        if (b) {
          b--;
          arr[i][m - 1] = arr[i + 1][m - 1] = get_ch(i, m - 1);
        } else {
          std::cout << "IMPOSSIBLE" << std::endl;
          return 0;
        }
      }
    }
    if (use_swap) {
      for (q = 0; q < m; q++) {
        for (p = 0; p < n; p++) std::cout << arr[p][q];
        std::cout << std::endl;
      }
    } else {
      for (q = 0; q < n; q++) {
        for (p = 0; p < m; p++) std::cout << arr[q][p];
        std::cout << std::endl;
      }
    }
  }
  return 0;
}

```