#include <bits/stdc++.h>
using namespace std;
const long long MOD = 1e9 + 7;
const int N = (1 << 24);
int n, m, a, b, c;
char mp[107][107];
bool check(int x, int y, char c) {
  if (x == 0 || y == 0) return 0;
  return mp[x][y] == c;
}
int main() {
  cin >> n >> m >> a >> b >> c;
  int n1 = n / 2, m1 = m / 2;
  if ((n & 1) && (m & 1)) {
    cout << "IMPOSSIBLE" << endl;
    return 0;
  } else if (!(n & 1) && !(m & 1)) {
    for (int i = int(1); i <= int(n1); ++i)
      for (int j = int(1); j <= int(m1); ++j) {
        if (c) {
          c--;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i, 2 * j - 2, cc) ||
                check(2 * i - 1, 2 * j - 2, cc) ||
                check(2 * i - 2, 2 * j - 1, cc) || check(2 * i - 2, 2 * j, cc))
              continue;
            mp[2 * i][2 * j] = mp[2 * i - 1][2 * j] = mp[2 * i][2 * j - 1] =
                mp[2 * i - 1][2 * j - 1] = cc;
            break;
          }
        } else if (a >= 2) {
          a -= 2;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j - 1, cc) ||
                check(2 * i - 2, 2 * j, cc) || check(2 * i - 1, 2 * j - 2, cc))
              continue;
            mp[2 * i - 1][2 * j - 1] = mp[2 * i - 1][2 * j] = cc;
            break;
          }
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 1, 2 * j - 1, cc) ||
                check(2 * i - 1, 2 * j, cc) || check(2 * i, 2 * j - 2, cc))
              continue;
            mp[2 * i][2 * j - 1] = mp[2 * i][2 * j] = cc;
            break;
          }
        } else if (b >= 2) {
          b -= 2;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j - 1, cc) ||
                check(2 * i - 1, 2 * j - 2, cc) || check(2 * i, 2 * j - 2, cc))
              continue;
            mp[2 * i - 1][2 * j - 1] = mp[2 * i][2 * j - 1] = cc;
            break;
          }
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j, cc) ||
                check(2 * i - 1, 2 * j - 1, cc) || check(2 * i, 2 * j - 1, cc))
              continue;
            mp[2 * i - 1][2 * j] = mp[2 * i][2 * j] = cc;
            break;
          }
        } else {
          puts("IMPOSSIBLE");
          return 0;
        }
      }
  } else if ((n & 1) && !(m & 1)) {
    for (int i = int(1); i <= int(n1); ++i)
      for (int j = int(1); j <= int(m1); ++j) {
        if (c) {
          c--;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i, 2 * j - 2, cc) ||
                check(2 * i - 1, 2 * j - 2, cc) ||
                check(2 * i - 2, 2 * j - 1, cc) || check(2 * i - 2, 2 * j, cc))
              continue;
            mp[2 * i][2 * j] = mp[2 * i - 1][2 * j] = mp[2 * i][2 * j - 1] =
                mp[2 * i - 1][2 * j - 1] = cc;
            break;
          }
        } else if (b >= 2) {
          b -= 2;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j - 1, cc) ||
                check(2 * i - 1, 2 * j - 2, cc) || check(2 * i, 2 * j - 2, cc))
              continue;
            mp[2 * i - 1][2 * j - 1] = mp[2 * i][2 * j - 1] = cc;
            break;
          }
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j, cc) ||
                check(2 * i - 1, 2 * j - 1, cc) || check(2 * i, 2 * j - 1, cc))
              continue;
            mp[2 * i - 1][2 * j] = mp[2 * i][2 * j] = cc;
            break;
          }
        } else if (a >= 2) {
          a -= 2;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j - 1, cc) ||
                check(2 * i - 2, 2 * j, cc) || check(2 * i - 1, 2 * j - 2, cc))
              continue;
            mp[2 * i - 1][2 * j - 1] = mp[2 * i - 1][2 * j] = cc;
            break;
          }
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 1, 2 * j - 1, cc) ||
                check(2 * i - 1, 2 * j, cc) || check(2 * i, 2 * j - 2, cc))
              continue;
            mp[2 * i][2 * j - 1] = mp[2 * i][2 * j] = cc;
            break;
          }
        } else {
          puts("IMPOSSIBLE");
          return 0;
        }
      }
    for (int j = int(1); j <= int(m1); ++j) {
      if (a >= 1) {
        a--;
        for (int k = int(0); k <= int(25); ++k) {
          char cc = (char)(k + 'a');
          if (check(n, 2 * j - 2, cc) || check(n - 1, 2 * j - 1, cc) ||
              check(n - 1, 2 * j, cc))
            continue;
          mp[n][2 * j - 1] = mp[n][2 * j] = cc;
          break;
        }
      } else {
        puts("IMPOSSIBLE");
        return 0;
      }
    }
  } else {
    for (int i = int(1); i <= int(n1); ++i)
      for (int j = int(1); j <= int(m1); ++j) {
        if (c) {
          c--;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i, 2 * j - 2, cc) ||
                check(2 * i - 1, 2 * j - 2, cc) ||
                check(2 * i - 2, 2 * j - 1, cc) || check(2 * i - 2, 2 * j, cc))
              continue;
            mp[2 * i][2 * j] = mp[2 * i - 1][2 * j] = mp[2 * i][2 * j - 1] =
                mp[2 * i - 1][2 * j - 1] = cc;
            break;
          }
        } else if (a >= 2) {
          a -= 2;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j - 1, cc) ||
                check(2 * i - 2, 2 * j, cc) || check(2 * i - 1, 2 * j - 2, cc))
              continue;
            mp[2 * i - 1][2 * j - 1] = mp[2 * i - 1][2 * j] = cc;
            break;
          }
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 1, 2 * j - 1, cc) ||
                check(2 * i - 1, 2 * j, cc) || check(2 * i, 2 * j - 2, cc))
              continue;
            mp[2 * i][2 * j - 1] = mp[2 * i][2 * j] = cc;
            break;
          }
        } else if (b >= 2) {
          b -= 2;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j - 1, cc) ||
                check(2 * i - 1, 2 * j - 2, cc) || check(2 * i, 2 * j - 2, cc))
              continue;
            mp[2 * i - 1][2 * j - 1] = mp[2 * i][2 * j - 1] = cc;
            break;
          }
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j, cc) ||
                check(2 * i - 1, 2 * j - 1, cc) || check(2 * i, 2 * j - 1, cc))
              continue;
            mp[2 * i - 1][2 * j] = mp[2 * i][2 * j] = cc;
            break;
          }
        } else {
          puts("IMPOSSIBLE");
          return 0;
        }
      }
    for (int i = int(1); i <= int(n1); ++i) {
      if (b >= 1) {
        b--;
        for (int k = int(0); k <= int(25); ++k) {
          char cc = (char)(k + 'a');
          if (check(2 * i - 2, m, cc) || check(2 * i - 1, m - 1, cc) ||
              check(2 * i, m - 1, cc))
            continue;
          mp[2 * i - 1][m] = mp[2 * i][m] = cc;
          break;
        }
      } else {
        puts("IMPOSSIBLE");
        return 0;
      }
    }
  }
  for (int i = int(1); i <= int(n); ++i) {
    for (int j = int(1); j <= int(m); ++j) printf("%c", mp[i][j]);
    puts("");
  }
}

