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.

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.

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

import java.util.*

fun main(args: Array<String>) {
    val sc = Scanner(System.`in`)

    println(modify(sc.next()))
}

val vowels = "AOYEUI"
fun modify(word: String) =
    word.filter { !vowels.contains(it.toUpperCase()) }
        .map { "." + it.toLowerCase() }
        .joinToString("")

// kotlin oj template code from uwi(Codeforces), and convert to kotlin by lety
import java.io.ByteArrayInputStream
import java.io.IOException
import java.io.InputStream
import java.io.PrintWriter
import java.util.Arrays
import java.util.InputMismatchException

lateinit var `is`: InputStream
lateinit var out: PrintWriter
var INPUT = ""

//val oj = System.getProperty("ONLINE_JUDGE") != null
val oj = true
val inbuf = ByteArray(1024)
var lenbuf = 0
var ptrbuf = 0

fun solve() {
    val s = ns()

    s.forEach {
        if(it in "aeiouyAEIOUY")
        {
        }
        else
        {
            print('.')

            if(it.isUpperCase())
            {
                print(it.toLowerCase())
            }
            else
            {
                print(it)
            }
        }
    }

}

fun main() {
    `is` = if (oj) System.`in` else ByteArrayInputStream(INPUT.toByteArray())
    out = PrintWriter(System.out)

    val s = System.currentTimeMillis()
    solve()
    out.flush()
    tr((System.currentTimeMillis() - s).toString() + "ms")
}

private fun readByte(): Int {
    if (lenbuf == -1) throw InputMismatchException()
    if (ptrbuf >= lenbuf) {
        ptrbuf = 0
        try {
            lenbuf = `is`.read(inbuf)
        } catch (e: IOException) {
            throw InputMismatchException()
        }

        if (lenbuf <= 0) return -1
    }
    return inbuf[ptrbuf++].toInt()
}

private fun isSpaceChar(c: Int): Boolean = !(c >= 33 && c <= 126)

private fun skip(): Int {
    var b: Int = readByte()
    while (b != -1 && isSpaceChar(b)) {
        b = readByte()
    }
    return b
}

// using ns()
private fun nd(): Double = ns().toDouble()

// using ns()
private fun nc(): Char = skip().toChar()

// input until whitespace
private fun ns(): String {
    var b = skip()
    val sb = StringBuilder()
    while (!isSpaceChar(b)) { // when nextLine, (isSpaceChar(b) && b != ' ')
        sb.appendCodePoint(b)
        b = readByte()
    }
    return sb.toString()
}

private fun ns(n: Int): CharArray {
    val buf = CharArray(n)
    var b = skip()
    var p = 0
    while (p < n && !isSpaceChar(b)) {
        buf[p++] = b.toChar()
        b = readByte()
    }
    return if (n == p) buf else Arrays.copyOf(buf, p)
}

// matrix
private fun nm(n: Int, m: Int): Array<CharArray> {
    val map = Array(n) { CharArray(m) }
    for (i in 0 until n) map[i] = ns(m)
    return map
}

private fun pm(matrix: Array<CharArray>) {
    val n = matrix.size
    val m = matrix[0].size
    repeat(n)
    {
        repeat(m)
        { jt ->
            out.print(matrix[it][jt])
        }
        out.println()
    }
    out.flush()
}

// int array
private fun na(n: Int): IntArray {
    val a = IntArray(n)
    for (i in 0 until n) a[i] = ni()
    return a
}

private fun ni(): Int {
    var num = 0
    var b: Int = readByte()
    var minus = false
    while (b != -1 && !(b >= '0'.toInt() && b <= '9'.toInt() || b == '-'.toInt())) {
        b = readByte()
    }
    if (b == '-'.toInt()) {
        minus = true
        b = readByte()
    }

    while (true) {
        if (b >= '0'.toInt() && b <= '9'.toInt()) {
            num = num * 10 + (b - '0'.toInt())
        } else {
            return if (minus) -num else num
        }
        b = readByte()
    }
}

private fun nl(): Long {
    var num: Long = 0
    var b: Int = readByte()
    var minus = false
    while (b != -1 && !(b >= '0'.toInt() && b <= '9'.toInt() || b == '-'.toInt())) {
        b = readByte()
    }
    if (b == '-'.toInt()) {
        minus = true
        b = readByte()
    }

    while (true) {
        if (b >= '0'.toInt() && b <= '9'.toInt()) {
            num = num * 10 + (b - '0'.toInt())
        } else {
            return if (minus) -num else num
        }
        b = readByte()
    }
}

private fun tr(vararg o: Any) {
//    if (!oj) println(Arrays.deepToString(o))
}

fun main(args: Array<String>) {

    val s = readLine()!!

    print(s.toLowerCase()
            .filter { it !in listOf('a', 'e', 'o', 'u', 'i', 'y') }.asIterable().joinToString(separator = ".", prefix = "."))

}

fun main(args : Array<String>) {
    val s = readLine()!!
    var list: MutableList<Char> = mutableListOf()
    var listc: MutableList<Char> = mutableListOf()

    val letter = arrayOf('a', 'o', 'y', 'e', 'i', 'u')
    for (char in s) {
        list.add(char)
    }

    for(j in 0..s.length-1){
        var c = 0
        for(k in 0..5){
             if(s[j].toLowerCase()!=letter[k]){
                c++
             }
        }
        if(c==6){
            listc.add('.')
            listc.add(s[j].toLowerCase())
        }
    }

    for (i in 0..listc.size-1) {
        print(listc[i])
    }
}

import java.util.*

fun main(args: Array<String>){
    val vwls = arrayOf("a","o","y","e","u","i");
    val sc = Scanner(System.`in`)
    var str = sc.nextLine().toLowerCase();

    var res = "";
    for (x in 0 until str.length){
        if (!vwls.contains("${str[x]}")){
            res += ".${str[x]}"
        }
    }
    print(res)
}

fun main()
{
    val given = readLine()!!
    var answer = ""
    for (i in given)
    {
        if (! "AEIOUYaeiouy".contains(i))
        {
            answer += "."+i.toLowerCase()
        }
    }
    println(answer)
}

fun main() {
    val r = System.`in`.bufferedReader()
    val s = StringBuilder()
    val vowels = listOf<String>("a", "e", "i", "o", "u", "y")
    val str = readLine()!!.split("").filter { it.length>0 && it.toLowerCase() !in vowels }.map { it.toLowerCase() }.joinToString(".")
    s.append(".")
    s.append(str)
    print(s)
}

fun main(args: Array<String>) {
    var w = readLine()!!.toString()
    var W = w.toLowerCase()
            for (i in W){
            if (!(i == 'a'  || i == 'o' || i == 'y' || i == 'e' || i == 'u' || i == 'i')) {
                print(".$i")
            }
          }
        }

import java.util.*

val scan = Scanner(System.`in`)

fun main(args: Array<String>){
    var s = scan.next().toLowerCase()
    var n = "aoyeui".split("").subList(1,7)
    for (i in s){
        var a = i.toString()
        if (a !in n) {
            print(".$i")
        }
    }

}

import java.lang.StringBuilder

fun main(args: Array<String>) {
    val input = readLine() ?: ""
    val vowels = "[aoyeui]".toRegex()
    val noVowels = input.toLowerCase().replace(vowels,"")
    val sb = StringBuilder()
    noVowels.forEach { sb.append(".$it") }
    println(sb.toString())
}

//package codeforces.com.tasks.task118A

fun main() {
    val vowels = setOf('a', 'o', 'y', 'e', 'u', 'i')
    val input = readLine()!!
    val letters = Array(input.length) { "" }
    var index = 0
    input.map {
        if (!vowels.contains(it.toLowerCase()))
            letters[index] = ".${it.toLowerCase()}"; index++
    }
    println(letters.joinToString(""))
}

fun main(args: Array<String>)
{

    var text = readLine()!!.trim()
    text = text.toLowerCase()
    var text1 = text
    var vowels ="aouyei"

    for (i in 0..(text.length-1))
    {
        if (vowels.contains(text.get(i)))
        {
            text1 = text1.replace(text.get(i)+"","")
        }else
        {
            text1 = text1.replace(text.get(i)+"","."+text.get(i))
        }
        text1 = text1.replace("..",".")

    }

    print(text1)

}

import java.io.PrintWriter
import java.util.StringTokenizer
import kotlin.math.*
import kotlin.random.*
import kotlin.collections.sort as _sort
import kotlin.collections.sortDescending as _sortDescending
import kotlin.io.println as iprintln

fun main() { _writer.solve(); _writer.flush() }

fun PrintWriter.solve() {
    var result = readLn()
    result = result.toLowerCase()
    result = result.replace("a","")
    result = result.replace("e","")
    result = result.replace("y","")
    result = result.replace("u","")
    result = result.replace("i","")
    result = result.replace("o","")
    var newChars = ""
    for (i in 0 until result.length) {
        newChars = newChars.plus(".").plus(result[i])
    }
    println(newChars.toString())
}

/** IO code start */
//@JvmField val INPUT = File("input.txt").inputStream()
//@JvmField val OUTPUT = File("output.txt").outputStream()
@JvmField val INPUT = System.`in`
@JvmField val OUTPUT = System.out

@JvmField val _reader = INPUT.bufferedReader()
fun readLine(): String? = _reader.readLine()
fun readLn() = _reader.readLine()!!
@JvmField var _tokenizer: StringTokenizer = StringTokenizer("")
fun read(): String {
    while (_tokenizer.hasMoreTokens().not()) _tokenizer = StringTokenizer(_reader.readLine() ?: return "", " ")
    return _tokenizer.nextToken()
}
fun readInt() = read().toInt()
fun readDouble() = read().toDouble()
fun readLong() = read().toLong()
fun readStrings(n: Int) = List(n) { read() }
fun readLines(n: Int) = List(n) { readLn() }
fun readInts(n: Int) = List(n) { read().toInt() }
fun readIntArray(n: Int) = IntArray(n) { read().toInt() }
fun readDoubles(n: Int) = List(n) { read().toDouble() }
fun readDoubleArray(n: Int) = DoubleArray(n) { read().toDouble() }
fun readLongs(n: Int) = List(n) { read().toLong() }
fun readLongArray(n: Int) = LongArray(n) { read().toLong() }

@JvmField val _writer = PrintWriter(OUTPUT, false)

/** shuffles and sort overrides to avoid quicksort attacks */
private inline fun <T> _shuffle(rnd: Random, get: (Int) -> T, set: (Int, T) -> Unit, size: Int) {
    // Fisher-Yates shuffle algorithm
    for (i in size - 1 downTo 1) {
        val j = rnd.nextInt(i + 1)
        val temp = get(i)
        set(i, get(j))
        set(j, temp)
    }
}

@JvmField var _random: Random? = null
val random get() = _random ?: Random(0x594E215C123 * System.nanoTime()).also { _random = it }

fun IntArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun IntArray.sort() { shuffle(); _sort() }
fun IntArray.sortDescending() { shuffle(); _sortDescending() }

fun LongArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun LongArray.sort() { shuffle(); _sort() }
fun LongArray.sortDescending() { shuffle(); _sortDescending() }

fun DoubleArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun DoubleArray.sort() { shuffle(); _sort() }
fun DoubleArray.sortDescending() { shuffle(); _sortDescending() }

fun CharArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
inline fun CharArray.sort() { _sort() }
inline fun CharArray.sortDescending() { _sortDescending() }

inline fun <T: Comparable<T>> Array<out T>.sort() = _sort()
inline fun <T: Comparable<T>> Array<out T>.sortDescending() = _sortDescending()
inline fun <T: Comparable<T>> MutableList<out T>.sort() = _sort()
inline fun <T: Comparable<T>> MutableList<out T>.sortDescending() = _sortDescending()

fun main() {
    val vowel:Array<Char> = arrayOf('A', 'O', 'Y', 'E', 'U', 'I')
    val vowelLower:Array<Char> = arrayOf('a', 'o', 'y', 'e', 'u', 'i')
    val word:String = readLine()!!

    for (i in word.indices) {

        if (word[i] in vowel || word[i] in vowelLower)
            print("")

        else {
            if (word[i] in 'A'..'Z')
                print("." + word[i].toLowerCase())
            else
                print("." + word[i])
        }
    }
}

import java.lang.StringBuilder

private val vowels = listOf('a','o','y','e','u','i')

fun main(args: Array<String>) {
    val text = readLine()!!
    val newText = StringBuilder()
    val capVowels = vowels.map { it - 32 }
    for (char in text) {
        if (char in vowels || char in capVowels)
            continue
        val consonant = if (char.toInt() < 97) char + 32 else char
        newText.append(".$consonant")
    }
    print(newText)
}

import kotlin.collections.*
import kotlin.io.*
import kotlin.text.*

fun readInts() = readLine()!!.split(' ').map { it.toInt() }

