package main

import (
	"bufio"
	"fmt"
	"math/bits"
	"os"
)

var left, right []int

func newNode() int {
	left = append(left, 0)
	right = append(right, 0)
	return len(left) - 1
}

func isPow2(x int) bool {
	return x > 0 && (x&(x-1)) == 0
}

func feasible(L, k int) bool {
	if L < 1 || k < 0 {
		return false
	}
	if L == 1 {
		return k == 0
	}
	if k > L-2 {
		return false
	}
	if isPow2(L) {
		return k == 0 || k >= 2
	}
	if L == 5 {
		return k == 1 || k == 3
	}
	return k >= 1
}

func buildPerfect(L int) int {
	if L == 1 {
		return newNode()
	}
	r := newNode()
	left[r] = buildPerfect(L / 2)
	right[r] = buildPerfect(L / 2)
	return r
}

func buildExactOne(L int) int {
	if L < 3 || isPow2(L) {
		return 0
	}
	p := 1 << (bits.Len(uint(L)) - 1)
	if p == L {
		return 0
	}
	rem := L - p
	r := newNode()
	if rem == p/2 {
		left[r] = buildPerfect(p / 2)
		right[r] = buildPerfect(p)
	} else if rem < p/2 {
		left[r] = buildPerfect(p / 2)
		right[r] = buildExactOne(L - p/2)
	} else {
		left[r] = buildPerfect(p)
		right[r] = buildExactOne(rem)
	}
	if left[r] == 0 || right[r] == 0 {
		return 0
	}
	return r
}

func build(L, k int) int {
	if k == 0 {
		return buildPerfect(L)
	}
	if k == 1 {
		return buildExactOne(L)
	}
	root, prev := 0, 0
	for k > 1 {
		cur := newNode()
		if root == 0 {
			root = cur
		} else {
			right[prev] = cur
		}
		if feasible(L-1, k-1) {
			left[cur] = newNode()
			L--
		} else if L >= 6 && feasible(L-2, k-1) {
			left[cur] = buildPerfect(2)
			L -= 2
		} else {
			return 0
		}
		k--
		prev = cur
	}
	sub := buildExactOne(L)
	if sub == 0 {
		return 0
	}
	if root == 0 {
		return sub
	}
	right[prev] = sub
	return root
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	var n, k int
	fmt.Fscan(in, &n, &k)

	if n%2 == 0 {
		fmt.Fprintln(out, "NO")
		return
	}

	L := (n + 1) / 2
	if !feasible(L, k) {
		fmt.Fprintln(out, "NO")
		return
	}

	left = make([]int, 1, n+1)
	right = make([]int, 1, n+1)

	root := build(L, k)
	if root == 0 || len(left)-1 != n {
		fmt.Fprintln(out, "NO")
		return
	}

	s := make([]int, n+1)
	stack := []int{root}
	for len(stack) > 0 {
		v := stack[len(stack)-1]
		stack = stack[:len(stack)-1]
		if left[v] != 0 {
			s[left[v]] = v
			stack = append(stack, left[v])
		}
		if right[v] != 0 {
			s[right[v]] = v
			stack = append(stack, right[v])
		}
	}

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