Problem: Dreamoon likes strings. Today he created a game about strings:

String s_1, s_2, …, s_n is beautiful if and only if for each 1 ≤ i < n, s_i ≠ s_{i+1}.

Initially, Dreamoon has a string a. In each step Dreamoon can choose a beautiful substring of a and remove it. Then he should concatenate the remaining characters (in the same order).

Dreamoon wants to use the smallest number of steps to make a empty. Please help Dreamoon, and print any sequence of the smallest number of steps to make a empty.

Input

The first line contains an integer t (1 ≤ t ≤ 200 000), denoting the number of test cases in the input.

For each test case, there's one line with a non-empty string of lowercase Latin letters a.

The total sum of lengths of strings in all test cases is at most 200 000.

Output

For each test case, in the first line, you should print m: the smallest number of steps to make a empty. Each of the following m lines should contain two integers l_i, r_i (1 ≤ l_i ≤ r_i ≤ |a|), denoting, that the i-th step is removing the characters from index l_i to r_i in the current string. (indices are numbered starting from 1). 

Note that after the deletion of the substring, indices of remaining characters may change, and r_i should be at most the current length of a.

If there are several possible solutions, you can print any.

Example

Input


4
aabbcc
aaabbb
aaa
abacad


Output


3
3 3
2 4
1 2
3
3 4
2 3
1 2
3
1 1
1 1
1 1
1
1 6

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
template <typename T, typename U>
std::istream &operator>>(std::istream &i, pair<T, U> &p) {
  i >> p.first >> p.second;
  return i;
}
template <typename T>
std::istream &operator>>(std::istream &i, vector<T> &t) {
  for (auto &v : t) {
    i >> v;
  }
  return i;
}
template <typename T, typename U>
std::ostream &operator<<(std::ostream &o, const pair<T, U> &p) {
  o << p.first << ' ' << p.second;
  return o;
}
template <typename T>
std::ostream &operator<<(std::ostream &o, const vector<T> &t) {
  if (t.empty()) o << '\n';
  for (size_t i = 0; i < t.size(); ++i) {
    o << t[i] << " \n"[i == t.size() - 1];
  }
  return o;
}
template <typename T>
using minheap = priority_queue<T, vector<T>, greater<T>>;
template <typename T>
using maxheap = priority_queue<T, vector<T>, less<T>>;
unsigned int logceil(long long first) {
  return first ? 8 * sizeof(long long) - __builtin_clzll(first) : 0;
}
namespace std {
template <typename T, typename U>
struct hash<pair<T, U>> {
  hash<T> t;
  hash<U> u;
  size_t operator()(const pair<T, U> &p) const {
    return t(p.first) ^ (u(p.second) << 7);
  }
};
}  // namespace std
template <typename T, typename F>
T bsh(T l, T h, const F &f) {
  T r = -1, m;
  while (l <= h) {
    m = (l + h) / 2;
    if (f(m)) {
      l = m + 1;
      r = m;
    } else {
      h = m - 1;
    }
  }
  return r;
}
template <typename F>
double bshd(double l, double h, const F &f, double p = 1e-9) {
  unsigned int r = 3 + (unsigned int)log2((h - l) / p);
  while (r--) {
    double m = (l + h) / 2;
    if (f(m)) {
      l = m;
    } else {
      h = m;
    }
  }
  return (l + h) / 2;
}
template <typename T, typename F>
T bsl(T l, T h, const F &f) {
  T r = -1, m;
  while (l <= h) {
    m = (l + h) / 2;
    if (f(m)) {
      h = m - 1;
      r = m;
    } else {
      l = m + 1;
    }
  }
  return r;
}
template <typename F>
double bsld(double l, double h, const F &f, double p = 1e-9) {
  unsigned int r = 3 + (unsigned int)log2((h - l) / p);
  while (r--) {
    double m = (l + h) / 2;
    if (f(m)) {
      h = m;
    } else {
      l = m;
    }
  }
  return (l + h) / 2;
}
template <typename T>
T gcd(T a, T b) {
  if (a < b) swap(a, b);
  return b ? gcd(b, a % b) : a;
}
template <typename T>
class vector2 : public vector<vector<T>> {
 public:
  vector2() {}
  vector2(size_t a, size_t b, T t = T())
      : vector<vector<T>>(a, vector<T>(b, t)) {}
};
template <typename T>
class vector3 : public vector<vector2<T>> {
 public:
  vector3() {}
  vector3(size_t a, size_t b, size_t c, T t = T())
      : vector<vector2<T>>(a, vector2<T>(b, c, t)) {}
};
template <typename T>
class vector4 : public vector<vector3<T>> {
 public:
  vector4() {}
  vector4(size_t a, size_t b, size_t c, size_t d, T t = T())
      : vector<vector3<T>>(a, vector3<T>(b, c, d, t)) {}
};
template <typename T>
class vector5 : public vector<vector4<T>> {
 public:
  vector5() {}
  vector5(size_t a, size_t b, size_t c, size_t d, size_t e, T t = T())
      : vector<vector4<T>>(a, vector4<T>(b, c, d, e, t)) {}
};
auto seed = chrono::high_resolution_clock::now().time_since_epoch().count();
std::mt19937 rng(seed);
using random_int = std::uniform_int_distribution<int>;
using random_ll = std::uniform_int_distribution<long long>;
struct TimeLimit {
  TimeLimit(double seconds) : s(seconds - 0.2), last(clock()), mx(0) {}
  operator bool() const {
    clock_t cur = clock();
    mx = max(mx, cur - last);
    last = cur;
    return clock() < s * CLOCKS_PER_SEC - 1.5 * mx;
  }
  double s;
  mutable clock_t last, mx;
};
template <typename ValueType, typename TagType,
          void (*combineTag)(TagType &, TagType),
          void (*applyTag)(ValueType &, TagType, unsigned int),
          ValueType (*combineValues)(ValueType, ValueType)>
