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 sys
import math
import operator as op
from functools import reduce
from bisect import *
from collections import deque

## I/O ##
def read_line():
    return sys.stdin.readline()[:-1]
 
def read_int():
    return int(sys.stdin.readline())
    
def read_int_line():
    return [int(v) for v in sys.stdin.readline().split()]

def read_float_line():
    return [float(v) for v in sys.stdin.readline().split()]
## ##

## ncr ##
def ncr(n, r):
    r = min(r, n-r)
    numer = reduce(op.mul, range(n, n-r, -1), 1)
    denom = reduce(op.mul, range(1, r+1), 1)
    return numer / denom
## ##

## Fenwick Tree ##
N = int(1e6)+10
fenwick = [0]*N

def add(i,x,n):
	while i<n:
		fenwick[i]+=x
		i = i|(i+1)

def fsum(i,n):
	res = 0
	while i>=0:
		res += fenwick[i]
		i = (i&(i+1))-1
	return res

def fsum_range(i,j,n):
	return fsum(j,n)-fsum(i-1,n)
## ##	

## Main ##

mod = int(1e9)+7
mod2 = 998244353

t = read_int()
# t = 1
for i in range(t):
	n = read_int()
	a = read_int_line()
	b = read_int_line()
	o,z = sum(b), n-sum(b)

	# l = [[a[i],b[i]] for i in range(n)]
	# l = sorted(l,key=lambda x:x[0])

	f = True

	# i = n-1
	# while i>=0:

	if o>0 and z>0:
		print("Yes")
		continue

	else:
		for i in range(1,n):
			if a[i]<a[i-1]:
				f = False
				break

	# for i in range(n-1):
	# 	print(a,b)
	# 	ind = n-i-1
	# 	m = max(a[:ind])
	# 	x = a.index(m)
	# 	if b[i] != b[ind]:
	# 		a[i],a[ind] = a[ind],a[i]
	# 		b[i],b[ind] = b[ind],b[i]
	# 	else:
	# 		o = b[:ind].count(1)
	# 		z = n-i-1 - o
	# 		if b[i] == 0:
	# 			if o>0:
	# 				y = b[:ind].index(1)
	# 				a[ind],a[y] = a[y],a[ind]
	# 				b[ind], b[y] = b[y],b[ind]

	# 				a[i],a[ind] = a[ind],a[i]
	# 				b[i],b[ind] = b[ind],b[i]		
	# 			else:
	# 				f = False
	# 				break

	# 		else:
	# 			if z>0:
	# 				y = b[:ind].index(0)
	# 				a[ind],a[y] = a[y],a[ind]
	# 				b[ind], b[y] = b[y],b[ind]

	# 				a[i],a[ind] = a[ind],a[i]
	# 				b[i],b[ind] = b[ind],b[i]		
	# 			else:
	# 				f = False
	# 				break				

	if f:
		print("Yes")
	else:
		print("No")


