#include <cstdio>
#include <iostream>
#include <sstream>
#include <string>
#include <vector>
#include <algorithm>
#include <map>
#include <set>
using namespace std;

int main()
{
    int s;
    cin>>s;
    int y;
    cin>>y;
    int t;
    map<int,vector<int>> mp;
    set<int> st;
    for (int i=1; i<=s; i++) {
        cin>>t;
        if (t>20) {
          mp[t].push_back(i);
          st.insert(t);
        }
    }
    vector<int> num(st.begin(),st.end());
    sort(num.rbegin(),num.rend());
    if (y>st.size()) {
        cout<<num[st.size()-1]<<' ';
        auto it=mp[num[st.size()-1]];
        sort(it.begin(),it.end());
        for (auto a:it) {
          cout<<a<<" ";
        }
    }else {
        cout<<num[y-1]<<' ';
        auto it=mp[num[y-1]];
        sort(it.begin(),it.end());
        for (auto a:it) {
          cout<<a<<" ";
        }
    }

    

}

#include<bits/stdc++.h>
using namespace std;

int main() {
    int s, y; // s: 图片总数, y: 塔子哥的经验值
    cin >> s >> y;

    // 记录出现过的有效分数——用于去重
    unordered_set<int> st;
    // 记录所有有效分数——用于后续排序
    vector<int> items;
    // 建立映射：有效分数 -> 出现下标（图片编号）
    unordered_map<int, vector<int>> mp;

    for (int i = 1; i <= s; i++) {
        int x; // 当前图片的评分
        cin >> x;

        // 筛选出不大于20分的照片
        if (x <= 20)
            continue; // 如果分数不符合条件，跳过

        // 如果该分数已经出现过，记录当前图片的下标
        if (st.count(x)) {
            mp[x].push_back(i);
        } else {
            // 否则，将该分数插入集合并初始化映射
            st.insert(x);
            items.push_back(x);
            mp[x] = vector<int>{ i }; // 初始化下标为当前图片
        }
    }

    // 将所有有效分数进行排序（从大到小）
    sort(items.begin(), items.end(), greater<int>());

    // 筛选符合经验值的分数
    int ans = min((int)items.size(), y); // 确保排名不会超出有效范围
    cout << items[ans - 1] << " "; // 输出排名第y的分数

    // 输出对应的所有图片下标
    int n = mp[items[ans - 1]].size(); // 获取当前分数对应的下标数量
    for (int i = 0; i < n; i++) {
        cout << mp[items[ans - 1]][i] << ((i < n - 1) ? ' ' : '\n'); // 逐个输出下标，最后一个后换行
    }

    return 0;
}

def main():
    import sys
    from collections import defaultdict

    # 读取输入
    input = sys.stdin.read
    data = input().splitlines()
    
    s = int(data[0])  # 图片总数
    y = int(data[1])  # 塔子哥的经验值
    scores = list(map(int, data[2].split()))  # 图片评分列表

    # 记录出现过的有效分数——用于去重
    st = set()
    # 记录所有有效分数——用于后续排序
    items = []
    # 建立映射：有效分数 -> 出现下标（图片编号）
    mp = defaultdict(list)

    for i in range(s):
        x = scores[i]  # 当前图片的评分

        # 筛选出不大于20分的照片
        if x <= 20:
            continue  # 如果分数不符合条件，跳过

        # 如果该分数已经出现过，记录当前图片的下标
        if x in st:
            mp[x].append(i + 1)  # 图片编号从1开始
        else:
            # 否则，将该分数插入集合并初始化映射
            st.add(x)
            items.append(x)
            mp[x].append(i + 1)  # 初始化下标为当前图片编号

    # 将所有有效分数进行排序（从大到小）
    items.sort(reverse=True)

    # 筛选符合经验值的分数
    ans = min(len(items), y)  # 确保排名不会超出有效范围
    print(items[ans - 1], end=" ")  # 输出排名第y的分数

    # 输出对应的所有图片下标
    indices = mp[items[ans - 1]]  # 获取当前分数对应的下标列表
    print(" ".join(map(str, indices)))  # 逐个输出下标

if __name__ == "__main__":
    main()

import java.util.*;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);

        int s = scanner.nextInt(); // 图片总数
        int y = scanner.nextInt(); // 塔子哥的经验值

        // 记录出现过的有效分数——用于去重
        Set<Integer> st = new HashSet<>();
        // 记录所有有效分数——用于后续排序
        List<Integer> items = new ArrayList<>();
        // 建立映射：有效分数 -> 出现下标（图片编号）
        Map<Integer, List<Integer>> mp = new HashMap<>();

        for (int i = 1; i <= s; i++) {
            int x = scanner.nextInt(); // 当前图片的评分

            // 筛选出不大于20分的照片
            if (x <= 20) {
                continue; // 如果分数不符合条件，跳过
            }

            // 如果该分数已经出现过，记录当前图片的下标
            if (st.contains(x)) {
                mp.get(x).add(i);
            } else {
                // 否则，将该分数插入集合并初始化映射
                st.add(x);
                items.add(x);
                mp.put(x, new ArrayList<>(Arrays.asList(i))); // 初始化下标为当前图片
            }
        }

        // 将所有有效分数进行排序（从大到小）
        Collections.sort(items, Collections.reverseOrder());

        // 筛选符合经验值的分数
        int ans = Math.min(items.size(), y); // 确保排名不会超出有效范围
        System.out.print(items.get(ans - 1) + " "); // 输出排名第y的分数

        // 输出对应的所有图片下标
        List<Integer> indices = mp.get(items.get(ans - 1)); // 获取当前分数对应的下标列表
        for (int i = 0; i < indices.size(); i++) {
            System.out.print(indices.get(i) + (i < indices.size() - 1 ? " " : "\n")); // 逐个输出下标，最后一个后换行
        }

        scanner.close(); // 关闭扫描器
    }
}