### Prompt

Please provide a CPP coded solution to the problem described below:

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;
const long long MOD = 1e9 + 7;
const int N = (1 << 24);
int n, m, a, b, c;
char mp[107][107];
bool check(int x, int y, char c) {
  if (x == 0 || y == 0) return 0;
  return mp[x][y] == c;
}
int main() {
  cin >> n >> m >> a >> b >> c;
  int n1 = n / 2, m1 = m / 2;
  if ((n & 1) && (m & 1)) {
    cout << "IMPOSSIBLE" << endl;
    return 0;
  } else if (!(n & 1) && !(m & 1)) {
    for (int i = int(1); i <= int(n1); ++i)
      for (int j = int(1); j <= int(m1); ++j) {
        if (c) {
          c--;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i, 2 * j - 2, cc) ||
                check(2 * i - 1, 2 * j - 2, cc) ||
                check(2 * i - 2, 2 * j - 1, cc) || check(2 * i - 2, 2 * j, cc))
              continue;
            mp[2 * i][2 * j] = mp[2 * i - 1][2 * j] = mp[2 * i][2 * j - 1] =
                mp[2 * i - 1][2 * j - 1] = cc;
            break;
          }
        } else if (a >= 2) {
          a -= 2;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j - 1, cc) ||
                check(2 * i - 2, 2 * j, cc) || check(2 * i - 1, 2 * j - 2, cc))
              continue;
            mp[2 * i - 1][2 * j - 1] = mp[2 * i - 1][2 * j] = cc;
            break;
          }
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 1, 2 * j - 1, cc) ||
                check(2 * i - 1, 2 * j, cc) || check(2 * i, 2 * j - 2, cc))
              continue;
            mp[2 * i][2 * j - 1] = mp[2 * i][2 * j] = cc;
            break;
          }
        } else if (b >= 2) {
          b -= 2;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j - 1, cc) ||
                check(2 * i - 1, 2 * j - 2, cc) || check(2 * i, 2 * j - 2, cc))
              continue;
            mp[2 * i - 1][2 * j - 1] = mp[2 * i][2 * j - 1] = cc;
            break;
          }
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j, cc) ||
                check(2 * i - 1, 2 * j - 1, cc) || check(2 * i, 2 * j - 1, cc))
              continue;
            mp[2 * i - 1][2 * j] = mp[2 * i][2 * j] = cc;
            break;
          }
        } else {
          puts("IMPOSSIBLE");
          return 0;
        }
      }
  } else if ((n & 1) && !(m & 1)) {
    for (int i = int(1); i <= int(n1); ++i)
      for (int j = int(1); j <= int(m1); ++j) {
        if (c) {
          c--;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i, 2 * j - 2, cc) ||
                check(2 * i - 1, 2 * j - 2, cc) ||
                check(2 * i - 2, 2 * j - 1, cc) || check(2 * i - 2, 2 * j, cc))
              continue;
            mp[2 * i][2 * j] = mp[2 * i - 1][2 * j] = mp[2 * i][2 * j - 1] =
                mp[2 * i - 1][2 * j - 1] = cc;
            break;
          }
        } else if (b >= 2) {
          b -= 2;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j - 1, cc) ||
                check(2 * i - 1, 2 * j - 2, cc) || check(2 * i, 2 * j - 2, cc))
              continue;
            mp[2 * i - 1][2 * j - 1] = mp[2 * i][2 * j - 1] = cc;
            break;
          }
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j, cc) ||
                check(2 * i - 1, 2 * j - 1, cc) || check(2 * i, 2 * j - 1, cc))
              continue;
            mp[2 * i - 1][2 * j] = mp[2 * i][2 * j] = cc;
            break;
          }
        } else if (a >= 2) {
          a -= 2;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j - 1, cc) ||
                check(2 * i - 2, 2 * j, cc) || check(2 * i - 1, 2 * j - 2, cc))
              continue;
            mp[2 * i - 1][2 * j - 1] = mp[2 * i - 1][2 * j] = cc;
            break;
          }
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 1, 2 * j - 1, cc) ||
                check(2 * i - 1, 2 * j, cc) || check(2 * i, 2 * j - 2, cc))
              continue;
            mp[2 * i][2 * j - 1] = mp[2 * i][2 * j] = cc;
            break;
          }
        } else {
          puts("IMPOSSIBLE");
          return 0;
        }
      }
    for (int j = int(1); j <= int(m1); ++j) {
      if (a >= 1) {
        a--;
        for (int k = int(0); k <= int(25); ++k) {
          char cc = (char)(k + 'a');
          if (check(n, 2 * j - 2, cc) || check(n - 1, 2 * j - 1, cc) ||
              check(n - 1, 2 * j, cc))
            continue;
          mp[n][2 * j - 1] = mp[n][2 * j] = cc;
          break;
        }
      } else {
        puts("IMPOSSIBLE");
        return 0;
      }
    }
  } else {
    for (int i = int(1); i <= int(n1); ++i)
      for (int j = int(1); j <= int(m1); ++j) {
        if (c) {
          c--;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i, 2 * j - 2, cc) ||
                check(2 * i - 1, 2 * j - 2, cc) ||
                check(2 * i - 2, 2 * j - 1, cc) || check(2 * i - 2, 2 * j, cc))
              continue;
            mp[2 * i][2 * j] = mp[2 * i - 1][2 * j] = mp[2 * i][2 * j - 1] =
                mp[2 * i - 1][2 * j - 1] = cc;
            break;
          }
        } else if (a >= 2) {
          a -= 2;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j - 1, cc) ||
                check(2 * i - 2, 2 * j, cc) || check(2 * i - 1, 2 * j - 2, cc))
              continue;
            mp[2 * i - 1][2 * j - 1] = mp[2 * i - 1][2 * j] = cc;
            break;
          }
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 1, 2 * j - 1, cc) ||
                check(2 * i - 1, 2 * j, cc) || check(2 * i, 2 * j - 2, cc))
              continue;
            mp[2 * i][2 * j - 1] = mp[2 * i][2 * j] = cc;
            break;
          }
        } else if (b >= 2) {
          b -= 2;
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j - 1, cc) ||
                check(2 * i - 1, 2 * j - 2, cc) || check(2 * i, 2 * j - 2, cc))
              continue;
            mp[2 * i - 1][2 * j - 1] = mp[2 * i][2 * j - 1] = cc;
            break;
          }
          for (int k = int(0); k <= int(25); ++k) {
            char cc = (char)(k + 'a');
            if (check(2 * i - 2, 2 * j, cc) ||
                check(2 * i - 1, 2 * j - 1, cc) || check(2 * i, 2 * j - 1, cc))
              continue;
            mp[2 * i - 1][2 * j] = mp[2 * i][2 * j] = cc;
            break;
          }
        } else {
          puts("IMPOSSIBLE");
          return 0;
        }
      }
    for (int i = int(1); i <= int(n1); ++i) {
      if (b >= 1) {
        b--;
        for (int k = int(0); k <= int(25); ++k) {
          char cc = (char)(k + 'a');
          if (check(2 * i - 2, m, cc) || check(2 * i - 1, m - 1, cc) ||
              check(2 * i, m - 1, cc))
            continue;
          mp[2 * i - 1][m] = mp[2 * i][m] = cc;
          break;
        }
      } else {
        puts("IMPOSSIBLE");
        return 0;
      }
    }
  }
  for (int i = int(1); i <= int(n); ++i) {
    for (int j = int(1); j <= int(m); ++j) printf("%c", mp[i][j]);
    puts("");
  }
}

```