fun main() {
    var s = readLine().toString()
    val vowels = arrayOf("a", "o", "y", "e", "u", "i")
    for (i in vowels.indices) {
        s = s.replace(vowels[i], "", true)
    }
    s = s.toLowerCase()
    val s1 = s.split("")

    var res = ""
    for (i in s1.indices) {
        res += if (s1[i] != "") "." else ""
        res += s1[i]
    }
    println(res)
}

fun main() {
    println(solution(readLine()!!))
}

fun solution(text: String): String{
    val syllables = setOf('A','O', 'Y', 'E', 'U', 'I')
    val res = mutableListOf<Char>()
    for (ch in text){
        if (syllables.contains(ch.toUpperCase())) {
            continue
        }
        res.addAll(listOf('.',ch.toLowerCase()))
    }
    return String(res.toCharArray())
}

import java.util.*

fun main(args: Array<String>) = with(Scanner(System.`in`)){
        val word = nextLine()

        val wordArray = word.toCharArray()
        val finalArray = CharArray(word.length * 2)
        var counter = 0
        for(i in wordArray.indices){
            val c = wordArray[i]
            var isCharOk = true
            when(c){
                'A','a',
                'O','o',
                'Y','y',
                'E','e',
                'U','u',
                'I','i'-> isCharOk = false
            }
            if(!isCharOk){
                continue
            }
            finalArray[counter] = '.'
            counter++
            finalArray[counter] = Character.toLowerCase(c)
            counter++
        }
        println(String(finalArray,0,counter))
}

fun main(args: Array<String>) {
    var inp = readLine()!!
    inp = inp.toLowerCase()
    val vovs = arrayOf('a','e','i','o','u','y')
    for (i in inp)
        {
            if (i in vovs)
                continue
            print(".$i")
        }
}

fun main(args: Array<String>) {
    val input: String = readLine()!!
    val answer: ArrayList<Char> = arrayListOf()
    val vowels: ArrayList<Char> = arrayListOf('a', 'i', 'u', 'e', 'o', 'y')
    for (char in input.toCharArray()) {
        val currentChar = char.toLowerCase()
        if (!vowels.contains(currentChar)) {
            answer.add('.')
            answer.add(currentChar)
        }
    }
    for (char in answer) {
        print(char)
    }
    println()
}

import java.util.*
import kotlin.collections.ArrayList

fun main(args: Array<String>) {
    var scan = Scanner(System.`in`)
    var input = scan.nextLine()
    input.toCharArray()
    var len = input.length
    var i = 0
    var arr2 = ArrayList<String>()
    while(i < len) {

        if(input[i].toUpperCase() !== 'A' && input[i].toUpperCase() !== 'E' && input[i].toUpperCase() !== 'I' && input[i].toUpperCase() !== 'O' && input[i].toUpperCase() !== 'U' && input[i].toUpperCase() !== 'Y'){
            arr2.add(".")
            arr2.add(input[i].toString())
        }
        i++
    }
    var output: String = ""
    arr2.forEach { output += it.toLowerCase()}
    println(output)
}

/**
 * We declare a package-level function main which returns Unit and takes
 * an Array of strings as a parameter. Note that semicolons are optional.
 */
fun main(args: Array<String>) {
//	val (l,r) = readLine()!!.split(' ').map(String::toInt)
	var str = readLine()!!
    var c  =  "aoyuie";
    str = str.toLowerCase()
    var newStr = StringBuilder()
    for ( s in str ) {
        var a = 0
		for (ch in c ) {
            if (!s.equals(ch)) {
                a+=1
            }
        }
        if (a==6) {
            newStr.append(".")
            newStr.append(s)

        }

    }
    println(newStr.toString())
}

fun main(args: Array<String>) {
    val word = readLine()!!
    println(solve(word))
}

fun solve(word: String): String {
    val consonants = "aeyoui"
    return word.toLowerCase().map { c -> if (c in consonants) "" else ".$c" }.joinToString("")
}

import java.io.*
import java.util.*

fun main(args: Array<String>) {
    val inputStream = System.`in`
    val outputStream = System.out
    val input = InputReader(inputStream)
    val output = PrintWriter(outputStream)
    val solver = Task()
    solver.solve(input, output)
    output.close()
}

private class Task {
    fun solve(input: InputReader, output: PrintWriter) {
        val string = input.next()

        val dot = '.'
        val vowels = setOf('a', 'o', 'y', 'e', 'u', 'i')

        for (char in string) {
            if (char.toLowerCase() !in vowels) {
                output.print(dot)
                output.print(char.toLowerCase())
            } else {
                continue
            }
        }
    }
}

private class InputReader(stream: InputStream) {
    private var reader: BufferedReader = BufferedReader(InputStreamReader(stream), 32768)
    private var tokenizer: StringTokenizer? = null

    operator fun next(): String {
        while (tokenizer == null || tokenizer?.hasMoreTokens()?.not() == true) {
            try {
                tokenizer = StringTokenizer(reader.readLine())
            } catch (e: IOException) {
                throw RuntimeException(e)
            }

        }
        return tokenizer!!.nextToken()
    }
}

import java.util.*
import java.util.regex.Pattern
import kotlin.collections.ArrayList

fun main(){
   var string = readLine()
    print(resulting(string!!))
}

fun resulting (str:String):String{
    var string = str.replace(Regex("[aoyeui]|[AOYEUI]"), "")
    string = string.toLowerCase()
    var newString = ""
    for (i in 0..string.length-1)
        newString+="."+string[i]
    return newString
}

fun main(args: Array<String>) {
    var s= readLine()
    var s2=""
    s= s!!.toLowerCase()
    for (i in 0..(s!!.length-1)){
        if (s.get(i)=='a'||s.get(i)=='e'||s.get(i)=='i'||s.get(i)=='o'||s.get(i)=='u'||s.get(i)=='y'){
            continue
        }
        else{
            s2=s2+"."+s.get(i)
        }
    }
    print(s2)

}

import java.util.*

fun main(args: Array<String>) {
    val s: Scanner = Scanner(System.`in`)
    val str: String = s.next()
    val vowels: CharArray = charArrayOf('a', 'o', 'y', 'e', 'i', 'u')
    for (c in str) {
        val lc: Char = c.toLowerCase();
        if (lc in vowels) {
            continue
        } else {
            System.out.print("." + lc.toString())
        }
    }
}

fun main(args: Array<String>) {
    readLine()!!
            .toLowerCase()
            .replace(Regex("[aoyeui]"), "")
            .forEach { print(".$it") }
}

import java.util.Scanner

fun main(args: Array<String>) {
  Scanner(System.`in`).use {
    val result = it.next().formatWithDots()
    println(result)
  }
}

fun String.formatWithDots(): String {
  val builder = StringBuilder()
  val dot = "."
  for (char in this) {
    if (char.isVowel()) {
      continue
    }
    builder.append(dot).append(Character.toLowerCase(char))
  }
  return builder.toString()
}

fun Char.isVowel() = when (this) {
  'a', 'A', 'o', 'O', 'e', 'E', 'u', 'U', 'i', 'I', 'y', 'Y' -> true
  else -> false
}

fun main(args: Array<String>) {
    val a = readLine()!!
    val template = arrayOf("A", "O", "Y", "E", "U", "I")

    val result = a
            .filter { !template.contains(it.toString().toUpperCase()) }
            .map { it.toLowerCase() }
            .joinToString(prefix = ".", separator = ".")

    println(result)
}

// codeforces problem 118 A

fun main() {
    val vowels = setOf('a', 'e', 'i', 'o', 'u', 'y')
    val result = StringBuilder(readLine()!!.toLowerCase().filter { it !in vowels })
    for (i in result.length-1 downTo 0) {
        result.insert(i, '.')
    }
    println(result)
}

import java.io.BufferedReader
import java.io.InputStreamReader

fun main(args: Array<String>) {
    val input = BufferedReader(InputStreamReader(System.`in`))
    val string = input.readLine()
    println(customReplace(string))
}

fun customReplace(string: String) = buildString {
    for (letter in string) {
        if (!letter.isVowel()) {
            append('.')
            append(letter.toLowerCase())
        }
    }
}

fun Char.isVowel(): Boolean {
    val ch = this.toLowerCase()
    return ch == 'a' || ch == 'e' || ch == 'i' || ch == 'o' || ch == 'u' || ch == 'y'
}

fun main(args: Array<String>){
    var s = readLine()!!
    val arr = charArrayOf ('a', 'o', 'y', 'e', 'u', 'i')
    var len = s.length - 1
    val ans  = mutableListOf<Char>()
    var add = true
    for(i in 0..len) {
        add = true
        for(j in 0..5) {
            if (s[i].toLowerCase() == arr[j])
                add = false
        }
        if (add) {
            ans.add('.')
            ans.add(s[i].toLowerCase())
        }

    }
    for(i in 0..(ans.size-1))
        print(ans[i])

}

import java.util.*
fun main(args: Array<String>) {
    val scanner = Scanner(System.`in`)
    val input: String = scanner.nextLine().toLowerCase()
    val VOWELS = "aoyeui"
    val result = StringBuilder()
    input.filterNot { VOWELS.contains(it) }.forEach { result.append(".$it") }
    println(result)
}

import java.util.*

    fun main(){
        var input = Scanner(System.`in`)
        var programString = input.nextLine()
        var string =""
        programString.toLowerCase().replace("a","")
        programString.toLowerCase().toCharArray().forEach {
            string =string+changeChar(it)
        }
        System.out.println(string)
    }

fun changeChar(char : Char) : String{
    if(char == 'a' || char == 'e' || char == 'i' || char == 'o'  || char == 'u' || char == 'y'){
        return ""
    }else{
        return ".${char}"
    }
}

import java.util.*

fun main(args: Array<String>) {
    val forbidden = listOf('a', 'o', 'y', 'e', 'u', 'i')
    println(stringTask(
            Scanner(System.`in`).next(),
            forbidden
    ))
}

fun stringTask(input: String, forbidden: List<Char>): String {
    return input
            .toLowerCase()
            .filter { it !in forbidden }
            .map { ".$it" }
            .joinToString("")
}

import java.io.BufferedReader
import java.io.InputStreamReader

fun main() {
    val vowels = hashSetOf('a', 'o', 'y', 'e', 'u', 'i', 'A', 'O', 'Y', 'E', 'U', 'I')
    val br = BufferedReader(InputStreamReader(System.`in`))
    val s = br.readLine()
    val newS = s.filter { c -> !(c in vowels) }
                .map { c -> if (c.isUpperCase()) c.toLowerCase() else c}
        .joinToString(".")
    println(".$newS")
}

private fun readLn() = readLine()!!
private fun readInt() = readLn().toInt()
private fun readStrings() = readLn().split(" ")
private fun readInts() = readStrings().map { it.toInt() }

fun main(args: Array<String>) {
    val str = readLn()
    var result: String = ""

    for (c in str.toCharArray()) {
        val cl = c.toLowerCase()
        if(!isVowel(cl)) {
            result = "${result}.${cl}"
        }
    }
    println(result)
}

fun isVowel(c: Char): Boolean {
    return c == 'a' || c == 'o' || c == 'y' || c == 'e' || c == 'u' || c == 'i'
}

fun main(args: Array<String>) {
    val str = readLine()!!.toLowerCase()
    var res = ""
    for (i in str) {
        if (i !in listOf('a', 'o', 'y', 'e', 'u', 'i')) {
            res += ".$i"
        }
    }
    println(res)
}

//package problem118a

import java.lang.StringBuilder

fun convertWord(word: String): String {
    val initialModifications = word.toLowerCase().filter { "aeiouy".indexOf(it) == -1 }

    val result = StringBuilder()
    for (char in initialModifications) {
        result.append(".$char")
    }

    return result.toString()
}

fun main() {
    val input = readLine()!!
    println(convertWord(input))
}

import java.util.Scanner;
fun solve(s : String){
    for(it in s){
        if(it=='A'||it=='O'||it=='E'||it=='I'||it=='U'||it=='Y')
            print("")
        else if(it=='a'||it=='o'||it=='e'||it=='i'||it=='u'||it=='y')
            print("")
        else{
            if(it>='A'&&it<='Z')
                print(".${it.toLowerCase()}")
            else
                print(".$it")
        }
    }
    println()
}
fun main(){
    val read = Scanner(System.`in`)
    var s = read.nextLine()
    solve(s)
}

import java.util.*

fun Test(str : String) : String{
    var my_map = mapOf<Char , Boolean>('a' to false , 'o' to false , 'y' to false , 'e' to false ,'u' to false ,'i' to false )
    var s = str.toLowerCase()
    var result = ""
    for(i in 0 until str.length)
    {
        if(my_map[s[i]] == null)
        {
            result += s[i]
        }
    }
    var r = ""
    for(i in 0 until result.length)
    {
        r += "." + result[i]
    }
    return r
}
fun main()
{
    var scanner = Scanner(System.`in`)
    var str : String= scanner.next()

    println(Test(str))
}

