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.io.*;
import java.util.*;
import java.util.stream.*;
import java.util.function.*;

import static java.lang.StrictMath.*;
import static java.util.stream.Collectors.*;

public class TaskA {

    private static final String INPUT_FILE = "input.txt";
    
    private static final String ONLINE_JUDGE = "ONLINE_JUDGE";

    public static void main(String[] args) {
        boolean oj = System.getProperty(ONLINE_JUDGE) != null;

        try {
            InputReader reader = new InputReader(oj ? System.in : new FileInputStream(INPUT_FILE));
            PrintWriter writer = new PrintWriter(System.out);
            new Solver(reader, writer);
            writer.close();
        }
        catch (IOException e) {
            new RuntimeException(e);
        }
    }
}

class Solver {

    public Solver(InputReader reader, PrintWriter writer) throws IOException {
        n = reader.nextInt();        
        k = reader.nextInt();
        q = reader.nextInt();
        p = new int[n];
        f = new Friend[n];
        for (int i = 0; i < n; ++i) {
            f[i] = new Friend(i, reader.nextInt()-1);
        }

        Arrays.sort(f);
        for (int i = 0; i < n; ++i) {
            p[f[i].id] = i;
        }

        fenwick = new Fenwick(n);

        isOnline = new boolean[n];
        Arrays.fill(isOnline, false);

        for (int i = 0; i < q; ++i) {
            int type = reader.nextInt();
            int id = reader.nextInt()-1;
            if (type == 1) {
                fenwick.inc(p[id]);
                isOnline[id] = true;
            }
            else {
                writer.println(isOnline[id] && fenwick.getSum(p[id]) <= k ? "YES" : "NO");
            }
        }
    }

    private int n;
    private int k;
    private int q;

    private int[] p;
    private Friend[] f;

    private boolean[] isOnline;

    private Fenwick fenwick;
}

class Friend implements Comparable<Friend> {

    public Friend(int id, int ti) {
        this.id = id;
        this.ti = ti;
    }

    @Override
    public int compareTo(Friend other) {
        return other.ti - ti;
    }

    int id;
    int ti;
}

class Fenwick {

    public Fenwick(int n) {
        t = new int[this.n = n];
        Arrays.fill(t, 0);
    }

    public void inc(int i) {
        for (; i < n; i |= i+1) {
            ++t[i];
        }
    }

    public int getSum(int r) {
        int res = 0;
        for (; r >= 0; r = (r & (r+1)) - 1) {
            res += t[r];
        }
        return res;
    }

    private int n;
    private int[] t;
}

class InputReader {
 	
    public BufferedReader reader;
    public StringTokenizer tokenizer;

    public InputReader(InputStream stream) {
        reader = new BufferedReader(new InputStreamReader(stream), 1<<15);
        tokenizer = null;
    }

    public String next() {
        while (tokenizer == null || !tokenizer.hasMoreTokens()) {
            try {
                tokenizer = new StringTokenizer(reader.readLine());
            } catch (IOException e) {
                throw new RuntimeException(e);
            }
        }
        return tokenizer.nextToken();
    }

    public int nextInt() {
        return Integer.parseInt(next());
    }

    public long nextLong() {
        return Long.parseLong(next());
    }

    public double parseDouble() {
        return Double.parseDouble(next());
    }

}
