Problem: Petya started to attend programming lessons. On the first lesson his task was to write a simple program. The program was supposed to do the following: in the given string, consisting if uppercase and lowercase Latin letters, it: 

  * deletes all the vowels, 
  * inserts a character "." before each consonant, 
  * replaces all uppercase consonants with corresponding lowercase ones. 



Vowels are letters "A", "O", "Y", "E", "U", "I", and the rest are consonants. The program's input is exactly one string, it should return the output as a single string, resulting after the program's processing the initial string.

Help Petya cope with this easy task.

Input

The first line represents input string of Petya's program. This string only consists of uppercase and lowercase Latin letters and its length is from 1 to 100, inclusive.

Output

Print the resulting string. It is guaranteed that this string is not empty.

Examples

Input

tour


Output

.t.r


Input

Codeforces


Output

.c.d.f.r.c.s


Input

aBAcAba


Output

.b.c.b

Solution (in PYTHON):

Solution:
"""Template for Python Competitive Programmers prepared by Mayank Chaudhary aka chaudhary_19"""

# to use the print and division function of Python3
from __future__ import division, print_function

"""value of mod"""
MOD = 10 ** 9 + 7

"""use resource"""
# import resource
# resource.setrlimit(resource.RLIMIT_STACK, [0x100000000, resource.RLIM_INFINITY])

"""uncomment next 4 lines while doing recursion based question"""
# import threading
# threading.stack_size(2**27)
import sys

# sys.setrecursionlimit(10**6)

"""uncomment next 7 lines while doing nCr question"""
# fact=[1]
# for i in range(1,100001):
#    fact.append((fact[-1]*i)%mod)
# ifact=[0]*100001
# ifact[100000]=pow(fact[100000],mod-2,mod)
# for i in range(100000,0,-1):
#    ifact[i-1]=(i*ifact[i])%mod

"""uncomment modules according to your need"""
from bisect import bisect_left, bisect_right, insort
# import itertools
# import collections
from math import floor, ceil
# import heapq
# from random import randint as rn
# from Queue import Queue as Q

'''
def modinv(n, p):
    return pow(n, p - 2, p)
'''

'''
def ncr(n, r, p):  # for using this uncomment the lines calculating fact and ifact
    t = ((fact[n]) * ((ifact[r] * ifact[n - r]) % p)) % p
    return t
'''


def get_ints(): return map(int, sys.stdin.readline().strip().split())
def get_array(): return list(map(int, sys.stdin.readline().strip().split()))
def input(): return sys.stdin.readline().strip()


'''
def GCD(x, y):
    while (y):
        x, y = y, x % y
    return x
'''

"""*******************************************************"""

def get_xor(n):
    return [n,1,n+1,0][n%4]


def main():

    string = input()
    ans = ''

    vowels = {'A','a','E','e','I','i','O','o','U','u','Y','y'}

    for i in string:
        if i not in vowels:
            ans += '.'
            ans += i.lower()
    print(ans)






""" -------- Python 2 and 3 footer by Pajenegod and c1729 ---------"""

py2 = round(0.5)
if py2:
    from future_builtins import ascii, filter, hex, map, oct, zip

    range = xrange

import os, sys
from io import IOBase, BytesIO

BUFSIZE = 8192


class FastIO(BytesIO):
    newlines = 0

    def __init__(self, file):
        self._file = file
        self._fd = file.fileno()
        self.writable = "x" in file.mode or "w" in file.mode
        self.write = super(FastIO, self).write if self.writable else None

    def _fill(self):
        s = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
        self.seek((self.tell(), self.seek(0, 2), super(FastIO, self).write(s))[0])
        return s

    def read(self):
        while self._fill(): pass
        return super(FastIO, self).read()

    def readline(self):
        while self.newlines == 0:
            s = self._fill();
            self.newlines = s.count(b"\n") + (not s)
        self.newlines -= 1
        return super(FastIO, self).readline()

    def flush(self):
        if self.writable:
            os.write(self._fd, self.getvalue())
            self.truncate(0), self.seek(0)


class IOWrapper(IOBase):
    def __init__(self, file):
        self.buffer = FastIO(file)
        self.flush = self.buffer.flush
        self.writable = self.buffer.writable
        if py2:
            self.write = self.buffer.write
            self.read = self.buffer.read
            self.readline = self.buffer.readline
        else:
            self.write = lambda s: self.buffer.write(s.encode('ascii'))
            self.read = lambda: self.buffer.read().decode('ascii')
            self.readline = lambda: self.buffer.readline().decode('ascii')


sys.stdin, sys.stdout = IOWrapper(sys.stdin), IOWrapper(sys.stdout)
input = lambda: sys.stdin.readline().rstrip('\r\n')

""" main function"""

if __name__ == '__main__':
    main()
# threading.Thread(target=main).start()