Problem:
Problem F: UTF-8

UTF-8はマルチバイト文字を符号化する手法の一つである。

文字は計算機上ではバイト列として扱われる。英語だけであればラテンアルファベットおよび数字、記号を合わせても 1byteで表現できるが、残念ながら世界中で利用されている文字を1byteで表現することはできないため、複数のバイトを用いて文字を表す必要がある。

ここで例えば"あ"という文字に12354(0x3042)という2バイト列を割り当てたとき、そのままバイト列を並べると0x30,0x42と2文字なのか0x3042で1文字なのかが区別がつかない。

このため、マルチバイト文字符号化方式のUTF-8では始めの1バイト目で続くバイト列の長さが分かるようにすることにより、この問題を克服している。具体的なビットパターンは以下のようになる。

バイト長

ビットパターン

1

0xxxxxxx

2

110yyyyx 10xxxxxx

3

1110yyyy 10yxxxxx 10xxxxxx

4

11110yyy 10yyxxxx 10xxxxxx 10xxxxxx

ここでxは0/1の任意のビットとする。またyも0/1の任意のビットとなるがどれか一つは1である必要がある。また全ての文字は1,2,3,4バイト文字のいずれかであるとする。

ここでyのビットが少なくとも一つは1であるという制約は以下のような理由による。 例えば'/'(0x2f)をバイト列にエンコードする際に0x2fと1バイトで符号化するないしは0xc0 0xafと2バイトで符号化する方法の二つがあるが、このような曖昧性を許すとセキュリティ上の脅威のもととなる可能性があるためである。

以上の話を聞いたあなたはUTF-8がどの程度の自由度があるのかが気になった。具体的には与えられたバイト列の一部のビットが不明な時にUTF-8として可能なバイト列の組み合わせがどの程度あるかということである。

このとき可能なバイト列の組み合わせの個数を求め、1,000,000で割った余りを出力せよ。

Input

N
b1
b2
...
bN

Nはバイト列の個数, biはバイト列である。
1 ≤ N ≤ 1000 を満たしている。 biは記号{0/1/x}が8個並んでいる。xはビットが不明であることを示している。

Output

可能なバイト列の組み合わせの個数を1,000,000で割った余りを出力せよ。

Notes on Test Cases

上記入力形式で複数のデータセットが与えられます。各データセットに対して上記出力形式で出力を行うプログラムを作成して下さい。

N が 0 のとき入力の終わりを示します。

Sample Input

1
xxxxxxxx
3
11100000
10x00000
10111111
3
11100000
10000000
10111111
4
xxxxxxxx
xxxxxxxx
xxxxxxxx
xxxxxxxx
0

Output for Sample Input

128
1
0
778240

Solution in Kotlin (judge verdict: Accepted)


fun main(args:Array<String>):Unit {
    while (true){
        val n = readLine()!!.trim().toInt()
        if (n == 0) return
        println(calPattern(Array(n){readLine()!!.trim()}))
    }
}
fun calPattern(bytes:Array<String>, index:Int = 0, memo:Array<Long> = Array(bytes.size){-1L}):Long {
    if (index == bytes.size) return 1
    if (memo[index] >= 0) return memo[index]
    memo[index] = oneByteUnicodePattern(bytes[index]) * calPattern(bytes, index + 1, memo)
    if (bytes.size - index >= 2)
        memo[index] += twoByteUnicodePattern(bytes[index], bytes[index + 1]) * calPattern(bytes, index + 2, memo)
    if (bytes.size - index >= 3)
        memo[index] += threeByteUnicodePattern(bytes[index], bytes[index + 1], bytes[index + 2]) * calPattern(bytes, index + 3, memo)
    if (bytes.size - index >= 4)
        memo[index] += fourByteUnicodePattern(bytes[index], bytes[index + 1], bytes[index + 2], bytes[index + 3]) * calPattern(bytes, index + 4, memo)
    memo[index] = memo[index] % 1000000
    return memo[index]
}

fun oneByteUnicodePattern(byte:String):Long {
    val pattern = """^[0x]([01x]{7})""".toRegex()
    val matched = pattern.matchEntire(byte)
    return when(matched){
        null -> 0L
        else -> matched.groupValues[1].countXPattern()
    }
}
fun twoByteUnicodePattern(byte1:String, byte2:String):Long {
    val pattern1 = """^[1x]{2}[0x]([01x]{4})([01x])""".toRegex()
    val pattern2 = """^[1x][0x]([01x]{6})""".toRegex()
    val matched1 = pattern1.matchEntire(byte1)
    val matched2 = pattern2.matchEntire(byte2)
    return when{
        matched1 == null || matched2 == null -> 0L
        else -> {
            val x = matched1.groupValues[2] + matched2.groupValues[1]
            val y = matched1.groupValues[1]
            x.countXPattern() * y.countYPattern()
        }
    }
}
fun threeByteUnicodePattern(byte1:String, byte2:String, byte3:String):Long {
    val pattern1 = """^[1x]{3}[0x]([01x]{4})""".toRegex()
    val pattern2 = """^[1x][0x]([01x])([01x]{5})""".toRegex()
    val pattern3 = """^[1x][0x]([01x]{6})""".toRegex()
    val matched1 = pattern1.matchEntire(byte1)
    val matched2 = pattern2.matchEntire(byte2)
    val matched3 = pattern3.matchEntire(byte3)
    return when {
        matched1 == null || matched2 == null || matched3 == null -> 0L
        else -> {
            val x = matched2.groupValues[2] + matched3.groupValues[1]
            val y = matched1.groupValues[1] + matched2.groupValues[1]
            x.countXPattern() * y.countYPattern()
        }
    }
}
fun fourByteUnicodePattern(byte1:String, byte2:String, byte3:String, byte4:String):Long {
    val pattern1 = """^[1x]{4}[0x]([01x]{3})""".toRegex()
    val pattern2 = """^[1x][0x]([01x]{2})([01x]{4})""".toRegex()
    val pattern34 = """^[1x][0x]([01x]{6})""".toRegex()
    val matched1 = pattern1.matchEntire(byte1)
    val matched2 = pattern2.matchEntire(byte2)
    val matched3 = pattern34.matchEntire(byte3)
    val matched4 = pattern34.matchEntire(byte4)
    return when{
        matched1 == null || matched2 == null || matched3 == null || matched4 == null -> 0L
        else -> {
            val x = matched2.groupValues[2] + matched3.groupValues[1] + matched4.groupValues[1]
            val y = matched1.groupValues[1] + matched2.groupValues[1]
            x.countXPattern() * y.countYPattern()
        }
    }

}
fun String.countXPattern():Long {
    return 1L shl this.count{it == 'x'}
}
fun String.countYPattern():Long {
    return when{
        this.contains('1') -> 1L shl this.count{it == 'x'}
        else -> (1L shl this.count{it == 'x'}) - 1
    }
}