import re

for \_ in range(int(input())):
HEX = re.findall(r".(#[0-9A-Fa-f]{6}|#[0-9A-Fa-f]{3})", input())
if HEX:
print(\*HEX, sep='\n') 

from html.parser import HTMLParser

class MyHTMLParser(HTMLParser):
def handle_starttag(self, tag, attrs):
print("Start :", tag)
for e in attrs:
print ('->',e[0],'>',e[1])

      def handle_endtag(self, tag):
          print("End   :", tag)

      def handle_startendtag(self, tag, attrs):
          print("Empty :", tag)
          for e in attrs:
              print ('->',e[0],'>',e[1])

parser = MyHTMLParser()
parser.feed(''.join([input() for _ in range(int(input()))])) 

from html.parser import HTMLParser

class MyHTMLParser(HTMLParser):
def handle_comment(self,data):
if '\n' in data:
print('>>> Multi-line Comment')
print(data)
else:
print('>>> Single-line Comment')
print(data)

      def handle_data(self,data):
          if data!='\n':
              print('>>> Data')
              print(data)

html = ""  
 for i in range(int(input())):
html += input().rstrip()
html += '\n'

parser = MyHTMLParser()
parser.feed(html)
parser.close() 

from html.parser import HTMLParser

class MyHTMLParser(HTMLParser):
def handle_starttag(self, tag, attrs):
print(tag)
[print('-> {} > {}'.format(*attr)) for attr in attrs]

html = '\n'.join([input() for _ in range(int(input()))])
parser = MyHTMLParser()
parser.feed(html)
parser.close() 

import re

text = ''
for \_ in range(int(input())):
text = re.sub(r'<!.+-->',r' ',(text+input()))

for er in re.findall(r'<([^/][^>]_)>', text):
if ' ' in er:  
 for ere in re.findall(r'([a-z]+)? _([a-z-]+)="([^"]+)', er):
if ere[0]:
print(ere[0])  
 print('-> '+ere[1]+' > '+ere[2])
else:
print(er) 

import re

no_repeats = r"(?!._(.)._\1)"
two_or_more_upper = r"(._[A-Z]){2,}"
three_or_more_digits = r"(._\d){3,}"
ten_alphanumerics = r"[a-zA-Z0-9]{10}"
filters = no_repeats, two_or_more_upper, three_or_more_digits, ten_alphanumerics

for uid in [input() for _ in range(int(input()))]:
if all(re.match(f, uid) for f in filters):
print("Valid")
else:
print("Invalid") 

import re

for \_ in range(int(input())):
u = ''.join(sorted(input()))
try:
assert re.search(r'[A-Z]{2}', u)
assert re.search(r'\d\d\d', u)
assert not re.search(r'[^a-za-z0-9]', u)
assert not re.search(r'(.)\1', u)
assert len(u) == 10
except:
print('Invalid')
else:
print('Valid') 

import re

def validate_credit_cards(credit_cards):
valid_structure = r"[456]\d{3}(-?\d{4}){3}$"
no_four_repeats = r"((\d)-?(?!(-?\2){3})){16}"
filters = valid_structure, no_four_repeats

      if all(re.match(f, credit_cards) for f in filters):
          print("Valid")
      else:
          print("Invalid")

for \_ in range(int(input())):
credit = input()
validate_credit_cards(credit) 

import re
pattern = re.compile(r"^"
r"(?!.\*(\d)(-?\1){3})"
r"[456]"
r"\d{3}"
r"(?:-?\d{4}){3}"
r"$")
for \_ in range(int(input().strip())):
print("Valid" if pattern.search(input().strip()) else "Invalid") 

regex_integer_in_range = r"^[1-9]\d{5}$"
regex_alternating_repetitive_digit_pair = r"(\d)(?=\d\1)"

import re
P = input()

print (bool(re.match(regex_integer_in_range, P))
and len(re.findall(regex_alternating_repetitive_digit_pair, P)) < 2) 

import re

regex = re.compile(r'(?<=\w)(\W+)(?=\w)')
N, M = (int(num) for num in input().split())
encoded = [input() for _ in range(N)]
decoded = ''.join(row[letter] for letter in range(M) for row in encoded)
print(regex.sub(' ', decoded)) 

'''
^: 시작을 나타냄
[+-]?: (`+` 혹은 `-`) 둘 중 하나가 있거나 없을 수 있다
\d\*: 숫자가 있을 수도 있고 없을 수도 있다 <- \d는 [0-9]로 표현할 수도 있다
\.: `.` 문자
\d+: 적어도 하나의 숫자가 있다
$: 끝을 나타냄
'''

import re

for \_ in range(int(input())):
n = input()
print(bool(re.search(r'^[+-]?\d*\.\d+$', n))) # print(bool(re.search(r'^[+-]?[0-9]*\.[0-9]+$', n))) 

regex_pattern = r'[\.\,]'

import re
print("\n".join(re.split(regex_pattern, input())))

import re

# S = re.search(r"([A-Za-z0-9])\1+", input())

# S = re.search(r"(\w(?!\_))\1+", input())

S = re.search(r"([^\w_])\1+", input())

# print(S[1] if S else -1)

print(S.group(1) if S else -1)

import re

VOWELS = 'aeiou'
CONSONANTS = 'bcdfghjklmnpqrstvwxyz'
REGEX = '(?<=[' + CONSONANTS + '])([' + VOWELS + ']{2,})[' + CONSONANTS + ']'

match = re.findall(REGEX, input(), re.IGNORECASE)
if match:
print(\*match, sep='\n')
else:
print('-1') 

import re

S = input()
k = input()

pattern = re.compile(k)
r = pattern.search(S)

if not r:
print((-1, -1))
while r:
print("({0}, {1})".format(r.start(), r.end() - 1))
r = pattern.search(S, r.start() + 1) 

import re

for \_ in range(int(input())):
S = input()
S = re.sub(r' &&(?= )', ' and', S)
S = re.sub(r' \|\|(?= )', ' or', S)
print(S)

thousand = 'M{0,3}'
hundred = '(C[MD]|D?C{0,3})'
ten = '(X[CL]|L?X{0,3})'
digit = '(I[VX]|V?I{0,3})'

regex_pattern = rf"{thousand}{hundred}{ten}{digit}$"

import re
print(str(bool(re.match(regex_pattern, input())))) 

import re

for \_ in range(int(input())):
line = input()
if re.match(r"^[789]{1}\d{9}$", line):
print("YES")
else:
print("NO") 

import re
pattern=r'(?<=<)[a-z][a-z0-9\.\_\-]*@[a-z]+\.[a-z]{1,3}(?=>)'
for \_ in range(int(input())):
s = input()
if bool(re.search(pattern,s,re.IGNORECASE)):
print(s) 

import re
import email.utils
pattern=r'[a-z][a-z0-9\.\_\-]\*@[a-z]+\.[a-z]{1,3}$'
for \_ in range(int(input())):
tup=email.utils.parseaddr(input())
if bool(re.match(pattern,tup[1],re.IGNORECASE)):
print(email.utils.formataddr(tup))