import sys

def is_valid_torii(a, b, c):
    if a == b or b == c or a == c:
        return False
    if (b > a and b > c) or (b < a and b < c):
        return True
    return False

def main():
    input = sys.stdin.read().split()
    ptr = 0
    T = int(input[ptr])
    ptr += 1
    for _ in range(T):
        N = int(input[ptr])
        ptr +=1
        A = list(map(int, input[ptr:ptr+N]))
        ptr +=N
        
        bad_triplets = []
        for x in range(N-2):
            a = A[x]
            b = A[x+1]
            c = A[x+2]
            if (a < b and b < c) or (a > b and b > c):
                bad_triplets.append(x)
        
        if not bad_triplets:
            print("Yes")
            continue
        
        swaps = set()
        for x in bad_triplets:
            swaps.add((x, x+1))
            swaps.add((x+1, x+2))
        
        found = False
        for (i, j) in swaps:
            if i > j:
                i, j = j, i
            
            all_bad_fixed = True
            for x in bad_triplets:
                a = A[x]
                b = A[x+1]
                c = A[x+2]
                if x == i or x == j or x+1 == i or x+1 == j or x+2 == i or x+2 == j:
                    new_a = A[x]
                    if x == i:
                        new_a = A[j]
                    elif x == j:
                        new_a = A[i]
                    
                    new_b = A[x+1]
                    if x+1 == i:
                        new_b = A[j]
                    elif x+1 == j:
                        new_b = A[i]
                    
                    new_c = A[x+2]
                    if x+2 == i:
                        new_c = A[j]
                    elif x+2 == j:
                        new_c = A[i]
                    
                    if not is_valid_torii(new_a, new_b, new_c):
                        all_bad_fixed = False
                        break
            if not all_bad_fixed:
                continue
            
            x_start_i = max(0, i-2)
            x_end_i = min(i, N-3)
            x_start_j = max(0, j-2)
            x_end_j = min(j, N-3)
            
            affected_x = set()
            for x in range(x_start_i, x_end_i +1):
                affected_x.add(x)
            for x in range(x_start_j, x_end_j +1):
                affected_x.add(x)
            
            all_affected_valid = True
            for x in affected_x:
                a = A[x]
                b = A[x+1]
                c = A[x+2]
                
                new_a = A[x]
                if x == i:
                    new_a = A[j]
                elif x == j:
                    new_a = A[i]
                
                new_b = A[x+1]
                if x+1 == i:
                    new_b = A[j]
                elif x+1 == j:
                    new_b = A[i]
                
                new_c = A[x+2]
                if x+2 == i:
                    new_c = A[j]
                elif x+2 == j:
                    new_c = A[i]
                
                if not is_valid_torii(new_a, new_b, new_c):
                    all_affected_valid = False
                    break
            if all_affected_valid:
                found = True
                break
        
        if found:
            print("Yes")
        else:
            print("No")

if __name__ == "__main__":
    main()