using System;
using System.Linq;
using System.Collections.Generic;

namespace AtCoder.Grand017
{
    public class AGC017A_Biscuits
    {
        public static void Main(string[] args)
        {
            
            // 総数と余りの数の入力
            int[] nums = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();
            int n = nums[0];
            int p = nums[1];

            // 袋毎のビスケット数の入力
            int[] biscuitNum = Console.ReadLine().Split(' ').Select(int.Parse).ToArray();

            int evenNum = biscuitNum.Count(num => num % 2 == 0);
            int oddNum = biscuitNum.Count(num => num % 2 == 1);

            if(p == 0)
            {
                // 偶数枚食べる
                // 偶数袋から任意の数と、奇数袋から偶数

                decimal evenCombi = 0;
                for(int i=0; i <= evenNum; i++)
                {
                    evenCombi += MathMod.Combination(evenNum, i);
                }

                decimal oddCombi = 0;
                for(int i = 0; i <= oddNum; i+= 2)
                {
                    oddCombi += MathMod.Combination(oddNum, i);
                }

                // 結果出力
                Console.WriteLine(evenCombi * oddCombi);

            }
            else
            {
                // 奇数枚食べる
                // 偶数袋から任意の数と、奇数袋から奇数

                decimal evenCombi = 0;
                for(int i = 0; i <= evenNum; i++)
                {
                    evenCombi += MathMod.Combination(evenNum, i);
                }

                decimal oddCombi = 0;
                for(int i = 1; i <= oddNum; i += 2)
                {
                    oddCombi += MathMod.Combination(oddNum, i);
                }

                // 結果出力
                Console.WriteLine(evenCombi * oddCombi);

            }
            

        }


        public class MathMod
        {

            // 階乗計算に使う素数(階乗計算の上限数)
            static decimal modVal = 261241490581607m;

            // 階乗計算を行う数
            private static int FactorialMax = 60;


            // 階乗の剰余
            private static decimal[] factorialMod = new decimal[FactorialMax + 1];

            // 階乗の逆元
            private static decimal[] factorialInverse = new decimal[FactorialMax + 1];


            static MathMod()
            {

                // 階乗の剰余・逆元を計算
                factorialMod[0] = 1;
                factorialInverse[0] = 1;
                for(long i = 1; i <= FactorialMax; i++)
                {
                    factorialMod[i] = (factorialMod[i - 1] * i) % modVal;
                    factorialInverse[i] = Pow(factorialMod[i], modVal - 2);
                }

            }

            /// <summary>累乗を求める</summary>
            public static decimal Pow(decimal x, decimal y)
            {
                decimal remaining = y;
                decimal p = x;

                decimal ret = 1;

                while(remaining > 0)
                {
                    if(remaining % 2 == 0)
                    {
                        p = (p * p) % modVal;
                        remaining /= 2;
                    }
                    else
                    {
                        ret = (ret * p) % modVal;
                        remaining -= 1;
                    }
                }

                return ret;
            }


            /// <summary>階乗を求める</summary>
            public static decimal Factorial(int n)
            {
                if(n < 0 || n > FactorialMax)
                {
                    throw new ArgumentOutOfRangeException();
                }

                return factorialMod[n];
            }


            /// <summary>組み合わせ数を求める</summary>
            /// <param name="n">全体集合の要素数</param>
            /// <param name="r">取り出す要素数</param>
            /// <returns>組み合わせ数</returns>
            public static decimal Combination(int n, int r)
            {
                if(n > FactorialMax || r > FactorialMax)
                {
                    throw new ArgumentOutOfRangeException();
                }

                if(n < r || n < 0 || r < 0)
                {
                    return 0;
                }

                return (factorialMod[n] * factorialInverse[r] % modVal * factorialInverse[n - r] % modVal);
            }

        }

    }
}

Measured memory_bytes: 13524