#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;
}