fun main(args: Array<String>) {

    val  otherStrings  = arrayOf("a", "o", "y", "e", "u", "i")
    val line = readLine()!!.toLowerCase()
    val chars = line.toCharArray()
    for (item in chars){
        if(!otherStrings.contains("" + item)){
            print("." + item)
        }
    }

}

val vowels = arrayOf('a', 'o', 'y', 'e', 'u', 'i')

fun main(args: Array<String>){
    val string = readLine() ?: ""
    var result = ""
    for(char in string){
        if (isConsonant(char))
            result += "." + char.toLowerCase()
    }
    println(result)
}

fun isConsonant(char: Char): Boolean{
    return !(char.toLowerCase() in vowels)
}

import java.lang.StringBuilder
import java.util.Scanner

    fun main() {
        val scanner  = Scanner(System.`in`)
        val word: String = scanner.nextLine()
        val result = StringBuilder()

        for(char:Char in word.toLowerCase()) {
            if(!"aoyeui".contains(char)){
                result.append(".$char")
            }
        }
        print(result.toString())
    }

fun main(arg: Array<String>){
    val s = readLine()!!
    val b = arrayOf('a','e','y','u','i','o')
    println('.'+s.toLowerCase().filter { it !in b }.asIterable().joinToString(separator = "."))
}

        fun main(args: Array<String>) {
            val vowels = "aAoOyYeEuUiI"
            val str = readLine()!!
            var newStr = ""
            for (c: Char in str) {
                if (!(c in vowels)) {
                    newStr += "." + c.toLowerCase()
                }
            }
            println(newStr)
        }

import java.util.*

fun main(আ : Array<String>) {
    val দ: Scanner = Scanner(System.`in`)
    var ফ = arrayOf('a','e','i','o','u','y')
    var স = দ.nextLine()
    for (ম in স.toLowerCase()) {
        if(ম !in ফ) {
            print(".$ম")
        }
    }
}

fun main(args: Array<String>)
{
    val s = readLine()!!.toLowerCase()
    val glas = "aoyeui"
    var sb = StringBuilder()
    for (c in s)
    {
        if (c !in glas)
            sb.append(".$c")
    }
    println(sb)
}

fun main() {
    var str = readStr()!!.toLowerCase().toCharArray()

    var vowels = "aoyeui"

    for (i in str) {
        if (!vowels.contains(i)){
            print('.')
            print(i)
        }
    }
}

private fun readInts(): List<Int> = readLine()!!.split(' ').map { it.toInt() }
private fun readLongs(): List<Long> = readLine()!!.split(' ').map { it.toLong() }
private fun readInt(): Int = readLine()!!.toInt()
private fun readLong(): Long = readLine()!!.toLong()
private fun readStr(): String? = readLine()!!

import java.io.BufferedOutputStream
import java.io.PrintWriter
import java.util.*

fun fn1 (x : String) : String{
    var res = ""
    val v = setOf('a', 'e', 'i', 'o', 'u','y')
    for (w in x){
        if (v.contains(w.toLowerCase())){
            continue
        }
        res += ".${w.toLowerCase()}"
    }
    return res
}

fun main() {
    val sc = Scanner(System.`in`)
    val out = PrintWriter(BufferedOutputStream(System.out))

//    val testCases = sc.nextInt()
//
//    val a = mutableListOf<List<String>>()
//
//    for (i in 0..testCases) {
//        val word = sc.nextLine().split(" ")
//        for (w in word) out.println(w)
//        a.add(word)
//    }
    val tescase = sc.nextLine()
    out.println(fn1(tescase))
    out.close()
    sc.close()
}

fun main(args: Array<String>) {
    val vowels = arrayOf('a', 'o', 'e', 'u', 'i', 'y')
    val word = readLine()!!
    println(word.toLowerCase().filter { !vowels.contains(it) }.map { ".$it" }.joinToString(separator = ""))
}

import java.util.*

fun main(args: Array<String>) {
    val sc = Scanner(System.`in`)
    println("." + sc.nextLine().toLowerCase().replace("a|e|o|i|u|y".toRegex(),"").toCharArray().joinToString("."))

}

import java.util.*

fun main(args: Array<String>){
    val scan = Scanner(System.`in`)
    var word = scan.next().toLowerCase()
    val glas = arrayOf("a", "o", "y", "e", "u", "i")
    val nGlas = arrayOf("b", "c", "d", "f", "g", "h", "j", "k", "l", "m", "n", "p", "q", "r", "s", "t", "v", "w", "x", "z")

    for (i in glas){
        word = word.replace(i, "")
    }
    for (i in nGlas) word = word.replace(i,".$i")
    print(word)
}

fun main() {
    val word = readLine()

    println(word!!.toLowerCase()
        .replace("[aoyeui]".toRegex(), "")
        .replace(".".toRegex()) { "." + it.value }
    )
}

import java.util.Scanner

/**
 *Created by Kartik Patodi on 28-05-2017.
 **/

fun main(args: Array<String>) {
    val sc = Scanner(System.`in`)
    var s = sc.nextLine()
    s = s.stringTask()
    println(s)
}

fun String.stringTask() = this.replace("[aeiouyAEIOUY]+".toRegex(), "").toLowerCase().replace("", ".").dropLast(1)

fun main() {
    var s = readLine()!!
    s = s.toLowerCase()
    var arr = listOf<Char>('a', 'i', 'o', 'y', 'e', 'u')
    for (c in s) {
        if(c !in arr){
            print('.')
            print(c)
        }
    }
}

fun main() {
    println(readLine()!!.asSequence()
        .map { it.toLowerCase() }
        .filter { it !in setOf('a', 'e', 'i', 'o', 'u', 'y') }
        .map { ".$it" }
        .joinToString(""))
}

fun main(args: Array<String>) {
    readLine()!!
        .toLowerCase()
        .replace("[aoyeui]".toRegex(), "")
        .forEach { print(".$it") }
}

fun main(args: Array<String>) {
  val vowels = arrayOf('a', 'o', 'y', 'e', 'u', 'i')
  val string = readLine()!!;
  println(string.toLowerCase().filter { it !in vowels }.map { ".$it" }.joinToString(separator = ""))
}

fun main(args: Array<String>) {
    val str = readLine()!!.toLowerCase().replace(Regex("[AaEeIiOoYyUu]"), "")
    println(str.replace(Regex("(?i)([bcdfghjklmnpqrstvwxyz])"), ".$1"))
}

fun main(){
    var someInput = readLine()!!
    var glasnie = arrayOf("A", "O", "Y", "E", "U", "I","a","o","y","e","u","i")
    var propisnie = arrayOf("Q","W","R","T","P","S","D","F","G","H","J","K","L","Z","X","C","V","B","N","M")
    var strochnie = arrayOf("q","w","r","t","p","s","d","f","g","h","j","k","l","z","x","c","v","b","n","m")
    var someOutput =""
    var count = 0
    var count2 = 0

    for (i in (0..someInput.length-1)){
        count = 0
        for (element in glasnie) {
            if (someInput[i].toString() == element) count++
        }
            if (count == 0){
                count2 = 0
                for (j in 0..19){
                    if (someInput[i].toString() == propisnie[j]){
                        count2++
                        someOutput =someOutput + "." + strochnie[j]
                    }
                }
                if (count2 ==0) someOutput =someOutput + "." + someInput[i]
            }
        }
    println(someOutput)
    }

fun main() = readLine()!!.toLowerCase().forEach { if (it !in arrayOf('a', 'e', 'o', 'u', 'i', 'y')) print(".$it") }

import java.lang.StringBuilder

fun main() {

    val input = readLine()

    if (input == null) {
        return
    }

    val vowels: String = "AOYEUI"

    val result: StringBuilder = StringBuilder()

    input.forEach {

        if (vowels.contains(it, ignoreCase = true) == false) {
            result.append("." + it.toLowerCase())
        }

    }

    println(result.toString())

}

import java.io.BufferedReader
import java.io.InputStreamReader

fun main(args: Array<String>) {
    val br = BufferedReader(InputStreamReader(System.`in`))
    var s:String = br.readLine()!!.toLowerCase()
    var set = hashSetOf<Char>('a','e','o','y','u','i')
    var res:StringBuilder = StringBuilder()
    for(c in s.toCharArray())
        if(!set.contains(c))
            res.append(".$c")
    println(res)
}

fun main(args:Array<String>){
    var str = readLine()!!.toLowerCase()

    for(i in 0 until str.length){
        if(str[i] != 'a' && str[i] != 'o' && str[i] != 'y' && str[i] != 'e' && str[i] != 'u' && str[i] != 'i') {
            print(".")
            print(str[i])
        }
    }
}

fun main() {
        val vowels = "aoyeui"
        var result = ""
        val input = readLine()!!
        input.forEach {
            val c = it.toLowerCase()
            if(c !in vowels) {
                result += ".$c"
            }
        }
        println(result)
}

fun main(args: Array<String>) {

    val letters = arrayListOf('a', 'o', 'y', 'e', 'u', 'i')
    var input = readLine()!!

    input = input.toLowerCase()

    var result = ""

    (0 until input.length)
            .filter { letters.indexOf(input[it]) == -1 }
            .forEach { result += "." + input[it] }

    println(result)
}

import java.util.*

private val scan = Scanner(System.`in`)

fun main(args: Array<String>) {

    scan.next()
            .toLowerCase()
            .filter { it !in listOf('a', 'e', 'i', 'o', 'u', 'y') }
            .flatMap { listOf('.', it) }
            .joinToString(separator = "")
            .run { println(this) }
}

import java.io.BufferedReader
import java.io.InputStreamReader

fun main(args: Array<String>) {
    val reader = BufferedReader(InputStreamReader(System.`in`))
    val input = reader.readLine()
    println(process(input))
}

fun process(input: String): String {
    val stringBuilder = StringBuilder()
    val tmpStr = input.toLowerCase().replace(Regex("[aoyeui]"), "")
    tmpStr.forEach {
        stringBuilder.append('.')
        stringBuilder.append(it)
    }
    return stringBuilder.toString()
}

fun main() {
    val vowels = setOf('a', 'o', 'y', 'e', 'u', 'i')
    val s = readLine()!!
    val result = s.toLowerCase().filterNot { it in vowels }.toList().joinToString(".", ".")
    println(result)
}

fun main() {
    val x = readLine()!!.toLowerCase()
    println(x.replace("[aoyeui]+".toRegex(), "").replace("(.)".toRegex(), ".$1"))
}

import java.util.*

fun main(args: Array<String>) {

    val chars = arrayListOf('a', 'o', 'y', 'e', 'u', 'i')

    val word = Scanner(System.`in`).nextLine()

    word.map { if (it.toLowerCase() in chars) "" else "." + it.toLowerCase() }
            .forEach { print(it) }
}

//https://www.google.com/search?q=codeforces+watermelon&oq=codeforces+water&aqs=chrome.0.69i59j69i57j0l6.1995j0j1&sourceid=chrome&ie=UTF-8

fun main() {
	var input = readLine()!!.toString() // read integer from the input
    println(convert(input)) // print answer to the output
}

val vowels = setOf<Char>('A', 'O', 'Y', 'E', 'U', 'I', 'a', 'o', 'y', 'e', 'u', 'i')

fun convert(input: String): String {
	val builder = StringBuilder()
	input.forEach label@ { c: Char ->
		if (vowels.contains(c)) {
			return@label
		}
		builder.append('.')
		if (c.isUpperCase()) {
			builder.append(c.toLowerCase())
		} else {
			builder.append(c)
		}
	}
	return builder.toString()
}

fun main(args: Array<String>) {
    solve()
}

fun solve() {
    val vowels = arrayOf('a', 'o', 'y', 'e', 'u', 'i')
    val chars = readLine()!!
    chars.map {
        val ch = it.toLowerCase()
        if (ch !in vowels) {
            print(".$ch")
        }
    }
}

import java.util.*

/**
 * Created by AoEiuV020 on 2017/05/09.
 */
fun main(vararg args: String) {
    val str = readLine()!!
    str.map {
        it.toLowerCase()
    }.filterNot {
        it in "aoyeui"
    }.forEach {
        print(".$it")
    }
}

fun main(){
    val  input = readLine()!!.toLowerCase().replace("[aoyeui]".toRegex(),"")
    for(i in input){
        print(".$i")
    }
}

import java.lang.StringBuilder

fun main() {
    val s = readLine()!!.toLowerCase().replace(Regex("[aeyuio]"), "")
    val result = StringBuilder()
    s.forEach { result.append(".$it") }
    println(result)
}

fun main()
{

    var x = readLine()
    x = x!!.toLowerCase()
    var a : String = ""
    for (c in x)
    {
        if (c!='o' && c!='i' && c!='u'&&c!='e'&&c!='y' && c!='a')
        {
            a+=".$c"
        }
    }
    println(a)
}

