import java.io.IOException
import java.lang.NumberFormatException
import java.lang.StringBuilder
import kotlin.math.max
import kotlin.math.pow

object AMain{
    fun solve(){
        val n = nextInt()
//        val a = ArrayList<Long>()
//        val num = Array(10) { arrayOfNulls<Int>(10) }
        val num = ArrayList<ArrayList<Int>>()
        var num44 = 0
        for(i in 1..21){
            val mnum = ArrayList<Int>()
            for(j in 1..21){
                mnum.add(0)
            }
            num.add(mnum)
        }

        var ans = 0L

        val pow10 = listOf(1L, 10L, 100L, 1000L, 10000L, 100000L, 1000000L, 10000000L, 100000000L, 1000000000L)

        for(i in 1..n){
            var sa = next().split('.') as MutableList
            if(sa.size == 1){
                sa = listOf(sa[0], "0") as MutableList<String>
            }

            while(sa[1].length > 1 && sa[1].get(sa[1].length-1) == '0') sa[1] = sa[1].substring(0, sa[1].length-1)

//            if(sa[1].length > 4) continue

            var ma = sa[0].toLong() * 1000000000L + sa[1].toInt() * pow10[9-sa[1].length]
//            var ma = sa[0].toLong() * 10000 + sa[1].toInt() * 10.toDouble().pow((4 - sa[1].length).toDouble()).toLong()
//            a.add(ma.toLong())

            var num2 = count(ma, 2)
            var num5 = count(ma, 5)


            for(mi in max(0, (18-num2))..20){
                for(mj in max(0, (18 - num5))..20){
                    ans += num[mi][mj]
                }
            }

            num[num2][num5]++

        }
        num.forEach{
//            println(it)
        }

        println(ans)
    }

    fun count(x: Long, n: Int): Int{
        var ret = 0
        var mx = x
        while(mx % n.toLong() == 0L){
            mx /= n.toLong()
            ret++
        }
        return if(ret > 20) 20 else ret
    }





    // Scanner based on uwi-san's Java code
    val stream = System.`in`
    val buffer = ByteArray(1024)
    var ptr = 0
    var buflen = 0

    fun hasNextByte(): Boolean{
        if(ptr < buflen){
            return true
        }else{
            ptr = 0
            try{
                buflen = stream.read(buffer)
            }catch (e: IOException){
                e.printStackTrace()
            }
            if(buflen <= 0){
                return false
            }
        }
        return true
    }

    fun readByte() =
        if(hasNextByte()) buffer[ptr++]
        else -1

    fun isPrintableChar(c: Byte) = c in 33..126

    fun hasNext(): Boolean{
        while(hasNextByte() && !isPrintableChar(buffer[ptr])) ptr++
        return hasNextByte()
    }

    fun next(): String{
        if(!hasNext()) throw NoSuchElementException()
        val sb = StringBuilder()
        var b = readByte()
        while(isPrintableChar(b)){
            sb.appendCodePoint(b.toInt())
            b = readByte()
        }
        return sb.toString()
    }

    fun nextLong(): Long{
        if(!hasNext()) throw NoSuchElementException()
        var n = 0L
        var minus = false
        var b = readByte()
        if(b == '-'.toByte()){
            minus = true
            b = readByte()
        }
        if(b !in '0'.toByte()..'9'.toByte())
            throw NumberFormatException()
        while(true){
            if(b in '0'.toByte()..'9'.toByte()){
                n *= 10
                n += b - '0'.toByte()
            }else if(!isPrintableChar(b)){
                return if(minus) -n else n
            }else{
                throw NumberFormatException()
            }
            b = readByte()
        }
    }

    fun nextInt(): Int{
        val n1 = nextLong()
        if(n1 !in Int.MIN_VALUE..Int.MAX_VALUE)
            throw NumberFormatException()
        return n1.toInt()
    }

    fun NextDouble() = next().toDouble()
}

fun main(){
    AMain.solve()
}



Measured memory_bytes: 67240