It is known that there are *k* fish species in the polar ocean, numbered from 1 to *k*. They are sorted by non-decreasing order of their weight, which is a positive number. Let the weight of the *i*-th type of fish be *w*<sub class="lower-index">*i*</sub>, then 0 &lt; *w*<sub class="lower-index">1</sub> ≤ *w*<sub class="lower-index">2</sub> ≤ ... ≤ *w*<sub class="lower-index">*k*</sub> holds.

Polar bears Alice and Bob each have caught some fish, and they are guessing who has the larger sum of weight of the fish he/she's caught. Given the type of the fish they've caught, determine whether it is possible that the fish caught by Alice has a strictly larger total weight than Bob's. In other words, does there exist a sequence of weights *w*<sub class="lower-index">*i*</sub> (not necessary integers), such that the fish caught by Alice has a strictly larger total weight?
The first line contains three integers *n*, *m*, *k* (1 ≤ *n*, *m* ≤ 10<sup class="upper-index">5</sup>, 1 ≤ *k* ≤ 10<sup class="upper-index">9</sup>) — the number of fish caught by Alice and Bob respectively, and the number of fish species.

The second line contains *n* integers each from 1 to *k*, the list of fish type caught by Alice. The third line contains *m* integers each from 1 to *k*, the list of fish type caught by Bob.

Note that one may have caught more than one fish for a same species.
from operator import itemgetter
from typing import *
from collections import deque, Counter, defaultdict
from bisect import *
import heapq, math
from functools import cmp_to_key, reduce
from itertools import groupby, islice, zip_longest

# from sortedcontainers import SortedSet, SortedList


def main():
    n, m, k = map(int, input().split())
    a = list(map(int, input().split()))
    b = list(map(int, input().split()))
    a, b = Counter(a), Counter(b)
    arr = []

    def get(key, tmp):
        return tmp[key] if key in tmp.keys() else 0

    for key in set(list(a.keys()) + list(b.keys())):
        arr.append((key, get(key, a) - get(key, b)))
    arr.sort(reverse=True)
    arr = list(map(lambda x: x[1], arr))
    arr = list(filter(lambda x: x != 0, arr))
    if all(it <= 0 for it in arr):
        print("NO")
    else:
        arr = [
            sum(it) for _, it in groupby(arr, key=cmp_to_key(lambda x, y: x * y < 0))
        ]
        if arr[0] > 0:
            print("YES")
        else:
            tmp, flag = 0, 0
            for it in arr:
                tmp += it
                if tmp > 0:
                    flag = 1
                    break
            if flag == 1:
                print("YES")
            else:
                print("NO")


main()
