Problem: Polycarp has a lot of work to do. Recently he has learned a new time management rule: "if a task takes five minutes or less, do it immediately". Polycarp likes the new rule, however he is not sure that five minutes is the optimal value. He supposes that this value d should be chosen based on existing task list.

Polycarp has a list of n tasks to complete. The i-th task has difficulty p_i, i.e. it requires exactly p_i minutes to be done. Polycarp reads the tasks one by one from the first to the n-th. If a task difficulty is d or less, Polycarp starts the work on the task immediately. If a task difficulty is strictly greater than d, he will not do the task at all. It is not allowed to rearrange tasks in the list. Polycarp doesn't spend any time for reading a task or skipping it.

Polycarp has t minutes in total to complete maximum number of tasks. But he does not want to work all the time. He decides to make a break after each group of m consecutive tasks he was working on. The break should take the same amount of time as it was spent in total on completion of these m tasks.

For example, if n=7, p=[3, 1, 4, 1, 5, 9, 2], d=3 and m=2 Polycarp works by the following schedule:

  * Polycarp reads the first task, its difficulty is not greater than d (p_1=3 ≤ d=3) and works for 3 minutes (i.e. the minutes 1, 2, 3); 
  * Polycarp reads the second task, its difficulty is not greater than d (p_2=1 ≤ d=3) and works for 1 minute (i.e. the minute 4); 
  * Polycarp notices that he has finished m=2 tasks and takes a break for 3+1=4 minutes (i.e. on the minutes 5, 6, 7, 8); 
  * Polycarp reads the third task, its difficulty is greater than d (p_3=4 > d=3) and skips it without spending any time; 
  * Polycarp reads the fourth task, its difficulty is not greater than d (p_4=1 ≤ d=3) and works for 1 minute (i.e. the minute 9); 
  * Polycarp reads the tasks 5 and 6, skips both of them (p_5>d and p_6>d); 
  * Polycarp reads the 7-th task, its difficulty is not greater than d (p_7=2 ≤ d=3) and works for 2 minutes (i.e. the minutes 10, 11); 
  * Polycarp notices that he has finished m=2 tasks and takes a break for 1+2=3 minutes (i.e. on the minutes 12, 13, 14). 



Polycarp stops exactly after t minutes. If Polycarp started a task but has not finished it by that time, the task is not considered as completed. It is allowed to complete less than m tasks in the last group. Also Polycarp considers acceptable to have shorter break than needed after the last group of tasks or even not to have this break at all — his working day is over and he will have enough time to rest anyway.

Please help Polycarp to find such value d, which would allow him to complete maximum possible number of tasks in t minutes.

Input

The first line of the input contains single integer c (1 ≤ c ≤ 5 ⋅ 10^4) — number of test cases. Then description of c test cases follows. Solve test cases separately, test cases are completely independent and do not affect each other.

Each test case is described by two lines. The first of these lines contains three space-separated integers n, m and t (1 ≤ n ≤ 2 ⋅ 10^5, 1 ≤ m ≤ 2 ⋅ 10^5, 1 ≤ t ≤ 4 ⋅ 10^{10}) — the number of tasks in Polycarp's list, the number of tasks he can do without a break and the total amount of time Polycarp can work on tasks. The second line of the test case contains n space separated integers p_1, p_2, ..., p_n (1 ≤ p_i ≤ 2 ⋅ 10^5) — difficulties of the tasks.

The sum of values n for all test cases in the input does not exceed 2 ⋅ 10^5.

Output

Print c lines, each line should contain answer for the corresponding test case — the maximum possible number of tasks Polycarp can complete and the integer value d (1 ≤ d ≤ t) Polycarp should use in time management rule, separated by space. If there are several possible values d for a test case, output any of them.

Examples

Input

4
5 2 16
5 6 1 4 7
5 3 30
5 6 1 4 7
6 4 15
12 5 15 7 20 17
1 1 50
100


Output

3 5
4 7
2 10
0 25


Input

3
11 1 29
6 4 3 7 5 3 4 7 3 5 3
7 1 5
1 1 1 1 1 1 1
5 2 18
2 3 3 7 5


Output

4 3
3 1
4 5

Note

In the first test case of the first example n=5, m=2 and t=16. The sequence of difficulties is [5, 6, 1, 4, 7]. If Polycarp chooses d=5 then he will complete 3 tasks. Polycarp will work by the following schedule:

  * Polycarp reads the first task, its difficulty is not greater than d (p_1=5 ≤ d=5) and works for 5 minutes (i.e. the minutes 1, 2, ..., 5); 
  * Polycarp reads the second task, its difficulty is greater than d (p_2=6 > d=5) and skips it without spending any time; 
  * Polycarp reads the third task, its difficulty is not greater than d (p_3=1 ≤ d=5) and works for 1 minute (i.e. the minute 6); 
  * Polycarp notices that he has finished m=2 tasks and takes a break for 5+1=6 minutes (i.e. on the minutes 7, 8, ..., 12); 
  * Polycarp reads the fourth task, its difficulty is not greater than d (p_4=4 ≤ d=5) and works for 4 minutes (i.e. the minutes 13, 14, 15, 16); 
  * Polycarp stops work because of t=16. 



In total in the first test case Polycarp will complete 3 tasks for d=5. He can't choose other value for d to increase the number of completed tasks.

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
class SegmentTree {
 public:
  SegmentTree(int _size) { root = new NodeST(0, _size - 1); }
  void Increase(int pos) { _Increase(root, pos); }
  int GetSum(int tl, int tr) const {
    if (tl > tr) {
      return 0;
    } else {
      return _GetSum(root, tl, tr);
    }
  }

