def main():
    import sys
    from collections import defaultdict

    N, k = map(int, sys.stdin.readline().split())
    A = list(map(int, sys.stdin.readline().split()))
    B = list(map(int, sys.stdin.readline().split()))

    if k == 1:
        if A == B:
            print("Yes")
        else:
            print("No")
        return

    if k > N:
        if A == B:
            print("Yes")
        else:
            print("No")
        return

    # Check if A and B have the same multiset
    sorted_A = sorted(A)
    sorted_B = sorted(B)
    if sorted_A != sorted_B:
        print("No")
        return

    # Function to check if exists m >=k and <=N with m mod4 2 or 3
    def has_valid_m(k, N):
        rem = k % 4
        if rem in (2, 3):
            return True
        if rem == 0:
            m2 = k + 2
            m3 = k + 3
            return m2 <= N or m3 <= N
        elif rem == 1:
            m1 = k + 1
            m2 = k + 2
            return m1 <= N or m2 <= N

    if has_valid_m(k, N):
        print("Yes")
        return

    # Check for duplicates
    freq = defaultdict(int)
    for num in A:
        freq[num] += 1
    has_duplicates = any(v > 1 for v in freq.values())
    if has_duplicates:
        print("Yes")
        return

    # Build permutation
    pos_in_A = {num: i for i, num in enumerate(A)}
    perm = []
    for num in B:
        perm.append(pos_in_A[num])

    # Compute inversion parity using Fenwick Tree
    class FenwickTree:
        def __init__(self, size):
            self.size = size
            self.tree = [0]*(size+1)

        def update(self, idx, delta=1):
            idx +=1  # 1-based
            while idx <= self.size:
                self.tree[idx] += delta
                idx += idx & -idx

        def query(self, idx):
            idx +=1  # 1-based
            res = 0
            while idx >0:
                res += self.tree[idx]
                idx -= idx & -idx
            return res

    ft = FenwickTree(N)
    parity = 0
    for x in reversed(perm):
        # Number of elements smaller than x already processed (in right)
        count = ft.query(x-1)
        parity = (parity + count) %2
        ft.update(x)

    if parity %2 ==0:
        print("Yes")
    else:
        print("No")

if __name__ == "__main__":
    main()