Problem: 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.

Solution (in PYTHON3):

Solution:
from fractions import Fraction
import bisect
import os
from collections import Counter
import bisect
from collections import defaultdict
import math
import random
import heapq as hq
from math import sqrt
import sys
from functools import reduce, cmp_to_key
from collections import deque
import threading
from itertools import combinations
from io import BytesIO, IOBase
from itertools import accumulate
from queue import Queue


# sys.setrecursionlimit(200000)
# input = io.BytesIO(os.read(0, os.fstat(0).st_size)).readline


def input():
    return sys.stdin.readline().strip()


def iinput():
    return int(input())


def tinput():
    return input().split()


def rinput():
    return map(int, tinput())


def rlinput():
    return list(rinput())


mod = int(1e9)+7


def factors(n):
    return set(reduce(list.__add__,
                      ([i, n//i] for i in range(1, int(n**0.5) + 1) if n % i == 0)))


# ----------------------------------------------------
# sys.stdin = open('input.txt', 'r')
# sys.stdout = open('output.txt', 'w')

t = 1
t = iinput()
for _ in range(t):
    n= iinput()
    a=rlinput()
    b = rlinput()
    if sorted(a)==a:
        print("Yes")
        continue
    elif b.count(0)==n or b.count(0)==0:
        print("No")
        continue
    print("Yes")

# t = iinput()
# for i in range(t):
#     n, m = rinput()
#     mat = []
#     for i in range(n):
#         mat.append(list(input()))
#     flg = False
#     for i in range(n):
#         for j in range(m):
#             if mat[i][j] == 'B':
#                 if i > 0:
#                     if mat[i-1][j] in ['.', '#']:
#                         mat[i-1][j] = '#'
#                     # elif mat[i-1][j] == 'G':
#                     #     flg = True
#                     #     break
#                 if i < n-1:
#                     if mat[i+1][j] in ['.', '#']:
#                         mat[i+1][j] = '#'
#                     elif mat[i+1][j] == 'G':
#                         flg = True
#                         break
#                 if j > 0:
#                     if mat[i][j-1] in ['.', '#']:
#                         mat[i][j-1] = '#'
#                     elif mat[i][j-1] == 'G':
#                         flg = True
#                         break
#                 if j < m-1:
#                     if mat[i][j+1] in ['.', '#']:
#                         mat[i][j+1] = '#'
#                     elif mat[i][j+1] == 'G':
#                         flg = True
#                         break
#         if flg:
#             break
#     if flg:
#         print("No")
#         continue

#     def recur(i, j):
#         if i < 0 or j < 0 or i>n-1 or j>m-1:
#             return
#         if mat[i][j] in ['B', '#'] or visited[i][j]:
#             return
#         visited[i][j] = True
#         if i > 0:
#             recur(i-1, j)
#         if i < n-1:
#             recur(i+1, j)
#         if j < m-1:
#             recur(i, j+1)
#         if j > 0:
#             recur(i, j-1)

#     visited = [[False]*m for i in range(n)]
#     recur(n-1,m-1)
#     for i in range(n):
#         for j in range(m):
#             if mat[i][j] == 'G' and not visited[i][j]:
#                 flg = True
#                 break
#         if flg:
#             break
#     # print(mat)
#     # print(visited)

#     print(["Yes","No"][flg])