fun main() {
    print(readLine()!!.toLowerCase().split("").filter {
        !"A,O,Y,E,U,I".split(",").map(String::toLowerCase).contains(it)
    }.dropLast(1).joinToString(separator = "."))
}

fun main(args: Array<String>) {
    var word = readLine()!!.toUpperCase().replace("A", "")
        .replace("O", "")
        .replace("Y", "")
        .replace("E", "")
        .replace("U", "")
        .replace("I", "")
        .toLowerCase()

    val array = word.toCharArray()
    var result = ""
    for (ch in array) {
        result += ".$ch"
    }
    println(result)
}

import java.util.*

fun main() {
    var scanner = Scanner(System.`in`)
    var a = scanner.next()
    a = a.toLowerCase()
    for(i in a.length-1 downTo 0){
        if(a[i] == 'a' || a[i]=='o'|| a[i]=='y'|| a[i]=='e'|| a[i]=='u'|| a[i]=='i') a = a.replace("${a[i]}"," ")
    }
    a = a.replace(" ", "")
    var b:String =""
    for(c in a){
         b=b.plus('.').plus(c)
    }
    println(b)
}

/**
 * Created by rohit.jh on 21/01/18
 */
fun applyOperations(a: Char): String {
    val x = a.toLowerCase()
    return if (x == 'a' || x == 'e' || x == 'i' || x == 'o' || x == 'u' || x == 'y') ""
    else ".$x"
}

fun main(args: Array<String>) {
    val str: String = readLine()!!
    for (i in 0 until str.length) {
        print(applyOperations(str[i]))
    }
}

import java.io.BufferedReader
import java.io.InputStreamReader
import java.util.*

fun main() {
    val br = BufferedReader(InputStreamReader(System.`in`))
    val token = StringTokenizer(br.readLine())
    val input = token.nextToken()

    val sb = StringBuilder()
    for (i in input.indices) {
        when (input[i]) {
            'A', 'O', 'Y', 'E', 'U', 'I', 'a', 'o', 'y', 'e', 'u', 'i' -> {
                continue
            }
            else -> {
                sb.append('.')
                sb.append(input[i].toString().toLowerCase(Locale.ROOT))
            }
        }
    }
    println(sb)
    br.close()
}

import java.util.Scanner

fun main(args: Array<String>) {
	val inp = Scanner(System.`in`)
	var word: String = inp.next().toLowerCase()
	var charArray = word.toCharArray()

	for(letter in charArray) {
		if(letter == 'a' || letter == 'e' || letter == 'i' || letter == 'o' || letter == 'u' || letter == 'y') {
			continue
		} else {
			print(".$letter")
		}
	}
}

fun main(args: Array<String>) {
    var s = readLine()!!
    s = s.replace(Regex("[aeyuioAEYUOI]"), "")

    var res = ""

    s.forEach {
        res += ".${it.toLowerCase()}"
    }

    print(res)
}

import java.io.PrintWriter
import java.util.StringTokenizer

fun main() = output {
    val string = read()
    val result = string
        .toLowerCase()
        .replace(Regex("[aeiouy]"), "")
        .replace(Regex(".")) {
            ".${it.value}"
        }

    println(result)
}

@JvmField
val INPUT = System.`in`

@JvmField
val OUTPUT = System.out

@JvmField
val _reader = INPUT.bufferedReader()
fun readLine(): String? = _reader.readLine()
fun readLn() = _reader.readLine()!!

@JvmField
var _tokenizer: StringTokenizer = StringTokenizer("")
fun read(): String {
    while (_tokenizer.hasMoreTokens().not()) _tokenizer = StringTokenizer(_reader.readLine() ?: return "", " ")
    return _tokenizer.nextToken()
}

fun readInt() = read().toInt()
fun readDouble() = read().toDouble()
fun readLong() = read().toLong()
fun readStrings(n: Int) = List(n) { read() }
fun readLines(n: Int) = List(n) { readLn() }
fun readInts(n: Int) = List(n) { read().toInt() }
fun readIntArray(n: Int) = IntArray(n) { read().toInt() }
fun readDoubles(n: Int) = List(n) { read().toDouble() }
fun readDoubleArray(n: Int) = DoubleArray(n) { read().toDouble() }
fun readLongs(n: Int) = List(n) { read().toLong() }
fun readLongArray(n: Int) = LongArray(n) { read().toLong() }

@JvmField
val _writer = PrintWriter(OUTPUT, false)

fun output(block: PrintWriter.() -> Unit) {
    _writer.apply(block).flush()
}

fun main()
{
    var s = readLine()!!.toString()
    for (p in s)
    {
        var c = p.toLowerCase()
        if(c!='a' && c!='e' && c!='i' && c!='o' && c!='u' && c!='y')
            print(".$c")
    }
}

fun main()
{
    var st = readLine()!!
    st = st.toLowerCase()
    var s : String = ""
    val arr = arrayOf('a','o','y','e','u','i')
    for(i in st)
    {
        if(i !in arr)
        {
            s = s.plus("."+i)
        }
    }
    println(s)
}

import java.util.*

fun main(){

    val read = Scanner(System.`in`)
    val s = read.nextLine().toLowerCase()
    for(i in 0 until s.length)  if((s[i] == 'a' || s[i]  == 'e' || s[i]  == 'i' || s[i]  == 'o' || s[i]  == 'u' || s[i]  == 'y'))
        continue
    else print("."+s[i])
    }

import java.util.*

fun isVowel(c : Char): Boolean = c.toUpperCase() in "AEIOUY"

fun main(args : Array<String>) {
    val scan = Scanner (System.`in`)
    val s = scan.next()
    val r = StringBuilder()
    for ( c in s )
        if ( !isVowel(c) ){
            r.append('.')
            r.append(c.toLowerCase())
        }
    println(r)
}

fun main() {
    val input = readLine()!!
    val vowels = Regex("[aoyeui]")
    val intermed = vowels.replace(input.toLowerCase(), "")
    var answer = ""
    for(i in 0..intermed.length - 1){
        answer += "." + intermed[i]
    }
    print(answer)
}

/* template start */
// input
private fun readString() = readLine()!!
private fun readStrings() = readString().split(" ")
private fun readInt() = readString().toInt()
private fun readDigits() = readString().map { it - '0' }
private fun readInts() = readStrings().map { it.toInt() }
private fun readLongs() = readStrings().map { it.toLong() }

// output
private fun <T> T.print(map: (T) -> String = { it.toString() }) = println(map(this))
private fun <T> Iterable<T>.print(sep: String? = null, map: ((T) -> String)? = null) = asSequence().print(sep, map)
private fun <T> Array<T>.print(sep: String? = null, map: ((T) -> String)? = null) = asSequence().print(sep, map)
private fun <T> Sequence<T>.print(sep: String? = null, map: ((T) -> String)? = null) =
    println(joinToString(sep ?: "", transform = map ?: { it.toString() }))

// various
private val Int.isEven: Boolean get() = this % 2 == 0
private val Int.isOdd: Boolean get() = !this.isEven
private fun queries(block: (Int) -> Unit) = repeat(readInt(), block)

/* template end */

fun main() {
    val input = readString()
    buildString {
        for (c in input) {
            val c = c.toLowerCase()
            if (c !in setOf('a', 'e', 'i', 'o', 'u','y')) {
                append('.')
                append(c)
            }
        }
    }.print()
}

import java.io.BufferedReader
import java.io.InputStreamReader

fun main()  {
    val reader = BufferedReader(InputStreamReader(System.`in`))

    val s = reader.readLine()
    println(s.toLowerCase()
            .replace(Regex("""[aoyeui]"""), "")
            .replace(Regex("""[a-z]""")) { "." + it.value })
}

// kotlin oj template code from uwi(Codeforces), and convert to kotlin by lety
import java.io.ByteArrayInputStream
import java.io.IOException
import java.io.InputStream
import java.io.PrintWriter
import java.util.Arrays
import java.util.InputMismatchException

lateinit var `is`: InputStream
lateinit var out: PrintWriter
var INPUT = ""

//val oj = System.getProperty("ONLINE_JUDGE") != null
val oj = true
val inbuf = ByteArray(1024)
var lenbuf = 0
var ptrbuf = 0

fun solve() {
    val s = ns()

    s.forEach {
        if(it in "aeiou")
        {
        }
        else
        {
            print('.')

            if(it.isUpperCase())
            {
                print(it.toLowerCase())
            }
            else
            {
                print(it)
            }
        }
    }

}

fun main() {
    `is` = if (oj) System.`in` else ByteArrayInputStream(INPUT.toByteArray())
    out = PrintWriter(System.out)

    val s = System.currentTimeMillis()
    solve()
    out.flush()
    tr((System.currentTimeMillis() - s).toString() + "ms")
}

private fun readByte(): Int {
    if (lenbuf == -1) throw InputMismatchException()
    if (ptrbuf >= lenbuf) {
        ptrbuf = 0
        try {
            lenbuf = `is`.read(inbuf)
        } catch (e: IOException) {
            throw InputMismatchException()
        }

        if (lenbuf <= 0) return -1
    }
    return inbuf[ptrbuf++].toInt()
}

private fun isSpaceChar(c: Int): Boolean = !(c >= 33 && c <= 126)

private fun skip(): Int {
    var b: Int = readByte()
    while (b != -1 && isSpaceChar(b)) {
        b = readByte()
    }
    return b
}

// using ns()
private fun nd(): Double = ns().toDouble()

// using ns()
private fun nc(): Char = skip().toChar()

// input until whitespace
private fun ns(): String {
    var b = skip()
    val sb = StringBuilder()
    while (!isSpaceChar(b)) { // when nextLine, (isSpaceChar(b) && b != ' ')
        sb.appendCodePoint(b)
        b = readByte()
    }
    return sb.toString()
}

private fun ns(n: Int): CharArray {
    val buf = CharArray(n)
    var b = skip()
    var p = 0
    while (p < n && !isSpaceChar(b)) {
        buf[p++] = b.toChar()
        b = readByte()
    }
    return if (n == p) buf else Arrays.copyOf(buf, p)
}

// matrix
private fun nm(n: Int, m: Int): Array<CharArray> {
    val map = Array(n) { CharArray(m) }
    for (i in 0 until n) map[i] = ns(m)
    return map
}

private fun pm(matrix: Array<CharArray>) {
    val n = matrix.size
    val m = matrix[0].size
    repeat(n)
    {
        repeat(m)
        { jt ->
            out.print(matrix[it][jt])
        }
        out.println()
    }
    out.flush()
}

// int array
private fun na(n: Int): IntArray {
    val a = IntArray(n)
    for (i in 0 until n) a[i] = ni()
    return a
}

private fun ni(): Int {
    var num = 0
    var b: Int = readByte()
    var minus = false
    while (b != -1 && !(b >= '0'.toInt() && b <= '9'.toInt() || b == '-'.toInt())) {
        b = readByte()
    }
    if (b == '-'.toInt()) {
        minus = true
        b = readByte()
    }

    while (true) {
        if (b >= '0'.toInt() && b <= '9'.toInt()) {
            num = num * 10 + (b - '0'.toInt())
        } else {
            return if (minus) -num else num
        }
        b = readByte()
    }
}

private fun nl(): Long {
    var num: Long = 0
    var b: Int = readByte()
    var minus = false
    while (b != -1 && !(b >= '0'.toInt() && b <= '9'.toInt() || b == '-'.toInt())) {
        b = readByte()
    }
    if (b == '-'.toInt()) {
        minus = true
        b = readByte()
    }

    while (true) {
        if (b >= '0'.toInt() && b <= '9'.toInt()) {
            num = num * 10 + (b - '0'.toInt())
        } else {
            return if (minus) -num else num
        }
        b = readByte()
    }
}

private fun tr(vararg o: Any) {
//    if (!oj) println(Arrays.deepToString(o))
}

// kotlin oj template code from uwi(Codeforces), and convert to kotlin by lety
import java.io.ByteArrayInputStream
import java.io.IOException
import java.io.InputStream
import java.io.PrintWriter
import java.util.Arrays
import java.util.InputMismatchException

lateinit var `is`: InputStream
lateinit var out: PrintWriter
var INPUT = ""

//val oj = System.getProperty("ONLINE_JUDGE") != null
val oj = true
val inbuf = ByteArray(1024)
var lenbuf = 0
var ptrbuf = 0

fun solve() {
    val s = ns()

    s.forEach {
        if(it in "aeiouAEIOU")
        {
        }
        else
        {
            print('.')

            if(it.isUpperCase())
            {
                print(it.toLowerCase())
            }
            else
            {
                print(it)
            }
        }
    }

}

fun main() {
    `is` = if (oj) System.`in` else ByteArrayInputStream(INPUT.toByteArray())
    out = PrintWriter(System.out)

    val s = System.currentTimeMillis()
    solve()
    out.flush()
    tr((System.currentTimeMillis() - s).toString() + "ms")
}

