import java.io.PrintWriter
import java.util.*
import kotlin.math.pow

fun next() = readLine()!!
fun nextInt() = next().toInt()
fun nextLong() = next().toLong()
fun nextDouble() = next().toDouble()
fun nextList() = next().split(" ")
fun nextIntList() = nextList().map(String::toInt)
fun nextLongList() = nextList().map(String::toLong)
fun nextDoubleList() = nextList().map(String::toDouble)

val pw = PrintWriter(System.out)
fun print(s: Any = "") = pw.print(s)
fun println(s: Any = "") = pw.println(s)

fun <T> Iterable<T>.join(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "") = joinToString(separator, prefix, postfix)
fun <T> Array<T>.join(separator: CharSequence = ", ", prefix: CharSequence = "", postfix: CharSequence = "") = joinToString(separator, prefix, postfix)
fun Int.pow(n: Int) = pow(n.toLong())
fun Int.pow(n: Long) = toDouble().pow(n.toDouble()).toLong()
fun Long.pow(n: Int) = pow(n.toLong())
fun Long.pow(n: Long) = toDouble().pow(n.toDouble()).toLong()

fun main(args: Array<String>) {
    main()
    pw.flush()
}

fun main() {
    val (N, P) = nextIntList()
    val A = nextIntList()
    val E = A.count { it % 2 == 0 }.toLong()
    val O = N - E
    val combi = Combination(50)
    if (P == 0) {
        val ans = 2.pow(E) * (0..O step 2).map { combi(O, it) }.sum()
        println(ans)
    } else {
        val ans = 2.pow(E) * (1..O step 2).map { combi(O, it) }.sum()
        println(ans)
    }
}

class Combination(n: Int) {
    private val fact = Array<HInt?>(n + 1) { null }

    init {
        fact[0] = HInt(1)
        (1..n).forEach { i -> fact[i] = fact[i - 1]!! * i }
    }

    operator fun invoke(n: Long, k: Long) = invoke(n.toInt(), k.toInt())
    operator fun invoke(n: Int, k: Int): Long {
        if (k < 0 || n < k) return 0L
        return (fact[n]!! / (fact[k]!! * fact[n - k]!!)).toLong()
    }
}

class HInt {
    private val map = HashMap<Long, Int>()

    constructor(n: Int) : this(n.toLong())
    constructor(n: Long) : this(primefact(n))
    private constructor(_map: Map<Long, Int>) {
        map.putAll(_map)
    }

    operator fun times(n: Int) = times(n.toLong())
    operator fun times(n: Long) = times(primefact(n))
    operator fun times(n: HInt) = times(n.map)

    private fun times(_map: Map<Long, Int>): HInt {
        val res = HInt(map)
        _map.forEach { (k, v) ->
            val ex = res.map[k] ?: 0
            res.map[k] = ex + v
        }
        return res
    }

    operator fun div(n: Int) = div(n.toLong())
    operator fun div(n: Long) = div(primefact(n))
    operator fun div(n: HInt) = div(n.map)

    private fun div(_map: Map<Long, Int>): HInt {
        val res = HInt(map)
        _map.forEach { (k, v) ->
            val ex = res.map[k] ?: 0
            res.map[k] = ex - v
        }
        return res
    }

    fun toLong() = map.entries.map { (k, v) -> k.pow(v) }.fold(1L) { a, b -> a * b }

    override fun toString(): String {
        return map.toString()
    }
}

fun primefact(n: Long): HashMap<Long, Int> {
    val map = HashMap<Long, Int>()
    var tmp = n
    for (i in 2L..(Math.sqrt(n.toDouble()).toLong() + 1)) {
        if (tmp % i == 0L) {
            var cnt = 0
            while (tmp % i == 0L) {
                tmp /= i
                cnt++
            }
            map[i] = cnt
        }
        if (tmp == 1L) break
    }
    if (tmp != 1L) {
        map[tmp] = 1
    }
    return map
}