/**
 * code generated by JHelper
 * More info: https://github.com/AlexeyDmitriev/JHelper
 * @author Ido Kessler
 */

#pragma GCC optimize("O3")

#include <iostream>

#include <vector>
#include <queue>
#include <algorithm>
#include <numeric>
#include <functional>



namespace io {
	class input_reader {
		std::istream &in;

		template<typename T>
		inline void readIntegerValue(T &f) {
			bool positive = true;
			f = 0;
			char c;
			if (!in.get(c)) throw std::runtime_error("No more inputs while reading number");
			while (c < '0' || c > '9') {
				if (c == '-') positive = false;
				if (!in.get(c)) throw std::runtime_error("No more inputs while reading number");
			}
			while (c >= '0' && c <= '9') {
				f = (f << 3) + (f << 1) + (c & 15);
				if (!in.get(c)) break;
			}
			if (!positive) f *= -1;
		}

	public:
		input_reader(std::istream &in) : in(in) {}

		inline void read(int &f) { readIntegerValue(f); }

		inline void read(short &f) { readIntegerValue(f); }

		inline void read(long int &f) { readIntegerValue(f); }

		inline void read(long long int &f) { readIntegerValue(f); }

		inline void read(unsigned int &f) { readIntegerValue(f); }

		inline void read(unsigned short &f) { readIntegerValue(f); }

		inline void read(unsigned long int &f) { readIntegerValue(f); }

		inline void read(unsigned long long int &f) { readIntegerValue(f); }

		template<typename T>
		inline void read(std::vector<T> &f) { for (auto &i : f) read(i); }

		template<typename T, int N>
		inline void read(std::array<T, N> &res) { for (auto &i: res) read(i); }

		template<typename T>
		inline void read(T &f) { in >> f; }

		template<typename T1, typename T2>
		inline void read(T1 &t1, T2 &t2) { read(t1), read(t2); }

		template<typename T1, typename T2, typename T3>
		inline void read(T1 &t1, T2 &t2, T3 &t3) { read(t1, t2), read(t3); }

		template<typename T1, typename T2, typename T3, typename T4>
		inline void read(T1 &t1, T2 &t2, T3 &t3, T4 &t4) { read(t1, t2, t3), read(t4); }

		template<typename T1, typename T2, typename T3, typename T4, typename T5>
		inline void read(T1 &t1, T2 &t2, T3 &t3, T4 &t4, T5 &t5) { read(t1, t2, t3, t4), read(t5); }

		template<typename T>
		inline void readArray(int n, T *res) { while (n--) read(*(res++)); }

		template<typename T>
		input_reader &operator>>(T &t) { return read(t), *this; }
	};
}




namespace io {
	class output_writer {
		std::ostream &out;

		template<typename T>
		inline void printIntegerHelper(T x) {
			if (x >= 10) printIntegerHelper(x / 10);
			out.put(x % 10 + 48);
		}

		template<typename T>
		inline void printInteger(T x) {
			if (x < 0) out.put('-'), x = -x;
			printIntegerHelper(x);
		}

		template<typename T>
		inline void printArray(T &ar) {
			bool first = true;
			for (auto &t : ar) print((first) ? first = false, "" : " ", t);
		}

	public:
		output_writer(std::ostream &out) : out(out) {}

		inline void flush() { out.flush(); }

		inline void print() {}

		inline void print(char x) { out.put(x); }

		inline void print(short x) { printInteger(x); }

		inline void print(int x) { printInteger(x); }

		inline void print(long int x) { printInteger(x); }

		inline void print(long long int x) { printInteger(x); }

		inline void print(unsigned short x) { printInteger(x); }

		inline void print(unsigned int x) { printInteger(x); }

		inline void print(unsigned long int x) { printInteger(x); }

		inline void print(unsigned long long int x) { printInteger(x); }

		template<typename T1>
		inline void print(const T1 &t1) { out << t1; }

		template<typename T1>
		inline void print(const std::vector<T1> &t1) { printArray(t1); }

		template<typename T1, int N>
		inline void print(const std::array<T1, N> &t1) { printArray(t1); }

		template<typename T1, int N, int M>
		inline void print(const std::array<std::array<T1, M>, N> &t1) { for (auto &t : t1) println(t); }

		template<typename T1>
		inline void print(const std::vector<std::vector<T1>> &t1) { for (auto &t : t1) println(t); }

		template<typename T, typename... Args>
		inline void print(const T &t, Args... args) { print(t), print(args...); }

		template<typename... Args>
		inline void println(Args... args) { print(args...), print('\n'); }

		template<typename T>
		output_writer &operator<<(const T &t) { return print(t), *this; }
	};
}


#define all(x) (x).begin(), (x).end()
#define fori(i,n) for(int i = 0; i < n; i++)
#define rep(i,s,e) for(int i = (s); i <= (e); ++i)
#define repr(i,s,e) for(int i = (s); i >= (e); --i)
#define ll long long int



using namespace std;

class CDifferBy1Bit {
	class Solver {
		io::input_reader in;
		io::output_writer out;

	public:
		Solver(std::istream &in, std::ostream &out) : in(in), out(out) {}

		vector<int> indexesOfOne(int x) {
			vector<int> indexes;
			int i = 0;
			while (x) {
				if (x & 1) indexes.push_back(i);
				i++;
				x >>= 1;
			}
			return indexes;
		}

		int printComplete(int mask, int a) {
			vector<int> res, indexes = indexesOfOne(mask);
			res.push_back(a);
			for (int i: indexes) {
				int s = res.size();
				fori(j, s) res.push_back(res[s - 1 - j] ^ (1 << i));
			}
			out << res << ' ';
			return res.back();
		}

		void printSeq(int mask, int a, int b) {
			int x = a ^b;
			if ((mask & (mask - 1)) == 0) {
				out << a << ' ' << b;
				return;
			}
			fori(i, 30) {
				if ((1 << i) & x) {
					int bit = 1 << i;
					mask ^= bit;
					a = printComplete(mask, a);
					printSeq(mask, a ^ bit, b);
					return;
				}
			}
		}

		void solve() {
			int n, a, b;
			in.read(n, a, b);
			{
				int x = a ^b;
				bool can = false;
				while (x) {
					if (x & 1) can = !can;
					x >>= 1;
				}
				if (!can) {
					out.println("NO");
					return;
				}
			}
			out.println("YES");
			printSeq((1 << n) - 1, a, b);
		}
	};

public:
	void solve(std::istream &in, std::ostream &out) {
		Solver(in, out).solve();
	}
};

int main() {
	std::ios_base::sync_with_stdio(false), cin.tie(0);
	CDifferBy1Bit solver;
	std::istream& in(std::cin);
	std::ostream& out(std::cout);
	solver.solve(in, out);
	return 0;
}


Measured memory_bytes: 1272