struct LSegTree {
  LSegTree(const vector<ValueType> &data, const ValueType &nullValue,
           const TagType &nullTag)
      : n(1 << logceil(data.size())),
        nullValue(nullValue),
        nullTag(nullTag),
        T(2 * n, {nullValue, nullTag}) {
    for (int i = 0; i < data.size(); ++i) T[n + i].first = data[i];
    for (unsigned int i = n - 1; i > 0; i--)
      T[i].first = combineValues(T[i << 1].first, T[i << 1 | 1].first);
  }
  LSegTree(unsigned int size, const ValueType &nullValue,
           const TagType &nullTag)
      : n(1 << logceil(size)),
        nullValue(nullValue),
        nullTag(nullTag),
        T(2 * n, {nullValue, nullTag}) {
    for (unsigned int i = n - 1; i > 0; i--)
      T[i].first = combineValues(T[i << 1].first, T[i << 1 | 1].first);
  }
  inline void put(unsigned int first, const TagType &n) {
    put(first, first, n);
  }
  inline void put(unsigned int from, unsigned int to, TagType v) {
    putInner(from, to, v, 1, n);
  }
  inline ValueType operator[](pair<unsigned int, unsigned int> first) {
    return get(first.first, first.second);
  }
  inline ValueType operator[](unsigned int first) { return get(first, first); }
  inline ValueType get(unsigned int first) { return get(first, first); }
  inline ValueType get(unsigned int from, unsigned int to) {
    return getInner(from, to, 1, n);
  }
  void pushAllDown() {
    unsigned int s = n, t = 1;
    while (s) {
      for (unsigned int i = t; i < (t << 1); ++i) pushTagDown(i, s);
      s >>= 1;
      t <<= 1;
    }
  }
  inline ValueType rawGet(unsigned int first) { return T[n + first].first; }
  void putInner(unsigned int from, unsigned int to, TagType v, unsigned int i,
                unsigned int s) {
    vector<int> Q;
    unsigned int r = i;
    while (true) {
      if (from == 0 && to == s - 1) {
        applyTag(T[i].first, v, s);
        combineTag(T[i].second, v);
        break;
      }
      pushTagDown(i, s);
      s >>= 1;
      i <<= 1;
      if (from & s) {
        from ^= s;
        to ^= s;
        i ^= 1;
      } else if (to & s) {
        putInner(0, to ^ s, v, i | 1, s);
        to = s - 1;
      }
    }
    while (i != r) {
      T[i >> 1].first = combineValues(T[i].first, T[i ^ 1].first);
      i >>= 1;
    }
  }
  ValueType getInner(unsigned int from, unsigned int to, unsigned int i,
                     unsigned int s) {
    while (true) {
      if (from == 0 && to == s - 1) {
        return T[i].first;
      }
      pushTagDown(i, s);
      s >>= 1;
      i <<= 1;
      if (to & s) {
        to ^= s;
        if (from & s) {
          from ^= s;
          i |= 1;
        } else {
          auto a = getInner(from, s - 1, i, s), b = getInner(0, to, i | 1, s);
          return combineValues(a, b);
        }
      }
    }
  }
  template <typename Pred>
  unsigned int longestSuffix(unsigned int first, Pred pred) {
    ValueType value = nullValue;
    return longestSuffixInner2(first, 1, 0, n, value, pred);
  }
  template <typename Pred>
  unsigned int longestSuffixInner(unsigned int i, unsigned int l,
                                  unsigned int r, ValueType &curValue,
                                  Pred pred) {
    if (l + 1 != r) pushTagDown(i, r - l);
    ValueType nextValue = combineValues(T[i].first, curValue);
    if (pred(nextValue)) {
      curValue = nextValue;
      return l;
    }
    if (l + 1 == r) return r;
    unsigned int s =
        longestSuffixInner(i << 1 | 1, (l + r) / 2, r, curValue, pred);
    if (s == (l + r) / 2) {
      return longestSuffixInner(i << 1, l, (l + r) / 2, curValue, pred);
    } else {
      return s;
    }
  }
  template <typename Pred>
  unsigned int longestSuffixInner2(unsigned int first, unsigned int i,
                                   unsigned int l, unsigned int r,
                                   ValueType &curValue, Pred pred) {
    if (first >= r - 1) {
      return longestSuffixInner(i, l, r, curValue, pred);
    }
    if (l + 1 == r) {
      ValueType nextValue = combineValues(T[i].first, curValue);
      if (pred(nextValue)) {
        curValue = nextValue;
        return l;
      } else
        return r;
    }
    pushTagDown(i, r - l);
    unsigned int m = (l + r) / 2;
    if (first < m) {
      return longestSuffixInner2(first, i << 1, l, (l + r) / 2, curValue, pred);
    } else {
      unsigned int s = longestSuffixInner2(first, i << 1 | 1, (l + r) / 2, r,
                                           curValue, pred);
      if (s == (l + r) / 2) {
        return longestSuffixInner(i << 1, l, (l + r) / 2, curValue, pred);
      } else {
        return s;
      }
    }
  }
  template <typename Pred>
  unsigned int longestPrefix(unsigned int first, Pred pred) {
    ValueType value = nullValue;
    return longestPrefixInner2(first, 1, 0, n, value, pred) - 1;
  }
  template <typename Pred>
  unsigned int longestPrefixInner(unsigned int i, unsigned int l,
                                  unsigned int r, ValueType &curValue,
                                  Pred pred) {
    if (l + 1 != r) pushTagDown(i, r - l);
    ValueType nextValue = combineValues(T[i].first, curValue);
    if (pred(nextValue)) {
      curValue = nextValue;
      return r;
    }
    if (l + 1 == r) return l;
    unsigned int s = longestPrefixInner(i << 1, l, (l + r) / 2, curValue, pred);
    return s == (l + r) / 2
               ? longestPrefixInner(i << 1 | 1, (l + r) / 2, r, curValue, pred)
               : s;
  }
  template <typename Pred>
  unsigned int longestPrefixInner2(unsigned int first, unsigned int i,
                                   unsigned int l, unsigned int r,
                                   ValueType &curValue, Pred pred) {
    if (first <= l) {
      return longestPrefixInner(i, l, r, curValue, pred);
    }
    if (l + 1 == r) {
      ValueType nextValue = combineValues(T[i].first, curValue);
      if (pred(nextValue)) {
        curValue = nextValue;
        return r;
      } else
        return l;
    }
    pushTagDown(i, r - l);
    unsigned int m = (l + r) / 2;
    if (first >= m) {
      return longestPrefixInner2(first, i << 1 | 1, m, r, curValue, pred);
    } else {
      unsigned int s = longestPrefixInner2(first, i << 1, l, m, curValue, pred);
      return s == m ? longestPrefixInner(i << 1 | 1, m, r, curValue, pred) : s;
    }
  }
  void pushTagDown(unsigned int i, unsigned int s) {
    applyTag(T[i << 1].first, T[i].second, s >> 1);
    applyTag(T[i << 1 | 1].first, T[i].second, s >> 1);
    combineTag(T[i << 1].second, T[i].second);
    combineTag(T[i << 1 | 1].second, T[i].second);
    T[i].second = nullTag;
  }
  unsigned int n;
  ValueType nullValue;
  TagType nullTag;
  vector<pair<ValueType, TagType>> T;
};
template <typename F>
void LAddOp(F &a, F b) {
  a += b;
}
template <typename F>
void LAddOp2(F &a, F b, unsigned int) {
  a += b;
}
template <typename F>
F LMinOp(F a, F b) {
  return std::min(a, b);
}
template <typename F>
F LMaxOp(F a, F b) {
  return std::max(a, b);
}
template <typename T>
T LSumOp(T a, T b) {
  return a + b;
}
template <typename T>
void LAssignOp(T &a, T b) {
  if (b != 0) a = b;
};
template <typename T>
void LAssignOp2(T &a, T b, unsigned int) {
  if (b != 0) a = b;
};
template <typename T>
void LAssignMultOp(T &a, T b, unsigned int s) {
  if (b != 0) a = b * s;
};
template <typename T>
using LAddMaxTree = LSegTree<T, T, LAddOp<T>, LAddOp2<T>, LMaxOp<T>>;
template <typename T>
using LAddMinTree = LSegTree<T, T, LAddOp<T>, LAddOp2<T>, LMinOp<T>>;
template <typename T>
using AddSumTree = LSegTree<T, T, LAddOp<T>, LAddOp2<T>, LSumOp<T>>;
template <typename T>
using AssignSumTree = LSegTree<T, T, LAssignOp<T>, LAssignMultOp<T>, LSumOp<T>>;
template <typename T>
using AssignMaxTree = LSegTree<T, T, LAssignOp<T>, LAssignOp2<T>, LMaxOp<T>>;
class DDreamoonLikesStrings {
 public:
  void solve(istream &cin, ostream &cout) {
    int T;
    cin >> T;
    for (int t = 0; t < T; ++t) {
      string S;
      cin >> S;
      int N = S.size(), j = 0;
      vector<int> Same, C(26, 0), stack, Ones(N, 2);
      vector<std::pair<int, int>> Solve;
      AssignSumTree<int> ASS(Ones, 0, 0);
      for (int i = 1; i < N; ++i) {
        if (S[i] == S[i - 1]) {
          Same.push_back(i);
          C[S[i] - 'a']++;
        }
      }
      auto add = [&](int a, int b) {
        int first = a == 0 ? 0 : ASS.get(0, a - 1);
        int second = ASS.get(0, b);
        Solve.push_back({first - a + 1, second - b - 1});
        ASS.put(a, b, 1);
      };
      int mx = *max_element(C.begin(), C.end());
      int sm = Same.size();
      while (true) {
        int X = stack.size();
        if (X >= 2 && S[stack[X - 1]] != S[stack[X - 2]]) {
          C[S[stack[X - 1]] - 'a']--;
          C[S[stack[X - 2]] - 'a']--;
          int newMx = *max_element(C.begin(), C.end());
          if (max(mx, (sm + 1) / 2) != max(newMx + 1, (sm + 1) / 2)) {
            C[S[stack[X - 1]] - 'a']++;
            C[S[stack[X - 2]] - 'a']++;
          } else {
            add(stack[X - 2], stack[X - 1] - 1);
            stack.pop_back();
            stack.pop_back();
            mx = newMx;
            sm -= 2;
            continue;
          }
        }
        if (j != Same.size()) {
          stack.push_back(Same[j++]);
        } else {
          break;
        }
      }
      for (int i : stack) add(0, i - 1);
      add(0, N - 1);
      cout << Solve.size() << '\n';
      for (std::pair<int, int> soln : Solve) cout << soln << '\n';
    }
  }
};
int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);
  cout.tie(nullptr);
  DDreamoonLikesStrings solver;
  std::istream &in(std::cin);
  std::ostream &out(std::cout);
  solver.solve(in, out);
  return 0;
}