private fun readByte(): Int {
    if (lenbuf == -1) throw InputMismatchException()
    if (ptrbuf >= lenbuf) {
        ptrbuf = 0
        try {
            lenbuf = `is`.read(inbuf)
        } catch (e: IOException) {
            throw InputMismatchException()
        }

        if (lenbuf <= 0) return -1
    }
    return inbuf[ptrbuf++].toInt()
}

private fun isSpaceChar(c: Int): Boolean = !(c >= 33 && c <= 126)

private fun skip(): Int {
    var b: Int = readByte()
    while (b != -1 && isSpaceChar(b)) {
        b = readByte()
    }
    return b
}

// using ns()
private fun nd(): Double = ns().toDouble()

// using ns()
private fun nc(): Char = skip().toChar()

// input until whitespace
private fun ns(): String {
    var b = skip()
    val sb = StringBuilder()
    while (!isSpaceChar(b)) { // when nextLine, (isSpaceChar(b) && b != ' ')
        sb.appendCodePoint(b)
        b = readByte()
    }
    return sb.toString()
}

private fun ns(n: Int): CharArray {
    val buf = CharArray(n)
    var b = skip()
    var p = 0
    while (p < n && !isSpaceChar(b)) {
        buf[p++] = b.toChar()
        b = readByte()
    }
    return if (n == p) buf else Arrays.copyOf(buf, p)
}

// matrix
private fun nm(n: Int, m: Int): Array<CharArray> {
    val map = Array(n) { CharArray(m) }
    for (i in 0 until n) map[i] = ns(m)
    return map
}

private fun pm(matrix: Array<CharArray>) {
    val n = matrix.size
    val m = matrix[0].size
    repeat(n)
    {
        repeat(m)
        { jt ->
            out.print(matrix[it][jt])
        }
        out.println()
    }
    out.flush()
}

// int array
private fun na(n: Int): IntArray {
    val a = IntArray(n)
    for (i in 0 until n) a[i] = ni()
    return a
}

private fun ni(): Int {
    var num = 0
    var b: Int = readByte()
    var minus = false
    while (b != -1 && !(b >= '0'.toInt() && b <= '9'.toInt() || b == '-'.toInt())) {
        b = readByte()
    }
    if (b == '-'.toInt()) {
        minus = true
        b = readByte()
    }

    while (true) {
        if (b >= '0'.toInt() && b <= '9'.toInt()) {
            num = num * 10 + (b - '0'.toInt())
        } else {
            return if (minus) -num else num
        }
        b = readByte()
    }
}

private fun nl(): Long {
    var num: Long = 0
    var b: Int = readByte()
    var minus = false
    while (b != -1 && !(b >= '0'.toInt() && b <= '9'.toInt() || b == '-'.toInt())) {
        b = readByte()
    }
    if (b == '-'.toInt()) {
        minus = true
        b = readByte()
    }

    while (true) {
        if (b >= '0'.toInt() && b <= '9'.toInt()) {
            num = num * 10 + (b - '0'.toInt())
        } else {
            return if (minus) -num else num
        }
        b = readByte()
    }
}

private fun tr(vararg o: Any) {
//    if (!oj) println(Arrays.deepToString(o))
}

fun main()
{
    val given = readLine()!!
    var answer = ""
    for (i in given)
    {
        if (! "AEIOUaeiou".contains(i))
        {
            answer += "."+i.toLowerCase()
        }
    }
    println(answer)
}

import java.io.PrintWriter
import java.util.StringTokenizer
import kotlin.math.*
import kotlin.random.*
import kotlin.collections.sort as _sort
import kotlin.collections.sortDescending as _sortDescending
import kotlin.io.println as iprintln

fun main() { _writer.solve(); _writer.flush() }

fun PrintWriter.solve() {
    var result = readLn()
    result.toLowerCase()
    result = result.replace("a","")
    result = result.replace("e","")
    result = result.replace("y","")
    result = result.replace("u","")
    result = result.replace("i","")
    result = result.replace("o","")
    var newChars = ""
    for (i in 0 until result.length) {
        newChars = newChars.plus(".").plus(result[i])
    }
    println(newChars.toString())
}

/** IO code start */
//@JvmField val INPUT = File("input.txt").inputStream()
//@JvmField val OUTPUT = File("output.txt").outputStream()
@JvmField val INPUT = System.`in`
@JvmField val OUTPUT = System.out

@JvmField val _reader = INPUT.bufferedReader()
fun readLine(): String? = _reader.readLine()
fun readLn() = _reader.readLine()!!
@JvmField var _tokenizer: StringTokenizer = StringTokenizer("")
fun read(): String {
    while (_tokenizer.hasMoreTokens().not()) _tokenizer = StringTokenizer(_reader.readLine() ?: return "", " ")
    return _tokenizer.nextToken()
}
fun readInt() = read().toInt()
fun readDouble() = read().toDouble()
fun readLong() = read().toLong()
fun readStrings(n: Int) = List(n) { read() }
fun readLines(n: Int) = List(n) { readLn() }
fun readInts(n: Int) = List(n) { read().toInt() }
fun readIntArray(n: Int) = IntArray(n) { read().toInt() }
fun readDoubles(n: Int) = List(n) { read().toDouble() }
fun readDoubleArray(n: Int) = DoubleArray(n) { read().toDouble() }
fun readLongs(n: Int) = List(n) { read().toLong() }
fun readLongArray(n: Int) = LongArray(n) { read().toLong() }

@JvmField val _writer = PrintWriter(OUTPUT, false)

/** shuffles and sort overrides to avoid quicksort attacks */
private inline fun <T> _shuffle(rnd: Random, get: (Int) -> T, set: (Int, T) -> Unit, size: Int) {
    // Fisher-Yates shuffle algorithm
    for (i in size - 1 downTo 1) {
        val j = rnd.nextInt(i + 1)
        val temp = get(i)
        set(i, get(j))
        set(j, temp)
    }
}

@JvmField var _random: Random? = null
val random get() = _random ?: Random(0x594E215C123 * System.nanoTime()).also { _random = it }

fun IntArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun IntArray.sort() { shuffle(); _sort() }
fun IntArray.sortDescending() { shuffle(); _sortDescending() }

fun LongArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun LongArray.sort() { shuffle(); _sort() }
fun LongArray.sortDescending() { shuffle(); _sortDescending() }

fun DoubleArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun DoubleArray.sort() { shuffle(); _sort() }
fun DoubleArray.sortDescending() { shuffle(); _sortDescending() }

fun CharArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
inline fun CharArray.sort() { _sort() }
inline fun CharArray.sortDescending() { _sortDescending() }

inline fun <T: Comparable<T>> Array<out T>.sort() = _sort()
inline fun <T: Comparable<T>> Array<out T>.sortDescending() = _sortDescending()
inline fun <T: Comparable<T>> MutableList<out T>.sort() = _sort()
inline fun <T: Comparable<T>> MutableList<out T>.sortDescending() = _sortDescending()

import java.io.PrintWriter
import java.util.StringTokenizer
import kotlin.math.*
import kotlin.random.*
import kotlin.collections.sort as _sort
import kotlin.collections.sortDescending as _sortDescending
import kotlin.io.println as iprintln

fun main() { _writer.solve(); _writer.flush() }

fun PrintWriter.solve() {
    var result = readLn()
    result.toLowerCase()
    result.removeVowels()
    var newChars = ""
    for (i in 0 until result.length) {
        newChars = ".".plus(result[i])
    }
    println(newChars.toString())
}

fun String.removeVowels() {
    this.replace("a","",false)
    this.replace("e","",false)
    this.replace("y","",false)
    this.replace("u","",false)
    this.replace("i","",false)
    this.replace("o","",false)
}

/** IO code start */
//@JvmField val INPUT = File("input.txt").inputStream()
//@JvmField val OUTPUT = File("output.txt").outputStream()
@JvmField val INPUT = System.`in`
@JvmField val OUTPUT = System.out

@JvmField val _reader = INPUT.bufferedReader()
fun readLine(): String? = _reader.readLine()
fun readLn() = _reader.readLine()!!
@JvmField var _tokenizer: StringTokenizer = StringTokenizer("")
fun read(): String {
    while (_tokenizer.hasMoreTokens().not()) _tokenizer = StringTokenizer(_reader.readLine() ?: return "", " ")
    return _tokenizer.nextToken()
}
fun readInt() = read().toInt()
fun readDouble() = read().toDouble()
fun readLong() = read().toLong()
fun readStrings(n: Int) = List(n) { read() }
fun readLines(n: Int) = List(n) { readLn() }
fun readInts(n: Int) = List(n) { read().toInt() }
fun readIntArray(n: Int) = IntArray(n) { read().toInt() }
fun readDoubles(n: Int) = List(n) { read().toDouble() }
fun readDoubleArray(n: Int) = DoubleArray(n) { read().toDouble() }
fun readLongs(n: Int) = List(n) { read().toLong() }
fun readLongArray(n: Int) = LongArray(n) { read().toLong() }

@JvmField val _writer = PrintWriter(OUTPUT, false)

/** shuffles and sort overrides to avoid quicksort attacks */
private inline fun <T> _shuffle(rnd: Random, get: (Int) -> T, set: (Int, T) -> Unit, size: Int) {
    // Fisher-Yates shuffle algorithm
    for (i in size - 1 downTo 1) {
        val j = rnd.nextInt(i + 1)
        val temp = get(i)
        set(i, get(j))
        set(j, temp)
    }
}

@JvmField var _random: Random? = null
val random get() = _random ?: Random(0x594E215C123 * System.nanoTime()).also { _random = it }

fun IntArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun IntArray.sort() { shuffle(); _sort() }
fun IntArray.sortDescending() { shuffle(); _sortDescending() }

fun LongArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun LongArray.sort() { shuffle(); _sort() }
fun LongArray.sortDescending() { shuffle(); _sortDescending() }

fun DoubleArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun DoubleArray.sort() { shuffle(); _sort() }
fun DoubleArray.sortDescending() { shuffle(); _sortDescending() }

fun CharArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
inline fun CharArray.sort() { _sort() }
inline fun CharArray.sortDescending() { _sortDescending() }

inline fun <T: Comparable<T>> Array<out T>.sort() = _sort()
inline fun <T: Comparable<T>> Array<out T>.sortDescending() = _sortDescending()
inline fun <T: Comparable<T>> MutableList<out T>.sort() = _sort()
inline fun <T: Comparable<T>> MutableList<out T>.sortDescending() = _sortDescending()

import java.io.PrintWriter
import java.util.StringTokenizer
import kotlin.math.*
import kotlin.random.*
import kotlin.collections.sort as _sort
import kotlin.collections.sortDescending as _sortDescending
import kotlin.io.println as iprintln

fun main() { _writer.solve(); _writer.flush() }

fun PrintWriter.solve() {
    var result = readLn()
    result.toLowerCase()
    result.removeVowels()
    var newChars = ""
    for (i in 0 until result.length) {
        newChars = ".".plus(result[i])
    }
    println(result)
}

fun String.removeVowels() {
    this.replace("a","",false)
    this.replace("e","",false)
    this.replace("y","",false)
    this.replace("u","",false)
    this.replace("i","",false)
    this.replace("o","",false)
}

/** IO code start */
//@JvmField val INPUT = File("input.txt").inputStream()
//@JvmField val OUTPUT = File("output.txt").outputStream()
@JvmField val INPUT = System.`in`
@JvmField val OUTPUT = System.out

@JvmField val _reader = INPUT.bufferedReader()
fun readLine(): String? = _reader.readLine()
fun readLn() = _reader.readLine()!!
@JvmField var _tokenizer: StringTokenizer = StringTokenizer("")
fun read(): String {
    while (_tokenizer.hasMoreTokens().not()) _tokenizer = StringTokenizer(_reader.readLine() ?: return "", " ")
    return _tokenizer.nextToken()
}
fun readInt() = read().toInt()
fun readDouble() = read().toDouble()
fun readLong() = read().toLong()
fun readStrings(n: Int) = List(n) { read() }
fun readLines(n: Int) = List(n) { readLn() }
fun readInts(n: Int) = List(n) { read().toInt() }
fun readIntArray(n: Int) = IntArray(n) { read().toInt() }
fun readDoubles(n: Int) = List(n) { read().toDouble() }
fun readDoubleArray(n: Int) = DoubleArray(n) { read().toDouble() }
fun readLongs(n: Int) = List(n) { read().toLong() }
fun readLongArray(n: Int) = LongArray(n) { read().toLong() }

@JvmField val _writer = PrintWriter(OUTPUT, false)

/** shuffles and sort overrides to avoid quicksort attacks */
private inline fun <T> _shuffle(rnd: Random, get: (Int) -> T, set: (Int, T) -> Unit, size: Int) {
    // Fisher-Yates shuffle algorithm
    for (i in size - 1 downTo 1) {
        val j = rnd.nextInt(i + 1)
        val temp = get(i)
        set(i, get(j))
        set(j, temp)
    }
}

