def isBalanced(s):
    # Valid combos that must exist as pairs
    combos = ["[]", "{}", "()"]
    
    # While there are characters available, attempt to remove combos
    while len(s) > 0:
        new_s = s
        for c in combos:
            new_s = new_s.replace(c, "")
        # If the new_s has not changed length (ie no valid combos) return NO
        if len(new_s) == len(s):
            return "NO"
        s = new_s
    return "YES"

import os

def isBalanced(s):
    stack = []
    bracket_map = {')': '(', '}': '{', ']': '['}  # Mapping of closing to opening brackets

    for char in s:
        if char in bracket_map.values():  # If it's an opening bracket
            stack.append(char)
        elif char in bracket_map:  # If it's a closing bracket
            if not stack or stack[-1] != bracket_map[char]:
                return "NO"
            stack.pop()  # Pop the matching opening bracket
        else:
            return "NO"  # Invalid character (not necessary per constraints)
    
    return "YES" if not stack else "NO"

if __name__ == '__main__':
    fptr = open(os.environ['OUTPUT_PATH'], 'w')

    t = int(input().strip())  # Number of test cases

    for _ in range(t):
        s = input().strip()
        result = isBalanced(s)
        fptr.write(result + '\n')

    fptr.close()

public static string isBalanced(string s)
{
    Stack<char> st = new();
    foreach (char chr in s.ToArray())
    {   
        if (new char[]{'(','[','{'}.Contains(chr)) st.Push(chr);
        else if ( st.Count > 0 && (int)chr > (int)st.Peek() && (int)chr-2 <= (int)st.Pop()) continue;
        else return "NO";  
    }   
    
    return (st.Count > 0)?"NO":"YES";
}