package main

import (
	"bufio"
	"fmt"
	"os"
)

var s []int

func isValid(n, k int) bool {
	if n%2 == 0 {
		return false
	}
	if n == 1 || n == 3 {
		return k == 0
	}
	maxK := (n - 3) / 2
	if k < 0 || k > maxK {
		return false
	}
	isPerf := (n & (n + 1)) == 0
	if isPerf && k == 1 {
		return false
	}
	if !isPerf && k == 0 {
		return false
	}
	return true
}

func build(n, k, offset int) int {
	root := offset + n
	if n == 1 {
		return root
	}

	for a := 1; a <= n-2; a += 2 {
		b := n - 1 - a
		imb := 0
		if a >= 2*b || b >= 2*a {
			imb = 1
		}

		rem := k - imb
		if rem < 0 {
			continue
		}

		minA := 1
		if a == 1 || a == 3 || (a&(a+1)) == 0 {
			minA = 0
		}
		maxA := 0
		if a > 3 {
			maxA = (a - 3) / 2
		}

		minB := 1
		if b == 1 || b == 3 || (b&(b+1)) == 0 {
			minB = 0
		}
		maxB := 0
		if b > 3 {
			maxB = (b - 3) / 2
		}

		startKA := minA
		if rem-maxB > startKA {
			startKA = rem - maxB
		}
		endKA := maxA
		if rem-minB < endKA {
			endKA = rem - minB
		}

		found := false
		for kA := startKA; kA <= endKA; kA++ {
			kB := rem - kA
			if isValid(a, kA) && isValid(b, kB) {
				rootA := build(a, kA, offset)
				rootB := build(b, kB, offset+a)
				s[rootA] = root
				s[rootB] = root
				found = true
				break
			}
		}
		if found {
			return root
		}
	}
	return root
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var n, k int
	if _, err := fmt.Fscan(in, &n, &k); err != nil {
		return
	}

	if !isValid(n, k) {
		fmt.Fprintln(out, "NO")
		return
	}

	s = make([]int, n+1)
	build(n, k, 0)

	fmt.Fprintln(out, "YES")
	for i := 1; i <= n; i++ {
		if i > 1 {
			fmt.Fprint(out, " ")
		}
		fmt.Fprint(out, s[i])
	}
	fmt.Fprintln(out)
}