@JvmField var _random: Random? = null
val random get() = _random ?: Random(0x594E215C123 * System.nanoTime()).also { _random = it }

fun IntArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun IntArray.sort() { shuffle(); _sort() }
fun IntArray.sortDescending() { shuffle(); _sortDescending() }

fun LongArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun LongArray.sort() { shuffle(); _sort() }
fun LongArray.sortDescending() { shuffle(); _sortDescending() }

fun DoubleArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun DoubleArray.sort() { shuffle(); _sort() }
fun DoubleArray.sortDescending() { shuffle(); _sortDescending() }

fun CharArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
inline fun CharArray.sort() { _sort() }
inline fun CharArray.sortDescending() { _sortDescending() }

inline fun <T: Comparable<T>> Array<out T>.sort() = _sort()
inline fun <T: Comparable<T>> Array<out T>.sortDescending() = _sortDescending()
inline fun <T: Comparable<T>> MutableList<out T>.sort() = _sort()
inline fun <T: Comparable<T>> MutableList<out T>.sortDescending() = _sortDescending()

import java.io.PrintWriter
import java.util.StringTokenizer
import kotlin.math.*
import kotlin.random.*
import kotlin.collections.sort as _sort
import kotlin.collections.sortDescending as _sortDescending
import kotlin.io.println as iprintln

fun main() { _writer.solve(); _writer.flush() }

fun PrintWriter.solve() {
    var result = readLn()
    result.toLowerCase()
    result = result.replace("a","")
    result = result.replace("e","")
    result = result.replace("y","")
    result = result.replace("u","")
    result = result.replace("i","")
    result = result.replace("o","")
    var newChars = ""
    for (i in 0 until result.length) {
        newChars = newChars.plus(".").plus(result[i])
    }
    println(result)
}

/** IO code start */
//@JvmField val INPUT = File("input.txt").inputStream()
//@JvmField val OUTPUT = File("output.txt").outputStream()
@JvmField val INPUT = System.`in`
@JvmField val OUTPUT = System.out

@JvmField val _reader = INPUT.bufferedReader()
fun readLine(): String? = _reader.readLine()
fun readLn() = _reader.readLine()!!
@JvmField var _tokenizer: StringTokenizer = StringTokenizer("")
fun read(): String {
    while (_tokenizer.hasMoreTokens().not()) _tokenizer = StringTokenizer(_reader.readLine() ?: return "", " ")
    return _tokenizer.nextToken()
}
fun readInt() = read().toInt()
fun readDouble() = read().toDouble()
fun readLong() = read().toLong()
fun readStrings(n: Int) = List(n) { read() }
fun readLines(n: Int) = List(n) { readLn() }
fun readInts(n: Int) = List(n) { read().toInt() }
fun readIntArray(n: Int) = IntArray(n) { read().toInt() }
fun readDoubles(n: Int) = List(n) { read().toDouble() }
fun readDoubleArray(n: Int) = DoubleArray(n) { read().toDouble() }
fun readLongs(n: Int) = List(n) { read().toLong() }
fun readLongArray(n: Int) = LongArray(n) { read().toLong() }

@JvmField val _writer = PrintWriter(OUTPUT, false)

/** shuffles and sort overrides to avoid quicksort attacks */
private inline fun <T> _shuffle(rnd: Random, get: (Int) -> T, set: (Int, T) -> Unit, size: Int) {
    // Fisher-Yates shuffle algorithm
    for (i in size - 1 downTo 1) {
        val j = rnd.nextInt(i + 1)
        val temp = get(i)
        set(i, get(j))
        set(j, temp)
    }
}

@JvmField var _random: Random? = null
val random get() = _random ?: Random(0x594E215C123 * System.nanoTime()).also { _random = it }

fun IntArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun IntArray.sort() { shuffle(); _sort() }
fun IntArray.sortDescending() { shuffle(); _sortDescending() }

fun LongArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun LongArray.sort() { shuffle(); _sort() }
fun LongArray.sortDescending() { shuffle(); _sortDescending() }

fun DoubleArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
fun DoubleArray.sort() { shuffle(); _sort() }
fun DoubleArray.sortDescending() { shuffle(); _sortDescending() }

fun CharArray.shuffle(rnd: Random = random) = _shuffle(rnd, ::get, ::set, size)
inline fun CharArray.sort() { _sort() }
inline fun CharArray.sortDescending() { _sortDescending() }

inline fun <T: Comparable<T>> Array<out T>.sort() = _sort()
inline fun <T: Comparable<T>> Array<out T>.sortDescending() = _sortDescending()
inline fun <T: Comparable<T>> MutableList<out T>.sort() = _sort()
inline fun <T: Comparable<T>> MutableList<out T>.sortDescending() = _sortDescending()

import java.util.Scanner

fun main(args: Array<String>) {
  Scanner(System.`in`).use {
    val result = it.next().formatWithDots()
    println(result)
  }
}

fun String.formatWithDots(): String {
  val builder = StringBuilder()
  val dot = "."
  for (char in this) {
    if (char.isVowel()) {
      continue
    }
    builder.append(dot).append(Character.toLowerCase(char))
  }
  return builder.toString()
}

fun Char.isVowel() = when (this) {
  'a', 'A', 'o', 'O', 'e', 'E', 'u', 'U', 'i', 'I' -> true
  else -> false
}

import java.util.*

    fun main(){
        var input = Scanner(System.`in`)
        var programString = input.nextLine()
        var string =""
        programString.toLowerCase().replace("a","")
        programString.toLowerCase().toCharArray().forEach {
            string =string+changeChar(it)
        }
        System.out.println(string)
    }

fun changeChar(char : Char) : String{
    if(char == 'a' || char == 'e' || char == 'i' || char == 'o'  || char == 'u'){
        return ""
    }else if(char == 'y' || char == 'z'){
        return char.toString()
    }else{
        return ".${char}"
    }
}

import java.util.*

    fun main(){
        var input = Scanner(System.`in`)
        var programString = input.nextLine()
        var string =""
        programString.toLowerCase().toCharArray().forEach {
            string =string+changeChar(it)
        }
        System.out.println(string)
    }

fun changeChar(char : Char) : String{
    if(char == 'a' || char == 'e' || char == 'i' || char == 'o'  || char == 'u'){
        return ""
    }else{
        return ".${char}"
    }
}

import java.io.BufferedReader
import java.io.InputStreamReader

fun main() {
    val vowels = hashSetOf('a', 'e', 'i', 'o', 'u', 'A', 'E', 'I', 'O', 'U')
    val br = BufferedReader(InputStreamReader(System.`in`))
    val s = br.readLine()
    val newS = s.filter { c -> !(c in vowels) }
                .map { c -> if (c.isUpperCase()) c.toLowerCase() else c}
        .joinToString(".")
    println(".$newS")
}

//package problem118a

import java.lang.StringBuilder

fun convertWord(word: String): String {
    val initialModifications = word.toLowerCase().filter { "aeiou".indexOf(it) == -1 }

    val result = StringBuilder()
    for (char in initialModifications) {
        result.append(".$char")
    }

    return result.toString()
}

fun main() {
    val input = readLine()!!
    println(convertWord(input))
}

//package problem118a

import java.lang.StringBuilder

fun convertWord(word: String): String {
    val initialModifications = word.filter { "aeiou".indexOf(it) == -1 }

    val result = StringBuilder()
    for (char in initialModifications) {
        result.append(".$char")
    }

    return result.toString().toLowerCase()
}

fun main() {
    val input = readLine()!!
    println(convertWord(input))
}

//package problem118a

import java.lang.StringBuilder

fun convertWord(word: String): String {
    val initialModifications = word.filter { "aeiouAEIOU".indexOf(it) == -1 }

    val result = StringBuilder()
    for (char in initialModifications) {
        result.append(".$char")
    }

    return result.toString().toLowerCase()
}

fun main() {
    val input = readLine()!!
    println(convertWord(input))
}

fun main(args: Array<String>) {

    val  otherStrings  = arrayOf("a", "o", "y", "e", "u", "i")
    val line = readLine()!!.toLowerCase()
    val chars = line.toCharArray()
    for (item in chars){
        if(otherStrings.contains("" + item)){
            print(".")
        }
        else {
            print(item)
        }
    }

}

import java.lang.StringBuilder
import java.util.Scanner

    fun main() {
        val scanner  = Scanner(System.`in`)
        val word: String = scanner.nextLine()
        val result = StringBuilder()

        for(char:Char in word) {
            if(!"aoyeui".contains(char.toLowerCase())){
                result.append(".$char")
            }
        }
        print(result.toString())
    }

fun main(arg: Array<String>){
    val s = readLine()!!
    val b = arrayOf('a','e','y','u','i','o')
    println(s.toLowerCase().filter { it !in b }.asIterable().joinToString(separator = "."))
}

import java.io.BufferedOutputStream
import java.io.PrintWriter
import java.util.*

fun fn1 (x : String) : String{
    var res = ""
    val v = setOf('a', 'e', 'i', 'o', 'u')
    for (w in x){
        if (v.contains(w)){
            continue
        }
        res += ".${w.toLowerCase()}"
    }
    return res
}

fun main() {
    val sc = Scanner(System.`in`)
    val out = PrintWriter(BufferedOutputStream(System.out))

//    val testCases = sc.nextInt()
//
//    val a = mutableListOf<List<String>>()
//
//    for (i in 0..testCases) {
//        val word = sc.nextLine().split(" ")
//        for (w in word) out.println(w)
//        a.add(word)
//    }
    val tescase = sc.nextLine()
    out.println(fn1(tescase))
    out.close()
    sc.close()
}

import java.util.Scanner

/**
 *Created by Kartik Patodi on 28-05-2017.
 **/

fun main(args: Array<String>) {
    val sc = Scanner(System.`in`)
    var s = sc.nextLine()
    s = s.stringTask().substring(0..s.length-1)
    println(s)
}

fun String.stringTask() = this.replace("[aeiouAEIOU]+".toRegex(), "").toLowerCase().replace("", ".")

import java.util.Scanner

/**
 *Created by Kartik Patodi on 28-05-2017.
 **/

fun main(args: Array<String>) {
    val sc = Scanner(System.`in`)
    var s = sc.nextLine()
    s = s.stringTask()
    println(s)
}

fun String.stringTask() = this.replace("[aeiouAEIOU]+".toRegex(), "").toLowerCase().replace("", ".").substring(0..this.length-2)

import java.util.Scanner

/**
 *Created by Kartik Patodi on 28-05-2017.
 **/

fun main(args: Array<String>) {
    val sc = Scanner(System.`in`)
    var s = sc.nextLine()
    s = s.stringTask()
    println(s)
}

fun String.stringTask() = this.replace("[aeiouAEIOU]+".toRegex(), "").toLowerCase().replace("", ".").dropLast(1)

import java.util.Scanner

/**
 *Created by Kartik Patodi on 28-05-2017.
 **/

fun main(args: Array<String>) {
    val sc = Scanner(System.`in`)
    var s = sc.nextLine()
    s=s.stringTask()
    when(s){
        "." -> println("")
        else -> println(s)
    }
}

fun String.stringTask() = this.replace("[aeiou]".toRegex(),"").replace("",".")

import java.util.Scanner

/**
 *Created by Kartik Patodi on 28-05-2017.
 **/

fun main(args: Array<String>) {
    val sc = Scanner(System.`in`)
    var s = sc.nextLine()
    s=s.stringTask()
    when(s){
        "." -> println("")
        else -> println(s.substring(0 until s.length))
    }
}

fun String.stringTask() = this.replace("[aeiou]".toRegex(),"").replace("",".")

fun main(args: Array<String>) {
    val str = readLine()!!.toLowerCase().replace(Regex("[AaEeIiOoUu]"), "")
    println(str.replace(Regex("(?i)([bcdfghjklmnpqrstvwxyz])"), ".$1"))
}

import java.lang.StringBuilder

fun main(args: Array<String>) {

    val vowels: String = "AOYEUI"

    if (args.size < 1) {
        return
    }

    val input = args[0]

    val result: StringBuilder = StringBuilder()

    input.forEach {

        if (vowels.contains(it, ignoreCase = true) == false) {
            result.append("." + it.toLowerCase())
        }

    }

    println(result.toString())

}

import java.lang.StringBuilder

fun main(args: Array<String>) {

    val vowels: String = "AOYEUI"

    if (args.size < 1) {
        return
    }

    val input = args[0]

    val result: StringBuilder = StringBuilder()

    input.forEach {

        if (vowels.contains(it, ignoreCase = true) == false) {
            result.append("." + it.toLowerCase())
        }

    }

    print(result.toString())

}

import java.util.*

private val scan = Scanner(System.`in`)

fun main(args: Array<String>) {

    scan.next()
            .toLowerCase()
            .filter { it !in listOf('a', 'e', 'i', 'o', 'u') }
            .flatMap { listOf('.', it) }
            .joinToString(separator = "")
            .run { println(this) }
}

