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.
import math 

def Divisors(n) : 
	
	l=[]
	i = 1
	while i <= math.sqrt(n): 
		
		if (n % i == 0) : 
			
			
			if (n // i == i) : 
				l.append(i)
			else : 
				l.append(i)
				l.append(n//i)
		i = i + 1
	return l

def SieveOfEratosthenes(n): 
	
	l=[]
	
	prime = [True for i in range(n+1)] 
	p = 2
	while (p * p <= n): 
		
		if (prime[p] == True): 
			
			for i in range(p * p, n+1, p): 
				prime[i] = False
		p += 1
	
	for p in range(2, n+1): 
		if prime[p]: 
			l.append(p)
	
	return l		

def primeFactors(n): 
	
	l=[]
	
	while n % 2 == 0: 
		l.append(2) 
		n = n / 2
		
	for i in range(3,int(math.sqrt(n))+1,2): 
		
		while n % i== 0: 
			l.append(i) 
			n = n / i 
			
	if n > 2: 
		l.append(n)
	
	return(l)	
		

def Factors(n) : 
	
	
	result = []
	
	for i in range(2,(int)(math.sqrt(n))+1) : 

		if (n % i == 0) : 
		    
			if (i == (n/i)) : 
				result.append(i)
			else : 
			    result.append(i)
			    result.append(n//i)
		
	result.append(1)
	result.append(n)
	return result

def maxSubArraySum(a): 
	
	max_so_far = 0
	max_ending_here = 0
	size=len(a)
	
	for i in range(0, size): 
		max_ending_here = max_ending_here + a[i] 
		if (max_so_far < max_ending_here): 
			max_so_far = max_ending_here 

		if max_ending_here < 0: 
			max_ending_here = 0
	return max_so_far 

#print(SieveOfEratosthenes(100))
#print(Divisors(100))
#print(primeFactors(100))
#print(Factors(100))
#print(maxSubArraySum(a)
def main():

    n=int(input())
    a=list(map(int,input().split()))
    b=list(map(int,input().split()))
    l=[]
    c1=0
    c2=0
    for j in range(0,n):
        l.append(a[j])
        if b[j]==0:
            c1+=1
        else:
            c2+=1
            
    l.sort()
    if c1>0 and c2>0:
        print("Yes")
        
    else:
        f=0
        for j in range(0,n):
            if a[j]!=l[j]:
                print("No")
                f=1
                break
                
        if f==0:
            print("Yes")
            
    
t=int(input())
for i in range(0,t):
    main()