#include <bits/stdc++.h>
using namespace std;

// loops
#define FOR_3(i, a, b) for (int i = (a), bb##i = (b); i <= bb##i; ++i)
#define FORR_3(i, a, b) for (int i = (b), aa##i = (a); i >= aa##i; --i)

#define FOR_2(i, n) FOR_3(i, 0, (n)-1)
#define FORR_2(i, n) FORR_3(i, 0, (n)-1)

#define FOR_1(n) FOR_2(_i##__LINE__, n)
#define FOR_0() for (;;)

#define OVERLOAD(_0, _1, _2, _3, NAME, ...) NAME
#define FOR(...)                                                       \
	OVERLOAD(_0 __VA_OPT__(, )##__VA_ARGS__, FOR_3, FOR_2, FOR_1, FOR_0) \
	(__VA_ARGS__)

#define FORR(...)                                                         \
	OVERLOAD(_0 __VA_OPT__(, )##__VA_ARGS__, FORR_3, FORR_2, FORR_1, FOR_0) \
	(__VA_ARGS__)

#ifdef LOCAL
#include <sys/prctl.h>
#include <sys/wait.h>
#include <unistd.h>

void print_trace()
{
	char pid_buf[30];
	sprintf(pid_buf, "%d", getpid());
	char name_buf[512];
	name_buf[readlink("/proc/self/exe", name_buf, 511)] = 0;
	prctl(PR_SET_PTRACER, PR_SET_PTRACER_ANY, 0, 0, 0);
	int child_pid = fork();
	if (!child_pid)
	{
		dup2(2, 1); // redirect output to stderr - edit: unnecessary?
		execl("/usr/bin/gdb", "gdb", "--batch", "-n", "-ex", "thread", "-ex", "bt",
					name_buf, pid_buf, NULL);
		abort(); /* If gdb failed to start */
	}
	else
	{
		waitpid(child_pid, NULL, 0);
	}
}

extern const char *const sys_siglist[];

void handler(int sig)
{
	cerr << "SIGNAL " << sig << " (" << sys_siglist[sig] << ")" << endl;
	print_trace();
	exit(1);
}

#define INDENT_SIZE 2
string indent;

void _E() { cerr << endl; }
template <class ARG, class... ARGS>
void _E(ARG &&arg, ARGS &&...args)
{
	cerr << std::forward<ARG>(arg) << " ";
	_E(std::forward<ARGS>(args)...);
}

#define ERR(...)                               \
	{                                            \
		cerr << indent << "[" << __LINE__ << "] "; \
		_E(__VA_ARGS__);                           \
	}

#define _V5(x) #x, "==", (x)
#define _V4(x, ...) #x, "==", (x)__VA_OPT__(, "|", _V5(__VA_ARGS__))
#define _V3(x, ...) #x, "==", (x)__VA_OPT__(, "|", _V4(__VA_ARGS__))
#define _V2(x, ...) #x, "==", (x)__VA_OPT__(, "|", _V3(__VA_ARGS__))
#define _V1(x, ...) #x, "==", (x)__VA_OPT__(, "|", _V2(__VA_ARGS__))
#define ERRV(...) ERR(_V1(__VA_ARGS__))
#define INDENT auto _indenter = Indenter();

struct Indenter
{
	Indenter()
	{
		FOR(INDENT_SIZE)
		indent.push_back(' ');
	}
	~Indenter()
	{
		FOR(INDENT_SIZE)
		indent.pop_back();
	}
};

#define FAIL(str)                                                             \
	{                                                                           \
		cerr << "ASSERT FAILED   " << str << "   " << __FILE__ << ':' << __LINE__ \
				 << endl;                                                             \
		abort();                                                                  \
	}

#define SLEEP this_thread::sleep_for(100ms);

#else
#define INDENT
#define SLEEP
#define FAIL(x) \
	{             \
	}
#define ERR(...) \
	{              \
	}
#define ERRV(...) \
	{               \
	}
#endif

// asserts
#define CHECK(cond) \
	if (!(cond))      \
	FAIL(#cond)

#define CHECK_OP(op, a, b, res) \
	if (!(res))                   \
	FAIL(#a " " op " " #b "   (" + to_string(a) + " vs " + to_string(b) + ")")

#define CHECK_EQ(a, b) CHECK_OP("==", a, b, (a) == (b))
#define CHECK_NE(a, b) CHECK_OP("!=", a, b, (a) != (b))
#define CHECK_LE(a, b) CHECK_OP("<=", a, b, (a) <= (b))
#define CHECK_GE(a, b) CHECK_OP(">=", a, b, (a) >= (b))
#define CHECK_LT(a, b) CHECK_OP("<", a, b, (a) < (b))
#define CHECK_GT(a, b) CHECK_OP(">", a, b, (a) > (b))

#define CHECK_RANGE(x, a, b) \
	if (!(a <= x && x < b))    \
	FAIL(#x " in [" #a "," #b ")")

// min / max
template <class T>
auto min(T &&t) { return move(t); };
template <class T, class... TS>
auto min(T &&t, TS &&...ts)
{
	auto rest = min(forward<TS>(ts)...);
	return t < rest ? t : rest;
}

template <class T>
auto max(T &&t) { return move(t); };
template <class T, class... TS>
auto max(T &&t, TS &&...ts)
{
	auto rest = max(forward<TS>(ts)...);
	return t > rest ? t : rest;
}

#define REMIN(a, b) ((a) = min(a, b));
#define REMAX(a, b) ((a) = max(a, b));

// containers / arrays
#define ALL(c) (c).begin(), (c).end()
#define SZ(x) int((x).size())
#define ZERO(x) memset(x, 0, sizeof(x));

// other
#define UNUSED(...) (void)(__VA_ARGS__);

// magic 1-indexed vector
template <class T>
struct vec : vector<T>
{
	decltype(vector<T>()[0]) operator[](int i)
	{
		CHECK_GE(i, 1);
		while (i > size())
			vector<T>::emplace_back();
		return vector<T>::operator[](i - 1);
	}
	int size() { return vector<T>::size(); }
};

// magic 1-indexed deque
template <class T>
struct deq : deque<T>
{
	auto &operator[](int i)
	{
		CHECK_GE(i, 1);
		while (i > size())
			deque<T>::emplace_back();
		return deque<T>::operator[](i - 1);
	}
	int size() { return deque<T>::size(); }
};

// magic 1-indexed array
template <class T, int sz>
struct arr : array<T, sz>
{
	auto &operator[](int i) { return array<T, sz>::operator[](i - 1); }
};

// types
#define umap unordered_map
#define deq deque
using ll = long long;
using ld = long double;
using pii = pair<int, int>;

using vi = vec<int>;
using vll = vec<ll>;
using vpii = vec<pii>;
using vb = vec<bool>;

using di = deq<int>;
using dll = deq<ll>;
using dpii = deq<pii>;

// abbrevs
#define push push_back
#define pop pop_back
#define CMP bool operator<(const auto &o) const

// array operations
#define SORT(v) sort(ALL(v));
#define UNIQUE(c)                     \
	{                                   \
		SORT(c);                          \
		c.erase(unique(ALL(c)), c.end()); \
	}

auto PERM(int n)
{
	di v(n);
	FOR(i, n)
	v[i] = i;
	return v;
}

template <class V>
auto esort(const V &v)
{
	auto perm = PERM(SZ(v));
	sort(ALL(perm), [&](int a, int b)
			 { return v[a] < v[b]; });
	return perm;
}

template <class V>
auto eremap(V &&vv)
{
	auto v = move(vv);
	SORT(v);
	umap<typename V::value_type, int> r;
	int nxt = 0;
	for (auto &e : v)
		if (r.emplace(e, nxt).second)
			++nxt;
	return r;
}

template <class X, class FR, class TO>
bool range(const X &x, const FR &fr, const TO &to)
{
	return !(x < fr) && x < to;
}

template <class A, class B>
auto divup(A a, B b) { return (a + b - 1) / b; }

// bit operations
int msb(int x)
{
	CHECK_GT(x, 0)
	return 31 - __builtin_clz(x);
}

int msb(ll x)
{
	CHECK_GT(x, 0)
	return 63 - __builtin_clzll(x);
}

int lsb(int x)
{
	CHECK_GT(x, 0)
	return __builtin_ctz(x);
}

int lsb(ll x)
{
	CHECK_GT(x, 0)
	return __builtin_ctzll(x);
}

int popcount(int x) { return __builtin_popcount(x); }
int popcount(ll x) { return __builtin_popcountll(x); }

#define FORB(b, mask) \
	for (auto m = mask, bit = lsb(m); m; m ^= (1 << b), bit = lsb(m))

#define FORS(s, mask) \
	for (auto s = mask; s; s = (s - 1) & mask) // iterate subsets

template <class T>
int log2up(T x)
{
	return x <= 1 ? 0 : msb(x - 1) + 1;
}

default_random_engine RNG(123);
#define SHUFFLE(c) shuffle(ALL(c), RNG);

// stdin
template <class T>
T read()
{
	T x;
	cin >> x;
	return x;
}
#define II read<int>()
#define ILL read<ll>()

void _I()
{
}
template <class ARG, class... ARGS>
void _I(ARG &&arg, ARGS &&...args)
{
	cin >> arg;
	_I(forward<ARGS>(args)...);
}
#define I(...) _I(__VA_ARGS__);

// stdout
template <class T>
void _print(T x)
{
	cout << x;
	bool space = true;
	if constexpr (is_same_v<T, char>)
	{
		if (x == '\n')
			space = false;
	}
	if (space)
		cout << " ";
}
template <class T>
void _print(deq<T> &d)
{
	for (auto &e : d)
		cout << e << " ";
}
void _O() {}
template <class ARG, class... ARGS>
void _O(ARG &&arg, ARGS &&...args)
{
	_print(arg);
	_O(forward<ARGS>(args)...);
}
#define O(...) _O(__VA_ARGS__ __VA_OPT__(, ) '\n');
#define OO(...) _O(__VA_ARGS__);

// stderr
template <class T>
auto &operator<<(ostream &os, deq<T> &v)
{
	os << "{";
	bool first = true;
	for (auto &e : v)
	{
		if (first)
			first = false;
		else
			os << " ";
		os << e;
	}
	return os << "}";
}

template <class A, class B>
auto &operator<<(ostream &os, pair<A, B> &p)
{
	return os << "{" << p.first << " " << p.second << "}";
}

////////////////////////////////////////////////////////////////////////////////
// snippets/modulo.hpp
//
template <class T, class E>
T fpow(T a, E exp)
{
	T r = 1;
	while (exp)
	{
		if (exp & 1)
		{
			r *= a;
			--exp;
		}
		else
		{
			exp >>= 1;
			a *= a;
		}
	}
	return r;
}

template <int MOD>
class Modulo
{
public:
	using H = int;
	H h = 0;

public:
	Modulo() = default;

	Modulo(H x) : h((x + MOD) % MOD) { CHECK_GE(x + MOD, 0); }

	Modulo(const Modulo &) = default;

public:
	Modulo &operator+=(const Modulo &o)
	{
		h += o.h;
		if (h >= MOD)
			h -= MOD;
		return *this;
	}

	Modulo &operator-=(const Modulo &o)
	{
		h = MOD + h - o.h;
		if (h >= MOD)
			h -= MOD;
		return *this;
	}

	Modulo &operator*=(const Modulo &o)
	{
		h = (1ULL * h * o.h) % MOD;
		return *this;
	}

	Modulo &operator/=(const Modulo &o)
	{
		const auto TOTIENT = MOD - 1;
		*this *= fpow(o, TOTIENT - 1);
		return *this;
	}

	bool operator==(const Modulo &o) const { return h == o.h; }
	bool operator!=(const Modulo &o) const { return h != o.h; }

	Modulo operator+(const Modulo &o) const { return Modulo(*this) += o; }
	Modulo operator-(const Modulo &o) const { return Modulo(*this) -= o; }
	Modulo operator*(const Modulo &o) const { return Modulo(*this) *= o; }
	Modulo operator/(const Modulo &o) const { return Modulo(*this) /= o; }

	Modulo &operator--()
	{
		if (h == 0)
			h = MOD;
		--h;
		return *this;
	}
	Modulo &operator++()
	{
		++h;
		if (h == MOD)
			h = 0;
		return *this;
	}
	Modulo operator--(int)
	{
		auto m = *this;
		--(*this);
		return m;
	}
	Modulo operator++(int)
	{
		auto m = *this;
		++(*this);
		return m;
	}

	explicit operator H() const { return h; }
};

template <int INT>
ostream &operator<<(ostream &os, const Modulo<INT> &modulo)
{
	return os << modulo.h;
}
// snippets/modulo.hpp
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
//
// snippets/graph.hpp
//
template <class V, class _E>
struct Graph
{
	Graph() : _p_vs(make_shared<vec<V>>()), vs(*_p_vs) {}
	template <class _EE>
	Graph(Graph<V, _EE> &o) : _p_vs(o._p_vs), vs(*_p_vs) {}

	shared_ptr<vec<V>> _p_vs;
	vec<V> &vs;
	vec<vi> ves;
	auto &operator[](int i)
	{
		vs[i];
		return ves[i];
	}
	int size() { return SZ(vs); }

	struct E : _E
	{
		E(_E &&e = _E()) : _E(move(e)) {}

		struct EV
		{
			int dest = 0;
			int ith = 0;
		};

		arr<EV, 2> ev;
		auto &operator[](int i) { return ev[i]; }
	};
	vec<E> es;

	int dest(int v, int ve)
	{
		int e = ves[v][ve];
		int ith = 1 + (es[e][2].dest != v);
		return es[e][ith].dest;
	}

	void e(int a, int b, _E &&_e = _E())
	{
		CHECK_NE(a, b);
		operator[](a);
		operator[](b);
		ves[a].push(SZ(es) + 1);
		ves[b].push(SZ(es) + 1);
		es.emplace_back(move(_e));
		es.back()[1] = {a, SZ(ves[a])};
		es.back()[2] = {b, SZ(ves[b])};
	}
};

vi _vis;
int _cvis = 0;
template <class G>
struct Dfs
{
	struct S
	{
		int v;
		int ve;
	};

	function<bool(int, int, int)> can_visit;
	function<void(int, int, int)> visit;
	function<void(int, int, int)> leave;

#define CAN_VISIT .can_visit = [&](int p, int v, int e)
#define VISIT .visit = [&](int p, int v, int e)
#define LEAVE .leave = [&](int p, int v, int e)

	Dfs()
	{
		++_cvis;
	}

	void run(G &g)
	{
		FOR(i, SZ(g))
		run(g, i);
	}

	void run(G &g, int v0)
	{
		_vis.resize(SZ(g));
		if (_vis[v0] == _cvis)
			return;

		vec<S> s;

		s.push({v0, 1});
		_vis[v0] = _cvis;
		if (visit)
			visit(0, v0, 0);

		while (!s.empty())
		{
			auto [v, ve] = s.back();
			if (ve > SZ(g[v]))
			{
				s.pop();
				if (!s.empty() && leave)
					leave(s.back().v, g.dest(s.back().v, s.back().ve - 1),
								g[s.back().v][s.back().ve - 1]);
				continue;
			}
			s.back().ve++;

			int e = g.ves[v][ve];
			int dest = g.dest(v, ve);

			int p = 0;
			if (SZ(s) - 1 >= 1)
				p = s[SZ(s) - 1].v;

			if (dest != p && (!can_visit || can_visit(v, dest, e)) &&
					_vis[dest] != _cvis)
			{
				s.push({dest, 1});
				_vis[dest] = _cvis;
				if (visit)
					visit(v, dest, e);
			}
		}
	}
};
// snippets/graph.hpp
////////////////////////////////////////////////////////////////////////////////

////////////////////////////////////////////////////////////////////////////////
//  _          _     _   _                                                    //
// | |        | |   | | | |                                                   //
// | |     ___| |_  | |_| |__   ___    __ _  __ _ _ __ ___   ___              //
// | |    / _ \ __| | __| '_ \ / _ \  / _` |/ _` | '_ ` _ \ / _ \             //
// | |___|  __/ |_  | |_| | | |  __/ | (_| | (_| | | | | | |  __/             //
// \_____/\___|\__|  \__|_| |_|\___|  \__, |\__,_|_| |_| |_|\___|             //
//                                     __/ |                                  //
//                                    |___/                                   //
//  ██████▓▓▒▒░░░░░░▒▒▒▒▒▒▒▒░░░░▒▒▒▒░░▒▒▒▒░░░░░░░░▒▒▒▒▒▒▒▒░░░░░░░░░░░░██████  //
//  ██████░░░░░░░░░░░░░░░░░░░░░░░░▒▒▒▒░░░░░░░░░░▒▒░░▒▒░░░░░░░░░░░░  ░░▒▒████  //
//  ████░░░░░░░░░░▒▒░░░░░░░░░░░░░░░░▒▒▒▒▒▒░░░░▒▒░░░░▒▒    ░░░░░░░░░░  ░░████  //
//  ████░░░░░░▒▒▓▓████▓▓▓▓▓▓░░░░░░░░░░▒▒▒▒▒▒▒▒▒▒▒▒░░░░▒▒▓▓▓▓████▓▓▒▒░░  ▓▓██  //
//  ████░░▒▒▓▓██████▓▓▓▓▓▓▓▓██▒▒░░░░░░░░▓▓▓▓░░░░░░░░██▓▓▓▓▒▒▒▒████▓▓▒▒░░████  //
//  ████▓▓▒▒▒▒▓▓████▓▓▓▓██▓▓████░░░░░░░░▒▒▒▒░░░░░░████▓▓▓▓▓▓░░▓▓██▓▓░░░░████  //
//  ████▒▒▒▒▓▓▓▓████▓▓▓▓▓▓▓▓████▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒▒████▓▓▓▓▓▓▒▒████▓▓░░░░▓▓██  //
//  ████▒▒▒▒▒▒▓▓▓▓██████▓▓██████░░▒▒▒▒▒▒▒▒▒▒░░░░░░████▓▓▓▓▓▓████▓▓▒▒░░░░▓▓██  //
//  ████▓▓▓▓▓▓▒▒▓▓▓▓▓▓██████▓▓▒▒▒▒▒▒▒▒░░▒▒░░░░░░░░▒▒████████▓▓▓▓▒▒░░▒▒▒▒░░██  //
//  ██▓▓░░░░▒▒▓▓██▒▒▒▒▓▓▓▓▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░░░░░░░░▒▒▓▓▓▓▒▒▒▒▒▒▓▓▓▓░░▒▒██  //
//  ██░░▓▓▓▓▒▒▒▒▒▒▓▓▒▒▒▒▒▒▒▒▒▒▒▒░░░░░░░░░░░░░░    ░░░░░░░░▒▒░░▒▒▓▓▒▒░░░░░░▓▓  //
//  ██░░░░▒▒▓▓▓▓▒▒▓▓▓▓▒▒▒▒▒▒░░▒▒░░░░░░░░░░░░      ░░░░░░░░▒▒▒▒▓▓▒▒▒▒▓▓▓▓▒▒▒▒  //
//  ▓▓▒▒▒▒▒▒░░▓▓▓▓▒▒▓▓▒▒▒▒▒▒░░░░░░░░░░░░░░░░      ░░░░░░░░▒▒▓▓▓▓▒▒▓▓░░        //
//  ▓▓▒▒▒▒▓▓▒▒▒▒▓▓▒▒▓▓▓▓▒▒▒▒░░░░░░░░░░░░░░░░      ░░░░░░▒▒▒▒██▒▒▓▓▓▓░░▒▒▒▒▒▒  //
//  ▓▓▒▒░░░░▓▓░░▓▓▓▓▒▒▓▓▒▒▒▒░░░░░░░░░░░░░░░░        ░░▒▒▒▒▓▓▓▓▒▒▓▓▒▒▒▒░░  ░░  //
//  ██▒▒▒▒░░▒▒▓▓▒▒▓▓▒▒▓▓▒▒▒▒░░░░░░░░░░░░░░░░        ░░░░▒▒▓▓▓▓▒▒▓▓░░▓▓  ▒▒    //
//  ██▒▒▒▒▒▒▒▒▓▓░░▓▓▒▒▓▓▒▒▒▒▒▒░░░░░░░░░░░░░░      ░░░░▒▒▒▒▒▒▓▓░░▓▓░░▓▓░░░░▓▓  //
//  ██▓▓▓▓▓▓▓▓▒▒▒▒▓▓▒▒▓▓▒▒▒▒▒▒▒▒░░░░░░░░░░░░    ░░▒▒▒▒▒▒▒▒▒▒▓▓▒▒▓▓░░▒▒▒▒░░██  //
//  ████▓▓▒▒▒▒▓▓▓▓▒▒▓▓▒▒▒▒▓▓▒▒▒▒░░░░░░░░░░░░      ░░▓▓▒▒▒▒▒▒▒▒▒▒▒▒▓▓▓▓▒▒████  //
//  ██████████▓▓▒▒▒▒▒▒▒▒██▓▓▓▓▒▒░░░░░░░░░░░░      ░░░░░░▒▒▒▒░░▒▒▒▒▓▓████████  //
//  ██████████████░░░░░░▒▒██▓▓▓▓██▓▓░░░░░░░░    ▓▓▒▒▒▒▓▓▓▓▒▒░░  ▒▒██████████  //
//  ████████████████░░░░░░▓▓▓▓▓▓▓▓▓▓▓▓▒▒░░░░▒▒▓▓▓▓▓▓▓▓▒▒▒▒      ████████████  //
//  ████████████████░░░░░░▒▒▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▓▒▒▒▒▒▒░░      ░░████████████  //
//  ████████████████░░░░░░▒▒░░▒▒▒▒░░▒▒▒▒▒▒▒▒▒▒░░░░░░▒▒        ██████████████  //
//  ████████████████▒▒░░░░▒▒░░░░░░░░░░░░▒▒▒▒░░░░░░░░▒▒░░    ▒▒██████████████  //
//  ██████████████████░░░░▒▒░░░░░░░░░░▒▒▒▒▒▒▒▒░░░░  ▓▓░░    ████████████████  //
//  ██████████████████░░░░▒▒░░░░░░░░░░▒▒▒▒▒▒▒▒░░░░  ▓▓░░  ▓▓████████████████  //
//                                                                            //
//           ;;;;;              ██████╗ ███████╗ ██████╗ ██╗███╗   ██╗        //
//           ;;;;;              ██╔══██╗██╔════╝██╔════╝ ██║████╗  ██║        //
//           ;;;;;              ██████╔╝█████╗  ██║  ███╗██║██╔██╗ ██║        //
//         ..;;;;;..            ██╔══██╗██╔══╝  ██║   ██║██║██║╚██╗██║        //
//          ':::::'             ██████╔╝███████╗╚██████╔╝██║██║ ╚████║        //
//            ':`               ╚═════╝ ╚══════╝ ╚═════╝ ╚═╝╚═╝  ╚═══╝        //
//                                                                            //

const bool MULTIPLE_TEST_CASES = false;

// using F = Modulo<1e9 + 7>;
// using F = Modulo<998'244'353>;

struct V
{
	//   int c = 0;
};
struct E
{
	//   int c = 0;
};
using G = Graph<V, E>;
using DFS = Dfs<G>;

struct Pt
{
	arr<int, 2> x;
	// int c = -1;
	bool operator<(const Pt &o) const { return x < o.x; }
};

const int MX = 1'000'009;

bool used[MX];

struct Test_Case
{

	Test_Case()
	{
		int n = II;
		int have = 0;
		int c = 1;

		for (;; ++c)
		{
			have += __builtin_popcount(c);
			used[c] = 1;
			if (have >= n)
				break;
		}

		for (;; --c)
		{
			int pc = __builtin_popcount(c);
			if (have - pc < n)
			{
				continue;
			}
			have -= pc;
			used[c] = 0;
			if (have == n)
				break;
		}

		int num = 0;
		FOR(i, MX)
		{
			if (used[i])
				++num;
		}

		O(num);
		FORR(i, MX)
		{
			if (used[i])
				cout << i << " ";
		}
		O();
	}
};

//                                                                            //
// ════════════ ('\../') ═════════════                                        //
// ════════════ (◕.◕) ═══════════════                                        //
// ════════════ (,,)(,,) ═════════════                                        //
// .▀█▀.█▄█.█▀█.█▄.█.█▄▀　█▄█.█▀█.█─█.                                        //
// ─.█.─█▀█.█▀█.█.▀█.█▀▄　─█.─█▄█.█▄█- for reading my code!                   //
// ═══════════════════════════════════              --Adam                    //
////////////////////////////////////////////////////////////////////////////////

int main()
{
#ifdef LOCAL
	signal(SIGSEGV, handler);
	signal(SIGABRT, handler);
#endif
	ios_base::sync_with_stdio(0);
	cout.precision(20);
	cout << fixed;

	int num_cases = 1;
	if (MULTIPLE_TEST_CASES)
		cin >> num_cases;

	FOR(i, num_cases)
	{
		ERR()
		ERR("TEST CASE", i + 1)
		INDENT
		Test_Case tc;
	}

	return 0;
}