fun main() {
    val x = readLine()!!.toLowerCase()
    println(x.replace("[aoyeui]+".toRegex(), "").replace(".".toRegex()) { "." + it })
}

fun main() {
    val x = readLine()!!.toLowerCase()
    println(x.replace("[aoyeui]+".toRegex(), "."))
}

fun main(args: Array<String>) {
    val word = readLine()!!.toUpperCase()

    word.apply {
        replace("A", "")
        replace("O", "")
        replace("Y", "")
        replace("E", "")
        replace("U", "")
        replace("I", "")
    }
    var array = word.toCharArray()
    var result = ""
    for (ch in array) {
        result += ".$ch"
    }
    println(result)
}

/**
 * Created by rohit.jh on 21/01/18
 */
fun applyOperations(a:Char):String{
    val x = a.toLowerCase()
    return if (x == 'a' || x == 'e' || x == 'i' || x == 'o' || x == 'u') ""
    else ".$x"
}
fun main(args:Array<String>){
    val str:String = readLine()!!
    for ( i in 0 until str.length){
        print(applyOperations(str[i]))
    }
}

import java.io.PrintWriter
import java.util.StringTokenizer

fun main() = output {
    val string = read()
    val result = string
        .toLowerCase()
        .replace(Regex("[aeiou]"), "")
        .replace(Regex(".")) {
            ".${it.value}"
        }

    println(result)
}

@JvmField
val INPUT = System.`in`

@JvmField
val OUTPUT = System.out

@JvmField
val _reader = INPUT.bufferedReader()
fun readLine(): String? = _reader.readLine()
fun readLn() = _reader.readLine()!!

@JvmField
var _tokenizer: StringTokenizer = StringTokenizer("")
fun read(): String {
    while (_tokenizer.hasMoreTokens().not()) _tokenizer = StringTokenizer(_reader.readLine() ?: return "", " ")
    return _tokenizer.nextToken()
}

fun readInt() = read().toInt()
fun readDouble() = read().toDouble()
fun readLong() = read().toLong()
fun readStrings(n: Int) = List(n) { read() }
fun readLines(n: Int) = List(n) { readLn() }
fun readInts(n: Int) = List(n) { read().toInt() }
fun readIntArray(n: Int) = IntArray(n) { read().toInt() }
fun readDoubles(n: Int) = List(n) { read().toDouble() }
fun readDoubleArray(n: Int) = DoubleArray(n) { read().toDouble() }
fun readLongs(n: Int) = List(n) { read().toLong() }
fun readLongArray(n: Int) = LongArray(n) { read().toLong() }

@JvmField
val _writer = PrintWriter(OUTPUT, false)

fun output(block: PrintWriter.() -> Unit) {
    _writer.apply(block).flush()
}

fun main()
{
    var st = readLine()!!
    st = st.toLowerCase()
    println(st)
    var s : String = ""
    val arr = arrayOf('a','o','y','e','u','i')
    for(i in st)
    {
        if(i !in arr)
        {
            s = s.plus("."+i)
        }
    }
    println(s)
}

fun main() {
    val input = readLine()!!
    val vowels = Regex("[aeiou]")
    val intermed = vowels.replace(input.toLowerCase(), "")
    var answer = ""
    for(i in 0..intermed.length - 1){
        answer += "." + intermed[i]
    }
    print(answer)
}

/* template start */
// input
private fun readString() = readLine()!!
private fun readStrings() = readString().split(" ")
private fun readInt() = readString().toInt()
private fun readDigits() = readString().map { it - '0' }
private fun readInts() = readStrings().map { it.toInt() }
private fun readLongs() = readStrings().map { it.toLong() }

// output
private fun <T> T.print(map: (T) -> String = { it.toString() }) = println(map(this))
private fun <T> Iterable<T>.print(sep: String? = null, map: ((T) -> String)? = null) = asSequence().print(sep, map)
private fun <T> Array<T>.print(sep: String? = null, map: ((T) -> String)? = null) = asSequence().print(sep, map)
private fun <T> Sequence<T>.print(sep: String? = null, map: ((T) -> String)? = null) =
    println(joinToString(sep ?: "", transform = map ?: { it.toString() }))

// various
private val Int.isEven: Boolean get() = this % 2 == 0
private val Int.isOdd: Boolean get() = !this.isEven
private fun queries(block: (Int) -> Unit) = repeat(readInt(), block)

/* template end */

fun main() {
    val input = readString()
    buildString {
        for (c in input) {
            val c = c.toLowerCase()
            if (c !in setOf('a', 'e', 'i', 'o', 'u')) {
                append('.')
                append(c)
            }
        }
    }.print()
}


It's that time of the year when the Russians flood their countryside summer cottages (dachas) and the bus stop has a lot of people. People rarely go to the dacha on their own, it's usually a group, so the people stand in queue by groups.The bus stop queue has n groups of people. The i-th group from the beginning has ai people. Every 30 minutes an empty bus arrives at the bus stop, it can carry at most m people. Naturally, the people from the first group enter the bus first. Then go the people from the second group and so on. Note that the order of groups in the queue never changes. Moreover, if some group cannot fit all of its members into the current bus, it waits for the next bus together with other groups standing after it in the queue.Your task is to determine how many buses is needed to transport all n groups to the dacha countryside.

The first line contains two integers n and m (1 ≤ n, m ≤ 100). The next line contains n integers: a1, a2, ..., an (1 ≤ ai ≤ m).

Print a single integer — the number of buses that is needed to transport all n groups to the dacha countryside.

fun main(args: Array<String>) {
    val nm = readLine()!!.trim().split(" ").map {it.trim().toInt()}.toIntArray()
    val a = readLine()!!.trim().split(" ").map {it.trim().toInt()}.toIntArray()
    var result = 1
    var people=0
    for (i in 0 until nm[0]){
        if (people + a[i] <= nm[1]){
            people+=a[i]
        }
        else{
            result++
            people=a[i]
        }
    }
    println(result)

}

fun main() {
    var (n, m) = readLine()!!.split(" ").map { it.toInt() }
    var list = readLine()!!.split(" ").map { it.toInt() }

    var busSize = m
    var count = 1
    for (i in list) {
        if (i <= busSize) {
            busSize = busSize - i
        } else {
            count++
            busSize = m - i
        }
    }
    println(count)

}

fun main() {
    fun readInts() = readLine()!!.split(" ").map(String::toInt)

    val (_, busSize) = readInts()
    val groupsSizes = readInts()
    var currentSize = busSize
    var sol = 1
    for (groupSize in groupsSizes)
        if (groupSize <= currentSize)
            currentSize -= groupSize
        else {
            sol++
            currentSize = busSize - groupSize
        }
    print(sol)
}

fun main(args: Array<String>) {
    val groupBus = readLine()!!.trim().split(" ").map {it.trim().toInt()}.toIntArray()
    val groupnums = readLine()!!.trim().split(" ").map {it.trim().toInt()}.toIntArray()
    var countbuses = 0
    var carry=0
    var count =1
    for (i in 0 until groupBus[0]-1){
        carry=groupnums[i]
        for (j in i+1 until groupBus[0]){
            carry+=groupnums[j]
            if (carry>groupBus[1])break
            count++
        }
        countbuses++
        if (count == groupBus[0])break
    }
    println(countbuses)
}

fun main(args: Array<String>) {
    val groupBus = readLine()!!.trim().split(" ").map {it.trim().toInt()}.toIntArray()
    val groupnums = readLine()!!.trim().split(" ").map {it.trim().toInt()}.toIntArray()
    var countbuses = 0
    var carry=0
    if (groupnums.sum()==groupBus[1])countbuses=1
    else {
        for (i in 0 until groupBus[0] - 1) {
            carry = groupnums[i]
            for (j in i + 1 until groupBus[0]) {
                carry += groupnums[j]
                if (carry > groupBus[1]) break
            }
            countbuses++
        }
    }
    println(countbuses)
}

fun main(args: Array<String>) {
    val groupBus = readLine()!!.trim().split(" ").map {it.trim().toInt()}.toIntArray()
    val groupnums = readLine()!!.trim().split(" ").map {it.trim().toInt()}.toIntArray()
    var countbuses = 0
    var carry=0
    var count =0
    for (i in 0 until groupBus[0]-1){
        carry=groupnums[i]
        for (j in i+1 until groupBus[0]){
            carry+=groupnums[j]
            if (carry>groupBus[1])break
            count++
        }
        if (count == groupBus[0])break
        countbuses++
    }
    println(countbuses)
}

fun main(){
    var (n,m) = readLine()!!.split(" ").map { it.toInt() }
    var list = readLine()!!.split(" ").map { it.toInt() }.sum()

    if (list%m==0){
        println(list/m)
    }else{
        println(list/m+1)
    }

}


Alice got many presents these days. So she decided to pack them into boxes and send them to her friends.There are $$$n$$$ kinds of presents. Presents of one kind are identical (i.e. there is no way to distinguish two gifts of the same kind). Presents of different kinds are different (i.e. that is, two gifts of different kinds are distinguishable). The number of presents of each kind, that Alice has is very big, so we can consider Alice has an infinite number of gifts of each kind.Also, there are $$$m$$$ boxes. All of them are for different people, so they are pairwise distinct (consider that the names of $$$m$$$ friends are written on the boxes). For example, putting the first kind of present into the first box but not into the second box, is different from putting the first kind of present into the second box but not into the first box.Alice wants to pack presents with the following rules:  She won't pack more than one present of each kind into the same box, so each box should contain presents of different kinds (i.e. each box contains a subset of $$$n$$$ kinds, empty boxes are allowed);  For each kind at least one present should be packed into some box. Now Alice wants to know how many different ways to pack the presents exists. Please, help her and calculate this number. Since the answer can be huge, output it by modulo $$$10^9+7$$$.See examples and their notes for clarification.

The first line contains two integers $$$n$$$ and $$$m$$$, separated by spaces ($$$1 \leq n,m \leq 10^9$$$) — the number of kinds of presents and the number of boxes that Alice has.

Print one integer  — the number of ways to pack the presents with Alice's rules, calculated by modulo $$$10^9+7$$$

fun fastPow(a: Long, b: Long): Long {
    if (b==0L)
        return 1

    if (b==1L)
        return a

    if (b%2==0L)
        return fastPow((a*a)%1000000007, b/2)

    return a*fastPow(a, b-1)%1000000007
}

fun main() {
    val (n, m) = readLine()!!.split(" ").map { it.toLong() }

    var numCombinationsOfEachKind = fastPow(2, m)-1
    var res = fastPow(numCombinationsOfEachKind, n)

    println(res)
}

fun main(args: Array<String>) {
    val MOD = 1000000007L

    fun mod(x: Long) = (x % MOD + MOD) % MOD

    fun pow(x: Long, p: Long): Long {
        if (p == 0L) {
            return 1L
        }

        val halfPow = pow(x, p / 2)

        return if (p % 2L == 0L) mod(halfPow * halfPow) else mod(x * mod(halfPow * halfPow))
    }

    val (n, m) = readLine()!!.split(' ').map { it.toLong() }

    println(pow(mod(pow(2L, m) - 1L), n))
}

@file:Suppress("NOTHING_TO_INLINE")

import java.io.PrintWriter
import java.util.StringTokenizer
import java.util.TreeMap
import kotlin.math.*
import kotlin.random.*
import kotlin.collections.sort as _sort
import kotlin.collections.sortDescending as _sortDescending
import kotlin.io.println as iprintln // immediate println for interactive

fun main() {
    output {
        val n = readInt()
        val m = readInt()

        val ans = (ModInt(2).pow(m) - 1).pow(n)

        println(ans.int)
    }
}

const val BILLION7 = 1e9.toInt() + 7
const val MODINT_BASE = BILLION7
const val MODINT_TOTIENT = MODINT_BASE - 1 // assumes MODINT_BASE is prime

inline infix fun Int.umod(base: Int) = Math.floorMod(this, base)
inline infix fun Long.umod(base: Long) = Math.floorMod(this, base)
inline infix fun Long.umod(base: Int) = Math.floorMod(this, base.toLong()).toInt()

fun Int.mulMod(other: Int, mod: Int) = (toLong() * other).umod(mod)

fun Int.powMod(exponent: Int, mod: Int): Int {
    var res = 1L
    var e = exponent
    var b = umod(mod).toLong()

    while(e > 0) {
        if(e and 1 == 1) {
            res = res * b % mod
        }
        e = e shr 1
        b = b * b % mod
    }
    return res.toInt()
}

inline fun Int.toModInt() = ModInt(this umod MODINT_BASE)
inline fun Long.toModInt() = ModInt(this umod MODINT_BASE)

