long dfs(int len, int sum, boolean limit) {
        if (len == 0) return sum == K ? 1 : 0;
        if (dp[len][sum] != -1 && !limit) return dp[len][sum];
        int up = limit ? num[len] : 1;
        long res = 0;
        for (long i = 0; i <= up; i++) 
            res += dfs(len - 1, sum + (i == 1 ? 1 : 0), limit && i == up);
        dp[len][sum] = res;
        return res;
    }

import java.io.*;
import java.util.*;
/**
 * @Auther: LiangXinRui
 * @Date: 2023/3/24 11:33
 * @Description: 数位DP
 */
public class Main {
    static long n, K;
    static long[][] dp = new long[66][66];//长度为len且1的个数为sum时的值（备忘录）
    static int[] num = new int[66];//用数组来存储n的二进制
    static StreamTokenizer in = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
    public static void main(String[] args) throws IOException {
        n = nextLong();
        K = nextLong();
        out.println(solve(n));
        out.flush();
    }
    /**
     * @param len   :当前是第几位
     * @param sum   :表示多少个1
     * @param limit :表示是否达到上限
     * @deprecated :这样写 : ~a != 0 就是说 a != -1
     */
    static long dfs(int len, int sum, boolean limit) {
        if (len == 0) return sum == K ? 1 : 0;//递归出口
        //当limit == false的时候，后续所有状态均为false，此时与num数组无关，答案是相同的，采用记忆化搜索
        //记忆化搜索DFS：只要这个状态的limit为false，并且曾经访问过，直接返回DP数组记录的答案。(没有达到上限时，我们搜到相同地方的答案都是一样的)
        if (dp[len][sum] != -1 && !limit) return dp[len][sum];//如果没有达到上限并且该处有记录就直接return掉
        //计算当前位的上限
        int up = limit ? num[len] : 1;//达到上限了吗？达到了就只能原样输出：否则就可以取二进制的最大值1.（这道题是二进制）
        long res = 0;
        for (long i = 0; i <= up; i++) {//对当前位能取到的情况进行暴力枚举，统计答案
            //第三个表达式：limit && i == up 的意思是：(注意短路与&&)
            //1.如果limit没有达到上限(false)，那整个表达式永远不会达到上限，return false，下一次可以随便取
            //2.如果limit已经达到上限，那我还要判断一下当前位是否已经到了当前位的上限，
            //      2.1如果i == up，那总体就算达到上限，返回true，带着这个状态继续往下走。
            //      2.2如果i != up，就表明当前位上是没有达到上限的，所以总体来说也是没有达到上限的，可以带着false的状态继续深搜。
            res += dfs(len - 1, sum + (i == 1 ? 1 : 0), limit && i == up);
        }
        dp[len][sum] = res;//如果上一次达到上限，并且当前情况(len,sum)没有出现过记录，那么我们就在这里给它做记录
        return res;
    }
    static long solve(long n) {
        for (long[] longs : dp) Arrays.fill(longs, -1);//初始化dp
        int len = 0;
        while (n != 0) {//将数字的二进制存储在num里面（默认二进制右边是第一位）
            num[++len] = (int) (n & 1);
            n >>= 1;
        }
        return dfs(len, 0, true);
    }
    static long nextLong() throws IOException {
        in.nextToken();
        return (long) in.nval;
    }
}