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.BufferedReader;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.PrintWriter;
import java.lang.reflect.Array;
import java.math.BigInteger;
import java.security.interfaces.DSAKey;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.LinkedList;
import java.util.PriorityQueue;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;
import java.util.StringTokenizer;
import java.util.TreeMap;
import java.util.TreeSet;

public class a {

	public static class in {
		static BufferedReader reader;
		static StringTokenizer tokenizer;

		static void init(InputStream input) {
			reader = new BufferedReader(new InputStreamReader(input));
			tokenizer = new StringTokenizer("");
		}

		static String next() throws IOException {
			while (!tokenizer.hasMoreTokens())
				tokenizer = new StringTokenizer(reader.readLine());
			return tokenizer.nextToken();
		}

		static int nextInt() throws IOException {
			return Integer.parseInt(next());
		}

		static double nextDouble() throws IOException {
			return Double.parseDouble(next());
		}

		static long nextLong() throws IOException {
			return Long.parseLong(next());
		}
	}

	public static long comp(int n, int r) {
		r = Math.min(r, n - r);
		long ans = 1;
		for (int i = 1; i <= r; i++) {
			ans = ans * (long) (n - r + i) / (long) i;
		}
		return ans;

	}

	public static class node implements Comparable<node> {

		int id;
		int t;

		node(int id, int t) {
			this.id = id;
			this.t = t;

		}

		@Override
		public int compareTo(node o) {
			if (o.t < t)
				return 1;
			else if (o.t > t)
				return -1;
			return 0;
		}

	}

	public static long gcd(int x, int y) {
		if (y == 0)
			return x;
		return gcd(y, x % y);
	}

	public static int z[];

	public static void Z_algorithm(char[] a, ArrayList<Long> arr) {
		z = new int[a.length];
		z[0] = a.length;
		int l = 0, r = 0;
		for (int i = 1; i < a.length; i++) {

			if (i > r) {
				l = r = i;

				while (r < a.length && a[r - l] == a[r]
						&& (long) arr.get(r - l) == (long) arr.get(r)) {

					r++;
				}

				z[i] = r - l;
				r--;
			} else {
				int k = i - l;
				if (z[k] < r - i + 1)
					z[i] = z[k];
				else {
					l = i;
					while (r < a.length && a[r - l] == a[r]
							&& (long) arr.get(r - l) == (long) arr.get(r))
						r++;
					z[i] = r - l;
					r--;
				}
			}

		}
	}

	public static int tree[];

	public static void add(int idx, long val, int n) {

		while (idx <= n) {
			tree[idx] += val;
			idx += (idx & -idx);
		}
	}

	public static int get(int idx) {
		int g = 0;
		while (idx > 0) {

			g += tree[idx];
			idx -= (idx & -idx);
		}

		return g;
	}

	public static ArrayList<Integer> arr[];
	public static int dp[];

	public static int solve(int i) {
		if (arr[i].size() == 0)
			return 0;
		if (dp[i] != -1)
			return dp[i];
		int a = Integer.MIN_VALUE;
		for (int j = 0; j < arr[i].size(); j++) {
			int g = arr[i].get(j);
			a = Math.max(a, solve(g) + 1);
		}

		return dp[i] = a;
	}

	public static void main(String[] args) throws IOException {
		StringBuilder qq = new StringBuilder();
		in.init(System.in);
		PrintWriter out = new PrintWriter(System.out);
		// source code
		// String hostNamee = "http://";
		// System.out.println(hostNamee.length());
		int n = in.nextInt();
		int k = in.nextInt();
		int query = in.nextInt();
		int a[] = new int[n];
		for (int i = 0; i < a.length; i++) {
			a[i] = in.nextInt();
		}
		PriorityQueue<node> q = new PriorityQueue<>();
		HashSet<Integer> mp = new HashSet();

		for (int i = 0; i < query; i++) {
			int o = in.nextInt();
			int id = in.nextInt();
			if (o == 2) {
				if (mp.contains(id))
					out.println("YES");
				else
					out.println("NO");
			} else {
				mp.add(id);
				q.add(new node(id, a[id - 1]));

				if (q.size() > k) {
					node e = q.poll();
					mp.remove(e.id);
				}
			}
		}

		out.close();

	}
}