 private:
  struct NodeST {
    int l, r;
    NodeST *left, *right;
    int sum;
    NodeST(int tl, int tr) : l(tl), r(tr) {
      if (tl == tr) {
        sum = 0;
      } else {
        int mid = (l + r) / 2;
        left = new NodeST(tl, mid);
        right = new NodeST(mid + 1, tr);
        sum = 0;
      }
    }
  };
  NodeST* root;
  void _Increase(NodeST* vrt, int pos) {
    if (vrt->l == vrt->r) {
      ++vrt->sum;
    } else {
      int mid = (vrt->l + vrt->r) / 2;
      if (pos <= mid) {
        _Increase(vrt->left, pos);
      } else {
        _Increase(vrt->right, pos);
      }
      vrt->sum = vrt->left->sum + vrt->right->sum;
    }
  }
  int _GetSum(NodeST* vrt, int tl, int tr) const {
    if (tl > tr) {
      return 0;
    }
    if (tl == vrt->l && tr == vrt->r) {
      return vrt->sum;
    } else {
      int mid = (vrt->l + vrt->r) / 2;
      return _GetSum(vrt->left, tl, min(mid, tr)) +
             _GetSum(vrt->right, max(mid + 1, tl), tr);
    }
  }
};
struct Node {
  int cnt = 1;
  int prior;
  long long value = 0;
  long long sum = 0;
  Node* l = nullptr;
  Node* r = nullptr;
  Node(long long value_) {
    cnt = 1;
    sum = 0;
    prior = rand() * rand();
    value = value_;
    l = nullptr;
    r = nullptr;
  }
};
int get_cnt(Node* root) {
  if (root == nullptr) {
    return 0;
  } else {
    return root->cnt;
  }
}
long long get_sum(Node* root) {
  if (root == nullptr) {
    return 0;
  } else {
    return root->sum;
  }
}
void update_node(Node* root) {
  if (root == nullptr) {
    return;
  }
  root->cnt = get_cnt(root->l) + get_cnt(root->r) + 1;
  root->sum = get_sum(root->l) + get_sum(root->r) + root->value;
}
void merge_node(Node*& root, Node* l, Node* r) {
  if (l == nullptr || r == nullptr) {
    root = (l == nullptr ? r : l);
  } else if (l->prior < r->prior) {
    root = r;
    merge_node(r->l, l, r->l);
  } else {
    root = l;
    merge_node(l->r, l->r, r);
  }
  update_node(root);
}
void split_node(Node* root, Node*& l, Node*& r, int left_size) {
  if (root == nullptr) {
    l = nullptr;
    r = nullptr;
    return;
  }
  if (get_cnt(root->l) >= left_size) {
    r = root;
    split_node(root->l, l, root->l, left_size);
  } else if (left_size == get_cnt(root->l) + 1) {
    l = root;
    r = root->r;
    root->r = nullptr;
  } else {
    l = root;
    split_node(root->r, root->r, r, left_size - get_cnt(root->l) - 1);
  }
  update_node(l);
  update_node(r);
}
long long get_sum(Node*& root, int l, int r) {
  Node* left = nullptr;
  Node* middle = nullptr;
  Node* right = nullptr;
  split_node(root, middle, right, r);
  split_node(middle, left, middle, l);
  long long result = get_sum(middle);
  merge_node(middle, middle, right);
  merge_node(root, left, middle);
  return result;
}
void insert_node(Node*& root, long long value, int pos) {
  Node* left = nullptr;
  Node* right = nullptr;
  split_node(root, left, right, pos);
  Node* middle = new Node(value);
  merge_node(middle, middle, right);
  merge_node(root, left, middle);
}
void print_node(Node* root) {
  if (root == nullptr) {
    return;
  }
  print_node(root->l);
  cout << root->value << endl;
  print_node(root->r);
}
int main() {
  srand(time(NULL));
  ios::sync_with_stdio(false);
  cin.tie(nullptr);
  int n_tests;
  cin >> n_tests;
  while (n_tests--) {
    int n, m;
    long long t;
    cin >> n >> m >> t;
    vector<pair<long long, int> > arr(n);
    for (int i = 0; i < n; ++i) {
      long long value;
      cin >> value;
      arr[i] = make_pair(value, i);
    }
    sort(arr.begin(), arr.end());
    int max_tasks = 0;
    int max_d = 1;
    Node* treap = nullptr;
    SegmentTree index_counter(n);
    for (int i = 0; i < n; ++i) {
      int id, pos;
      long long value;
      value = arr[i].first;
      while (i < n && arr[i].first == value) {
        id = arr[i].second;
        index_counter.Increase(id);
        pos = index_counter.GetSum(0, id - 1);
        insert_node(treap, value, pos);
        ++i;
      }
      --i;
      int k_l = 0, k_r = (get_cnt(treap) + m) / m, k_m;
      while (k_r - k_l > 1) {
        k_m = (k_l + k_r) >> 1;
        int batch_size = k_m * m;
        long long sum = get_sum(treap, 0, batch_size);
        if (2LL * sum <= t) {
          k_l = k_m;
        } else {
          k_r = k_m;
        }
      }
      int k = k_l;
      int batch_size = k * m;
      long long sum = get_sum(treap, 0, batch_size);
      long long next_time = t - 2LL * sum;
      int l = 0, r = min(m, get_cnt(treap) - batch_size) + 1, middle;
      while (r - l > 1) {
        middle = (l + r) >> 1;
        long long part_sum = get_sum(treap, batch_size, batch_size + middle);
        if (part_sum <= next_time) {
          l = middle;
        } else {
          r = middle;
        }
      }
      int possible_tasks = batch_size + l;
      if (possible_tasks > max_tasks) {
        max_tasks = possible_tasks;
        max_d = value;
      }
    }
    cout << max_tasks << " " << max_d << endl;
  }
  return 0;
}