1 1 1
1000000000
2 1
 20 2 15
12698951 55128070 116962690 156763505 188535242 194018601 269939893 428710623 442819431 483000923 516768937 552903993 633087286 656092270 671535141 714291344 717660646 846508634 879748146 937368929
2 7
1 2
2 4
1 19
1 12
1 5
2 18
2 11
1 16
2 1
2 3
2 19
1 17
2 9
2 6
 6 3 10
62417580 78150524 410053501 582708235 630200761 760672946
2 2
1 5
1 2
1 4
2 4
2 1
2 1
1 6
2 5
2 6

NO
 NO
NO
NO
NO
NO
NO
YES
NO
NO
 NO
YES
NO
NO
YES
YES

import java.util.*;

public class Main {

    public static void main(String[] args) {
        LinkedHashMap<Integer, Integer> t = new LinkedHashMap<>();
        LinkedHashMap<Integer, Integer> temp = new LinkedHashMap<>();
        int n;
        int k;
        int q;

        Scanner scanner = new Scanner(System.in);

        n = scanner.nextInt();
        k = scanner.nextInt();
        q = scanner.nextInt();

        for (int i=0; i<n; i++){
            t.put(i,scanner.nextInt());
        }

        for (int i=0; i<q; i++){
            int v1 = scanner.nextInt();
            int v2 = scanner.nextInt() - 1;
            int size = temp.size();
            if (v1 == 1){
                if (size < k) {
                    temp.put(v2, t.get(v2));
                }else {
                    temp = sortByValues(temp);
                    int[] mapKeys = new int[size];
                    int[] mapValues = new int[size];
                    int pos = 0;
                    for (int key : temp.keySet()) {
                        mapKeys[pos++] = key;
                    }

                    pos = 0;
                    for (int values : temp.values()) {
                        mapValues[pos++] = values;
                    }

                    if (mapValues[size-1]<t.get(v2)){
                        temp.remove(mapKeys[size-1]);
                        temp.put(v2, t.get(v2));
                    }
                }
            }else {
                boolean f = temp.containsKey(v2);
                if (!f) {
                    System.out.println("NO");
                } else {
                    if (temp.size() <= k) {
                        System.out.println("YES");
                    } else {
                        temp = sortByValues(temp);
                        int idx = 0;
                        for (Map.Entry<Integer, Integer> e: temp.entrySet()){
                            if (e.getKey() == v2){
                                if (idx < k){
                                    System.out.println("YES");
                                }else {
                                    System.out.println("NO");
                                }
                                break;
                            }
                            idx++;
                        }
                    }
                }
            }
        }

    }

    public static <K extends Comparable,V extends Comparable> LinkedHashMap<K,V> sortByValues(LinkedHashMap<K,V> map) {
        List<Map.Entry<K, V>> entries = new LinkedList<>(map.entrySet());

        Collections.sort(entries, (o1, o2) -> o2.getValue().compareTo(o1.getValue()));

        LinkedHashMap<K,V> sortedMap = new LinkedHashMap<K,V>();

        for(Map.Entry<K,V> entry: entries){
            sortedMap.put(entry.getKey(), entry.getValue());
        }

        return sortedMap;
    }
}