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)
        }
    }

}

/**
 * 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 })
}

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>) {
    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)
}

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 = "."))

}

/**
 * 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.*

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)
}

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)
}

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)
}

// 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)
}

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.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.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()

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("")
}

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.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)
}

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 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)
}

//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.*

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))
}

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()
{
    val given = readLine()!!
    var answer = ""
    for (i in given)
    {
        if (! "AEIOUYaeiouy".contains(i))
        {
            answer += "."+i.toLowerCase()
        }
    }
    println(answer)
}

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 }
    )
}

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.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)

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")
        }
    }

}

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 = ""))
}

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())
}

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") }

//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(""))
}

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)
}

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)
}

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())
}

// 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()
}


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 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(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)
    }

}


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 ) )
}

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()
}

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))
    )
}

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
    }