#include <bits/stdc++.h>
using namespace std;
template <class T>
T gcd(T a, T b) {
  if (!b) return a;
  while (b ^= a ^= b ^= a %= b)
    ;
  return a;
}
template <class T>
T max(const T& t1, const T& t2, const T& t3) {
  return max(max(t1, t2), t3);
}
template <class T>
T max(const T& t1, const T& t2, const T& t3, const T& t4) {
  return max(max(t1, t2), max(t3, t4));
}
long long fpow(long long x, long long y, long long mod = 0x7fffffffffffffffll) {
  long long ret = 1;
  while (y) {
    if (y & 1) ret *= x, ret %= mod;
    x *= x;
    x %= mod;
    y >>= 1;
  }
  return ret;
}
void ex_gcd(long long a, long long b, long long& x, long long& y) {
  if (b == 0) {
    x = a;
    y = 0;
    return;
  }
  ex_gcd(b, a % b, y, x);
  y = y - a / b * x;
}
long long modrev(long long x, long long mod) {
  long long x1, x2;
  ex_gcd(x, mod, x1, x2);
  return x1;
}
unsigned long long T_rand() { return (unsigned long long)(rand()); }
unsigned long long Rand() {
  return (T_rand() << 48) | (T_rand() << 32) | (T_rand() << 16) | T_rand();
}
template <class T>
bool PRE_INPUT_INTENGER(T& ret) {
  ;
  ret = 0;
  char c = getchar();
  if (c == -1) return 0;
  bool f = 0;
  while ((c < '0' || c > '9') && (c != -1) && (c != '-')) c = getchar();
  if (c == '-') {
    f = 1;
    c = getchar();
  }
  while (c >= '0' && c <= '9') ret *= 10, ret += c - '0', c = getchar();
  if (f) ret = -ret;
  if (c == -1) return 0;
  return 1;
}
bool input(int& ret) { return PRE_INPUT_INTENGER(ret); }
bool input(long long& ret) { return PRE_INPUT_INTENGER(ret); }
bool input(unsigned long long& ret) { return PRE_INPUT_INTENGER(ret); }
bool input(unsigned int& ret) { return PRE_INPUT_INTENGER(ret); }
template <class T>
bool PRE_INPUT_DOUBLE(T& ret) {
  ;
  ret = 0;
  char c = getchar();
  if (c == -1) return 0;
  bool f = 0;
  while ((c < '0' || c > '9') && (c != -1) && (c != '.') && (c != '-'))
    c = getchar();
  bool isright = 0;
  if (c == '-') {
    f = 1;
    c = getchar();
  }
  T t = 1;
  while ((c >= '0' && c <= '9') || (c == '.')) {
    if (c == '.')
      isright = 1;
    else {
      ret *= 10, ret += c - '0';
      if (isright) t *= 10;
    }
    c = getchar();
  }
  ret /= t;
  if (f) ret = -ret;
  if (c == -1) return 0;
  return 1;
}
bool input(double& ret) { return PRE_INPUT_DOUBLE(ret); }
bool input(float& ret) { return PRE_INPUT_DOUBLE(ret); }
bool IS_SPECIAL_CHAR(const char& ret) {
  return (ret == ' ' || ret == '\n' || ret == '\t' || ret == '\r' ||
          ret == '\v');
}
bool input(char& ret) {
  ;
  ret = getchar();
  if (ret == -1) return 0;
  while (IS_SPECIAL_CHAR(ret)) ret = getchar();
  return ~ret;
}
bool input(char* ret) {
  ;
  char c;
  if (!input(c)) return 0;
  *ret++ = c;
  while (!IS_SPECIAL_CHAR(*(ret - 1))) *ret++ = getchar();
  *(ret - 1) = 0;
  return 1;
}
template <class T1, class T2>
bool input(T1& t1, T2& t2) {
  return input(t1) && input(t2);
}
template <class T1, class T2, class T3>
bool input(T1& t1, T2& t2, T3& t3) {
  return input(t1) && input(t2) && input(t3);
}
template <class T1, class T2, class T3, class T4>
bool input(T1& t1, T2& t2, T3& t3, T4& t4) {
  return input(t1) && input(t2) && input(t3) && input(t4);
}
template <class T1, class T2, class T3, class T4, class T5>
bool input(T1& t1, T2& t2, T3& t3, T4& t4, T5& t5) {
  return input(t1) && input(t2) && input(t3) && input(t4) && input(t5);
}
template <class T>
void input(T* a, int n) {
  for (int i = 0; i <= n - 1; i++) input(a[i]);
}
template <class T>
void PRE_OUTPUT_INTENGER(const T& t) {
  ;
  if (!t) {
    putchar('0');
    return;
  }
  T key = t;
  int tt[25];
  if (key < 0) {
    putchar('-');
    key = -key;
  }
  int cnt = 0;
  while (key) tt[cnt++] = key % 10, key /= 10;
  while (cnt) putchar(tt[--cnt] + '0');
  ;
}
void output(const int& t) { PRE_OUTPUT_INTENGER(t); }
void output(const long long& t) { PRE_OUTPUT_INTENGER(t); }
void output(const unsigned long long& t) { PRE_OUTPUT_INTENGER(t); }
void output(const unsigned int& t) { PRE_OUTPUT_INTENGER(t); }
template <class T>
void PRE_OUTPUT_DOUBLE(const T& key) {
  ;
  printf("%.*f", 6, key);
  ;
}
void output(const double& t) { PRE_OUTPUT_DOUBLE(t); }
void output(const float& t) { PRE_OUTPUT_DOUBLE(t); }
void output(const char* ch) {
  ;
  int cnt = 0;
  while (ch[cnt]) putchar(ch[cnt++]);
  ;
}
void output(const char& c) {
  ;
  putchar(c);
  ;
}
void output(const string& s) { output(s.c_str()); }
template <class T1, class T2>
void output(const T1& t1, const T2& t2) {
  output(t1);
  output(t2);
}
template <class T1, class T2, class T3>
void output(const T1& t1, const T2& t2, const T3& t3) {
  output(t1);
  output(t2);
  output(t3);
}
template <class T1, class T2, class T3, class T4>
void output(const T1& t1, const T2& t2, const T3& t3, const T4& t4) {
  output(t1);
  output(t2);
  output(t3);
  output(t4);
}
template <class T1, class T2, class T3, class T4, class T5>
void output(const T1& t1, const T2& t2, const T3& t3, const T4& t4,
            const T5& t5) {
  output(t1);
  output(t2);
  output(t3);
  output(t4);
  output(t5);
}
template <class T1, class T2, class T3, class T4, class T5, class T6>
void output(const T1& t1, const T2& t2, const T3& t3, const T4& t4,
            const T5& t5, const T6& t6) {
  output(t1);
  output(t2);
  output(t3);
  output(t4);
  output(t5);
  output(t6);
}
template <class T1, class T2, class T3, class T4, class T5, class T6, class T7>
void output(const T1& t1, const T2& t2, const T3& t3, const T4& t4,
            const T5& t5, const T6& t6, const T7& t7) {
  output(t1);
  output(t2);
  output(t3);
  output(t4);
  output(t5);
  output(t6);
  output(t7);
}
template <class T>
void printal(T* a, int n) {
  for (int i = 0; i < n - 1; i++) output(a[i], ' ');
  output(a[n - 1], '\n');
}
template <class T>
void printel(T* a, int n) {
  for (int i = 0; i < n; i++) output(a[i], '\n');
}
template <class T>
void inputal(T* a, int n) {
  for (int i = 0; i <= n - 1; i++) input(a[i]);
}
const int maxn = 1e5 + 10;
struct Node {
  string s;
  int cnt;
  char last;
  bool operator<(const Node& t) const {
    if (cnt < t.cnt) return true;
    if (last < t.last) return true;
    return false;
  }
  bool operator==(const Node& t) const {
    return cnt == t.cnt && last == t.last;
  }
};
Node node[maxn];
const char* vowel = "aeiou";
bool is_vowel(char c) {
  switch (c) {
    case 'a':
    case 'e':
    case 'i':
    case 'o':
    case 'u':
      return true;
    default:
      return false;
  }
}
map<int, map<char, vector<int>>> mp;
int ans[4 * maxn];
int main() {
  int n;
  input(n);
  for (int i = 0; i <= n - 1; i++) {
    cin >> node[i].s;
    node[i].cnt = 0;
    for (const char& c : node[i].s) {
      if (is_vowel(c)) {
        ++node[i].cnt;
        node[i].last = c;
      }
    }
    if (mp.count(node[i].cnt) == 0) {
      mp[node[i].cnt] = map<char, vector<int>>();
    }
    if (mp[node[i].cnt].count(node[i].last) == 0) {
      mp[node[i].cnt][node[i].last] = vector<int>();
    }
    mp[node[i].cnt][node[i].last].push_back(i);
  }
  vector<pair<int, int>> has_same;
  map<int, vector<int>> single;
  for (const pair<int, map<char, vector<int>>>& t : mp) {
    for (const pair<char, vector<int>>& t2 : t.second) {
      for (int i = 0; i < t2.second.size(); i += 2) {
        if (i == t2.second.size() - 1) {
          if (single.count(t.first) == 0) {
            single[t.first] = vector<int>();
          }
          single[t.first].push_back(t2.second[i]);
        } else {
          has_same.push_back(make_pair(t2.second[i], t2.second[i + 1]));
        }
      }
    }
  }
  int cnt = 0;
  int last_double_idx = 0;
  for (const pair<int, vector<int>>& t : single) {
    int last_single_idx = 0;
    if (last_double_idx == has_same.size()) break;
    while (t.second.size() - last_single_idx > 1) {
      if (last_double_idx == has_same.size()) break;
      pair<int, int>& cur = has_same[last_double_idx++];
      ans[cnt++] = t.second[last_single_idx++];
      ans[cnt++] = cur.first;
      ans[cnt++] = t.second[last_single_idx++];
      ans[cnt++] = cur.second;
    }
  }
  while (last_double_idx + 1 < has_same.size()) {
    ans[cnt++] = has_same[last_double_idx].first;
    ans[cnt++] = has_same[last_double_idx + 1].first;
    ans[cnt++] = has_same[last_double_idx].second;
    ans[cnt++] = has_same[last_double_idx + 1].second;
    last_double_idx += 2;
  }
  output(cnt / 4);
  putchar('\n');
  for (int i = 0; i < cnt; i += 2) {
    output(node[ans[i]].s, " ", node[ans[i + 1]].s);
    putchar('\n');
  }
}
