#include<bits/stdc++.h>
using namespace std;
 
int main(){
    int tc;
    cin >> tc;
    while (tc--){
        string s;
        cin >> s;
        sort(s.begin(), s.end());
        reverse(s.begin(), s.end());
        cout << s << '\n';
    }
}

from math import gcd
for _ in range(int(input())):
    a, b, k = map(int, input().split())
    g = gcd(a, b)
    print(1 if a // g <= k and b // g <= k else 2)

def good(x):
    return x % 2 > 0 and x % 3 > 0 and x % 5 > 0 and x % 7 > 0
 
def get_naive(x):
    ans = 0
    for i in range(x):
        if good(i):
            ans += 1
    return ans
 
def get(r):
    return (r // 210) * get_naive(210) + get_naive(r % 210)
 
t = int(input())
for i in range(t):
    l, r = map(int, input().split())
    print(get(r+1) - get(l))

for _ in range(int(input())):
    l, r = map(int, input().split())
 
    def f(x):
        res = 0
        ps = [2, 3, 5, 7]
        for mask in range(16):
            m = 1
            sg = 1
            for i in range(4):
                if (mask >> i) & 1:
                    m *= ps[i]
                    sg = -sg
            res += sg * (x // m)
        return res
    
    print(f(r) - f(l - 1))

#include <bits/stdc++.h>
 
using namespace std;
 
using pt = pair<int, int>;
 
const int MOD = 998244353;
 
int add(int x, int y) {
   x += y;
   if (x >= MOD) x -= MOD;
   if (x < 0) x += MOD;
   return x;
}
 
int mul(int x, int y) {
  return x * 1LL * y % MOD;
}
 
int binpow(int x, int y) {
  int z = 1;
  while (y) {
    if (y & 1) z = mul(z, x);
    x = mul(x, x);
    y >>= 1;
  }
  return z;
}
 
int divide(int x, int y) {
  return mul(x, binpow(y, MOD - 2));
}
 
int main() {
  ios::sync_with_stdio(false); cin.tie(0);
  int n, m;
  cin >> n >> m;
  vector<vector<pt>> a(m + 1);
  for (int i = 0; i < n; ++i) {
    int l, r, p, q;
    cin >> l >> r >> p >> q;
    a[r].emplace_back(l - 1, divide(p, q));
  }
  vector<int> pr(m + 1);
  pr[0] = 1;
  for (int i = 1; i <= m; ++i) {
    int cur = 1;
    for (auto [_, p] : a[i]) cur = mul(cur, add(1, -p));
    pr[i] = mul(pr[i - 1], cur);
  }
  vector<int> dp(m + 1);
  dp[0] = 1;
  for (int i = 1; i <= m; ++i) {
    for (auto [l, p] : a[i]) { 
      int cur = divide(pr[i], pr[l]);
      cur = divide(cur, add(1, -p));
      cur = mul(cur, p);
      dp[i] = add(dp[i], mul(dp[l], cur));
    }
  }
  cout << dp[m] << endl;  
}

#include <bits/stdc++.h>
 
using namespace std;
 
using pt = pair<int, int>;
 
const int MOD = 998244353;
 
int add(int x, int y) {
     x += y;
     if (x >= MOD) x -= MOD;
     if (x < 0) x += MOD;
     return x;
}
 
int mul(int x, int y) {
    return x * 1LL * y % MOD;
}
 
int binpow(int x, int y) {
    int z = 1;
    while (y) {
        if (y & 1) z = mul(z, x);
        x = mul(x, x);
        y >>= 1;
    }
    return z;
}
 
int divide(int x, int y) {
    return mul(x, binpow(y, MOD - 2));
}
 
int main() {
    ios::sync_with_stdio(false); cin.tie(0);
    int n, m;
    cin >> n >> m;
    vector<vector<pt>> a(m + 1);
    vector<int> dp(m + 1);
    dp[0] = 1;
    for (int i = 0; i < n; ++i) {
        int l, r, p, q;
        cin >> l >> r >> p >> q;
        int val = divide(p, q);
        a[r].emplace_back(l - 1, val);
        dp[0] = mul(dp[0], add(1, -val));
    }
    for (int i = 1; i <= m; ++i) {
        for (auto [l, p] : a[i]) { 
            int cur = dp[l];
            cur = divide(cur, add(1, -p));
            cur = mul(cur, p);
            dp[i] = add(dp[i], cur);
        }
    }
    cout << dp[m] << endl;  
}

#include<bits/stdc++.h>
using namespace std;
 
#define int long long
 
const int MOD = 998'244'353;
 
void solve(){
    int n, x;
    cin >> n >> x;
    // need sum(mx + 1 - ai) <= mx + 1
    // start with 1, 2, 3, ... n
    // min sum + 1 is n + 1
 
    if (n == 1){
        cout << x << '\n';
        return;
    }
 
    int s_cur = n * (n + 1) / 2;
    int need = s_cur - (n + 1);
 
    // leads to n is O(sqrt(s))
    if (n + need > x){
        cout << 0 << '\n';
        return;
    }
 
    // so we can do dp[sum] knapsack
 
    vector<int> dp(x + 1);
    dp[0] = 1;
 
    // for -1 and 0
    for (int j = 0; j < 2; j++){
        for (int i = 0; i < x; i++){
            dp[i + 1] = (dp[i + 1] + dp[i]) % MOD;
        }
    }
 
    for (int i = 1; i <= n - 2; i++){
        for (int j = 0; j < x; j++){
            // increase sum by i -> mx increase by 1 + i
            if (j + i + 1 <= x){
                dp[j + i + 1] = (dp[j + i + 1] + dp[j]) % MOD;
            }
        }
    }
 
    int ans = 0;
    for (int i = 0; i <= x; i++){
        int cur = n + need + i;
        if (cur > x){
            break;
        }
        ans = (ans + dp[i]) % MOD;
    }
 
    cout << ans << '\n';
}
 
signed main()
{
#ifdef FELIX
    auto _clock_start = chrono::high_resolution_clock::now();
#endif
    ios_base::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
 
    int t = 1;
    cin >> t;
    while(t--){
        solve();
    }
 
#ifdef FELIX
    cerr << "Executed in " << chrono::duration_cast<chrono::milliseconds>(
        chrono::high_resolution_clock::now()
            - _clock_start).count() << "ms." << endl;
#endif
    return 0;
}

#include <bits/stdc++.h>
 
using namespace std;
 
#define forn(i, n) for(int i = 0; i < int(n); i++) 
 
const int INF = 1e8;
const string al = "docker";
 
int main(){
    cin.tie(0);
    ios::sync_with_stdio(false);
    int tc;
    cin >> tc;
    while (tc--){
        string s;
        cin >> s;
        int n = s.size();
        int mx = n / 6;
        int m;
        cin >> m;
        vector<int> dx(mx + 2);
        forn(i, m){
            int l, r;
            cin >> l >> r;
            r = min(r, mx);
            if (l > r) continue;
            ++dx[l];
            --dx[r + 1];
        }
        forn(i, mx + 1) dx[i + 1] += dx[i];
 
        int cur = 0;
        vector<int> dif(max(0, n - 5));
        forn(i, n - 5){
            forn(j, 6)
                dif[i] += s[i + j] != al[j];
            cur += dif[i] == 0;
        }
 
        int mxcnt = *max_element(dx.begin(), dx.end());
        int k = -1;
        int ans = INF;
        forn(i, mx + 1){
            if (dx[i] != mxcnt) continue;
            if (i <= cur){
                ans = min(ans, cur - i);
                continue;
            }
            k = i;
            break;
        }
 
        if (k == -1){
            cout << ans << '\n';
            continue;
        }
 
        auto calc = [&](int d){
            vector<pair<long long, int>> dp(n + 1, {(long long)1e18, -1});
            dp[0] = {0, 0};
            forn(i, n){
                dp[i + 1] = min(dp[i + 1], dp[i]);
                if (i + 6 <= n)
                    dp[i + 6] = min(dp[i + 6], {dp[i].first + dif[i] + d, dp[i].second - 1});
            }
            return dp[n];
        };
 
        int l = -INF, r = 0, sv = INF;
        while (l <= r){
            int m = (l + r) / 2;
            auto [val, cnt] = calc(m);
            if (-cnt >= k){
                sv = val - k * 1ll * m;
                l = m + 1;
            }
            else{
                r = m - 1;
            }
        }
        ans = min(ans, sv);
 
        cout << ans << '\n';
    } 
}