/** note: Only use constructor for int within modulo range, otherwise use toModInt **/
inline class ModInt(val int: Int) {
    companion object {
        /** can't seem to make these private or inlined without causing compiler issues */
        @JvmField val _invMemo = HashMap<ModInt, ModInt>()
        fun _invMemoized(m: ModInt) = _invMemo.getOrPut(m) { m.inv_unmemoized() }
    }

    inline operator fun plus(other: ModInt) = plus(other.int) // MODINT_BASE < 2^30
    inline operator fun plus(other: Int) =  (int + other).toModInt() // careful of possible overflow
    inline operator fun inc() = plus(1)

    inline operator fun minus(other: ModInt) = minus(other.int)
    inline operator fun minus(other: Int) = (int - other).toModInt()
    inline operator fun dec() = minus(1)
    operator fun unaryMinus() = if(int == 0) this else ModInt(MODINT_BASE - int)

    inline operator fun times(other: ModInt) = times(other.int)
    inline operator fun times(other: Int) = ModInt(int.mulMod(other, MODINT_BASE))

    fun pow(exponent: Int): ModInt {
        val e = if(exponent < 0) exponent umod MODINT_TOTIENT else exponent
        return ModInt(int.powMod(e, MODINT_BASE))
    }

    fun pow(exponent: Long) = pow(exponent umod MODINT_TOTIENT)

    inline fun inverse() = inv_memoized() /** NOTE: Change if necessary */

    fun inv_unmemoized(): ModInt {
        require(int != 0) { "Can't invert/divide by 0" }
        return pow(MODINT_TOTIENT - 1)
    }
    inline fun inv_memoized() = _invMemoized(this)

    operator fun div(other: ModInt) = times(other.inverse())
    inline operator fun div(other: Int) = div(other.toModInt())

    override fun toString() = int.toString()
}

inline class ModIntArray(val intArray: IntArray): Collection<ModInt> {
    inline operator fun get(i: Int) = ModInt(intArray[i])
    inline operator fun set(i: Int, v: ModInt) { intArray[i] = v.int }

    override val size: Int get() = intArray.size
    inline val lastIndex get() = intArray.lastIndex

    override fun contains(element: ModInt): Boolean = any { it == element }

    override fun containsAll(elements: Collection<ModInt>): Boolean = elements.all(::contains)

    override fun isEmpty(): Boolean = intArray.isEmpty()

    override fun iterator(): Iterator<ModInt> = object: Iterator<ModInt> {
        var index = 0
        override fun hasNext(): Boolean = index < size
        override fun next(): ModInt = get(index++)
    }
}
fun ModIntArray(capacity: Int) = ModIntArray(IntArray(capacity))
inline fun ModIntArray(capacity: Int, init: (Int) -> ModInt) =
    ModIntArray(IntArray(capacity) { init(it).int })

fun Iterable<ModInt>.sum() = fold(ModInt(0), ModInt::plus)
fun Sequence<ModInt>.sum() = fold(ModInt(0), ModInt::plus)
fun Iterable<ModInt>.product() = fold(ModInt(1), ModInt::times)
fun Sequence<ModInt>.product() = fold(ModInt(1), ModInt::times)

/** IO code start */
@JvmField val _reader = System.`in`.bufferedReader()
fun readLine(): String? = _reader.readLine()
fun readLn() = _reader.readLine()!!
@JvmField var _tokenizer: StringTokenizer = StringTokenizer("")
fun read(): String {
    while (_tokenizer.hasMoreTokens().not()) _tokenizer = StringTokenizer(_reader.readLine() ?: return "", " ")
    return _tokenizer.nextToken()
}
fun readInt() = read().toInt()
fun readDouble() = read().toDouble()
fun readLong() = read().toLong()
fun readStrings(n: Int) = List(n) { read() }
fun readInts(n: Int) = List(n) { read().toInt() }
fun readIntArray(n: Int) = IntArray(n) { read().toInt() }
fun readDoubles(n: Int) = List(n) { read().toDouble() }
fun readDoubleArray(n: Int) = DoubleArray(n) { read().toDouble() }
fun readLongs(n: Int) = List(n) { read().toLong() }
fun readLongArray(n: Int) = LongArray(n) { read().toLong() }

@JvmField val _writer = PrintWriter(System.out, false)
inline fun output(block: PrintWriter.()->Unit) { _writer.apply(block).flush() }

/** shuffles and sort overrides to avoid quicksort attacks */
private inline fun <R, V> R._shuffle(rnd: Random, get: R.(Int) -> V, set: R.(Int, V) -> Unit, size: Int) {
    // Fisher-Yates shuffle algorithm
    for (i in size - 1 downTo 1) {
        val j = rnd.nextInt(i + 1)
        val temp = get(i)
        set(i, get(j))
        set(j, temp)
    }
}

@JvmField var _random: Random? = null
val random get() = _random ?: Random(System.nanoTime()).also { _random = it }

fun IntArray.shuffle(rnd: Random = random) = _shuffle(rnd, IntArray::get, IntArray::set, size)
fun IntArray.sort() { shuffle(); _sort() }
fun IntArray.sortDescending() { shuffle(); _sortDescending() }

fun LongArray.shuffle(rnd: Random = random) = _shuffle(rnd, LongArray::get, LongArray::set, size)
fun LongArray.sort() { shuffle(); _sort() }
fun LongArray.sortDescending() { shuffle(); _sortDescending() }

fun DoubleArray.shuffle(rnd: Random = random) = _shuffle(rnd, DoubleArray::get, DoubleArray::set, size)
fun DoubleArray.sort() { shuffle(); _sort() }
fun DoubleArray.sortDescending() { shuffle(); _sortDescending() }

fun CharArray.shuffle(rnd: Random = random) = _shuffle(rnd, CharArray::get, CharArray::set, size)
inline fun CharArray.sort() { _sort() }
inline fun CharArray.sortDescending() { _sortDescending() }

inline fun <T: Comparable<T>> Array<out T>.sort() = _sort()
inline fun <T: Comparable<T>> Array<out T>.sortDescending() = _sortDescending()
inline fun <T: Comparable<T>> MutableList<out T>.sort() = _sort()
inline fun <T: Comparable<T>> MutableList<out T>.sortDescending() = _sortDescending()

import java.io.BufferedReader
import java.io.InputStream
import java.io.InputStreamReader
import java.io.PrintWriter
import java.lang.StringBuilder
import java.util.*

fun PrintWriter.solve(sc: FastScanner) {
    val n = sc.nextLong()
    val m = sc.nextLong()
    println((ModInt(2).pow(m)-ModInt(1)).pow(n))
}

fun main(args: Array<String>) {
    val writer = PrintWriter(System.out, false)
    writer.solve(FastScanner(System.`in`))
    writer.flush()
}

class FastScanner(s: InputStream) {
    private var st = StringTokenizer("")
    private val br = BufferedReader(InputStreamReader(s))

    fun next(): String {
        while (!st.hasMoreTokens()) st = StringTokenizer(br.readLine())

        return st.nextToken()
    }

    fun nextInt() = next().toInt()
    fun nextLong() = next().toLong()
    fun nextLine() = br.readLine()
    fun nextDouble() = next().toDouble()
    fun ready() = br.ready()
}

private class ModInt(x: Long) {

    companion object {
        const val MOD = 1e9.toLong() + 7
    }

    val x = (x % MOD + MOD) % MOD

    operator fun plus(other: ModInt): ModInt {
        return ModInt(x + other.x)
    }

    operator fun minus(other: ModInt): ModInt {
        return ModInt(x - other.x)
    }

    operator fun times(other: ModInt): ModInt {
        return ModInt(x * other.x)
    }

    operator fun div(other: ModInt): ModInt {
        return this * other.inv()
    }

    fun pow(exp: Long): ModInt {
        if (exp == 0L) return ModInt(1L)
        var a = pow(exp shr 1)
        a *= a
        if (exp and 1L == 0L) return a
        return this * a
    }

    fun inv(): ModInt {
        return this.pow(MOD - 2)
    }

    override fun equals(other: Any?): Boolean {
        if (this === other) return true
        if (javaClass != other?.javaClass) return false

        other as ModInt

        if (x != other.x) return false

        return true
    }

    override fun hashCode(): Int {
        return x.hashCode()
    }

    override fun toString(): String {
        return "$x"
    }
}

import java.math.BigInteger

fun main() {
    val (numKinds, numFriends) = readLine()!!.split(" ").map(String::toLong)
    print(
        BigInteger.valueOf(2L)
            .modPow(BigInteger.valueOf(numFriends), BigInteger.valueOf(1000000007L))
            .minus(BigInteger.ONE)
            .modPow(BigInteger.valueOf(numKinds), BigInteger.valueOf(1000000007L))
    )
}

fun main( args: Array<String> ) {
    val modulo = 1000000007L
    fun modexp( aa: Long, nn: Long ): Long {
        var a = aa
        var n = nn
        var r = 1L
        while ( n > 0 ) {
            if ( n and 1L > 0L ) r = ( r * a ) % modulo
            a = ( a * a ) % modulo
            n /= 2
        }
        return r
    }
    val ( a, b ) = readLine()!!.split( " " ).map { it.toLong() }
    println( modexp( ( modexp( 2L, b ) - 1L ), a ) )
}

import java.util.ArrayList
import java.util.Arrays
import java.util.Scanner

    internal var mod = (1e9 + 7).toLong()

    fun main(args: Array<String>) {
        val sc = Scanner(System.`in`)
        val n = sc.nextInt()
        val m = sc.nextInt()
        val sh = pow(2, m.toLong()) - 1
        print(pow(sh, n.toLong()))
    }

    private fun pow(a: Long, b: Long): Long {
        if (b == 0L) return 1L
        var p = pow(a, b / 2) % mod
        p = p * p % mod
        if (b and 1 != 0L) p = a * p % mod
        return p
    }

val MOD = 1000000007

fun pow(a: Long, n: Long): Long {
    if (n == 0L) return 1
    if (n % 2 == 1L) {
        val tmp = pow(a, n-1)
        return (tmp * a) % MOD
    } else {
        val c = pow(a, n / 2)
        return (c * c) % MOD
    }
}

fun main(args: Array<String>) {
    var (n, m) = readLine()!!.split(' ').map { it.toLong() }
    print(pow((pow(2, m) - 1), n))
}

import java.io.BufferedReader
import java.io.InputStream
import java.io.InputStreamReader
import java.util.*
import kotlin.math.abs
import kotlin.math.max
import kotlin.math.min

val MOD = 1_000_000_007

fun powMod(a: Int, n: Long, mod: Int): Long {
  if (n == 0L) return 1
  val res = powMod((a.toLong() * a % mod).toInt(), n / 2, mod)
  return if (n % 2 == 1L) res * a % mod else res
}
class Solver(stream: InputStream, private val out: java.io.PrintWriter) {
  fun solve() {
    val n = nl()
    val m = nl()
    val p = (MOD + powMod(2, m, MOD) - 1) % MOD
    out.println(powMod(p.toInt(), n, MOD))
  }

  private val isDebug = try {
    // なんか本番でエラーでる
    System.getenv("MY_DEBUG") != null
  } catch (t: Throwable) {
    false
  }

  private var tokenizer: StringTokenizer? = null
  private val reader = BufferedReader(InputStreamReader(stream), 32768)
  private fun next(): String {
    while (tokenizer == null || !tokenizer!!.hasMoreTokens()) {
      tokenizer = StringTokenizer(reader.readLine())
    }
    return tokenizer!!.nextToken()
  }

  private fun ni() = next().toInt()
  private fun nl() = next().toLong()
  private fun ns() = next()
  private fun na(n: Int, offset: Int = 0): IntArray {
    return map(n) { ni() + offset }
  }
  private fun nal(n: Int, offset: Int = 0): LongArray {
    val res = LongArray(n)
    for (i in 0 until n) {
      res[i] = nl() + offset
    }
    return res
  }

  private fun na2(n: Int, offset: Int = 0): Array<IntArray> {
    val a  = Array(2){IntArray(n)}
    for (i in 0 until n) {
      for (e in a) {
        e[i] = ni() + offset
      }
    }
    return a
  }

  private inline fun map(n: Int, f: (Int) -> Int): IntArray {
    val res = IntArray(n)
    for (i in 0 until n) {
      res[i] = f(i)
    }
    return res
  }

  private inline fun debug(msg: () -> String) {
    if (isDebug) System.err.println(msg())
  }

  private fun debug(a: LongArray) {
    debug { a.joinToString(" ") }
  }

  private fun debug(a: IntArray) {
    debug { a.joinToString(" ") }
  }

  private fun debug(a: BooleanArray) {
    debug { a.map { if (it) 1 else 0 }.joinToString("") }
  }

  private fun debugDim(A: Array<IntArray>) {
    if (isDebug) {
      for (a in A) {
        debug(a)
      }
    }
  }

  /**
   * 勝手にimport消されるのを防ぎたい
   */
  private fun hoge() {
    min(1, 2)
    max(1, 2)
    abs(-10)
  }
}

fun main() {
  val out = java.io.PrintWriter(System.out)
  Solver(System.`in`, out).solve()
  out.flush()
}