human
Ashish has n elements arranged in a line. 

These elements are represented by two integers a_i — the value of the element and b_i — the type of the element (there are only two possible types: 0 and 1). He wants to sort the elements in non-decreasing values of a_i.

He can perform the following operation any number of times: 

  * Select any two elements i and j such that b_i ≠ b_j and swap them. That is, he can only swap two elements of different types in one move. 


Tell him if he can sort the elements in non-decreasing values of a_i after performing any number of operations.

Input

The first line contains one integer t (1 ≤ t ≤ 100) — the number of test cases. The description of the test cases follows.

The first line of each test case contains one integer n (1 ≤ n ≤ 500) — the size of the arrays.

The second line contains n integers a_i (1 ≤ a_i ≤ 10^5) — the value of the i-th element.

The third line containts n integers b_i (b_i ∈ \{0, 1\}) — the type of the i-th element.

Output

For each test case, print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.

You may print each letter in any case (upper or lower).

Example

Input

5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1

Output

Yes
Yes
Yes
No
Yes

Note

For the first case: The elements are already in sorted order.

For the second case: Ashish may first swap elements at positions 1 and 2, then swap elements at positions 2 and 3.

For the third case: The elements are already in sorted order.

For the fourth case: No swap operations may be performed as there is no pair of elements i and j such that b_i ≠ b_j. The elements cannot be sorted.

For the fifth case: Ashish may swap elements at positions 3 and 4, then elements at positions 1 and 2.
Solve the task in PYTHON3.
 Can you provide a Python program to print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value?
assistant
#Here is Python program to print "Yes" or "No" (without quotes) depending on whether it is possible to sort elements in non-decreasing order of their value.

'''input
5
4
10 20 20 30
0 1 0 1
3
3 1 2
0 1 1
4
2 2 4 8
1 1 1 1
3
5 15 4
0 0 0
4
20 10 100 50
1 0 0 1

'''
from collections import defaultdict
import math
from functools import reduce
from heapq import heapify, heappush, heappop
import sys
from sys import stdin, stdout
from random import seed
from random import randint

mod = 10 ** 9 + 7

def mul_mod(a, b):
    return ((a % mod) * (b % mod)) % mod

def add_mod(a, b):
    return ((a % mod) + (b % mod)) % mod

def sub_mod(a, b):
	return((a % mod) - (b % mod) + mod) % mod

def modInverse(b):
    # g = math.gcd(b, m)
    # if (g != 1):
    #     # print("Inverse doesn't exist")
    #     return -1
    return pow(b, mod - 2, mod)

def div_mod(a, b):
    a = a % mod
    inv = modInverse(b)
    # if(inv == -1):
    #     print("Division not defined")
    # else:
    #     print("Result of Division is ",(inv*a) % m)
    return (inv * a) % mod

# This class represents an undirected graph using adjacency list representation
class Graph:

    def __init__(self, vertices):
        self.V = vertices + 1  # No. of vertices
        self.graph = defaultdict(set)  # default dictionary to store graph
        self.Time = 0
        self.P = 0
        self.Q = 0

    # function to add an edge to graph
    def addEdge(self, u, v):
        self.graph[u].add(v)
        self.graph[v].add(u)

    '''A recursive function that finds and prints bridges
    using DFS traversal
    u --> The vertex to be visited next
    visited[] --> keeps tract of visited vertices
    disc[] --> Stores discovery times of visited vertices
    parent[] --> Stores parent vertices in DFS tree
    count[] --> Stores count of vertices in DFS subtree rooted at the vertex'''

    def bridgeUtil(self, u):
        # Mark the current node as visited and print it
        # self.visited[u] = True
        self.count[u] += 1

        # Initialize discovery time and low value
        self.disc[u] = self.Time
        self.low[u] = self.Time
        self.Time += 1

        # Recur for all the vertices adjacent to...