import java.security.MessageDigest
import java.util.Arrays
import java.util.Base64

object Crypt {
    private val Hasher = MessageDigest.getInstance("SHA-256")

    private fun buildMessage(seenZero: Boolean): String {
        val element = if (!seenZero) "0" else "1"
        val builder = StringBuilder()
        repeat(256) {
            builder.append(element)
        }
        return builder.toString()
    }

    private fun getPrivateKeys(arr: ByteArray): Array<ByteArray> {
        val privateKeys = Array(256) { ByteArray(32) }
        for (j in 0..255) {
            for (k in 0..31) {
                privateKeys[j][k] = arr[j * 32 + k]
            }
        }
        return privateKeys
    }

    private fun getPublicKeys(arr: ByteArray): Array<ByteArray> {
        val publicKeys = Array(512) { ByteArray(32) }
        for (j in 0..511) {
            for (k in 0..31) {
                publicKeys[j][k] = arr[j * 32 + k]
            }
        }
        return publicKeys
    }

    @JvmStatic
    fun main(args: Array<String>) {
        val secretKeys = Array(256) { Array(512) { ByteArray(32) } }
        val keysAcquired = BooleanArray(256)
        val rootHash = Base64.getDecoder().decode(readLine())
        while (true) {
            val key = Integer.valueOf(readLine())
            val zeroSeen = keysAcquired[key]
            val message = buildMessage(zeroSeen)
            println(message)
            val privateKeys = getPrivateKeys(Base64.getDecoder().decode(readLine()))
            val allPublicKeys = Base64.getDecoder().decode(readLine())
            val publicKeys = getPublicKeys(allPublicKeys)

            var curHash = Hasher.digest(byteArrayOf(0) + allPublicKeys)
            var curVertexNum = key
            for (j in 0 until 8) {
                val hash = Base64.getDecoder().decode(readLine())
                curHash = if (curVertexNum % 2 == 0) {
                    Hasher.digest(byteArrayOf(1) + curHash + byteArrayOf(2) + hash)
                } else {
                    Hasher.digest(byteArrayOf(1) + hash + byteArrayOf(2) + curHash)
                }
                curVertexNum = curVertexNum shr 1
            }
            val q = readLine()!!
            if (!Arrays.equals(curHash, rootHash)) {
                println("NO\nNO")
                continue
            }
            var correct = true
            for (j in 0..255) {
                val additional = if (!zeroSeen) 0 else 256
                val privateHash = Hasher.digest(privateKeys[j])
                val curPublicKey = publicKeys[j + additional]
                if (!Arrays.equals(curPublicKey, privateHash)) {
                    correct = false
                    break
                }
            }
            if (correct) {
                println("YES")
            } else {
                println("NO\nNO")
                continue
            }
            if (!zeroSeen) {
                keysAcquired[key] = true
            }
            val additional = if (!zeroSeen) 0 else 1
            for (j in 0..255) {
                secretKeys[key][2 * j + additional] = privateKeys[j]
            }
            if (!zeroSeen && q != message) {
                println("NO")
                continue
            }
            println("YES")
            val ans = ByteArray(256 * 32)
            for (j in 0..255) {
                val addition = if (q[j] == '1') 1 else 0
                for (k in 0..31) {
                    ans[j * 32 + k] = secretKeys[key][2 * j + addition][k]
                }
            }
            println(Base64.getEncoder().encodeToString(ans))
            return
        }
    }
}