get_i(-1, "zero", "one", "two") = zero
get_i(0, "zero", "one", "two") = zero
get_i(2, "zero", "one", "two") = two
get_i(3, "zero", "one", "two") = two

.LC0:
        .string "zero"
_GLOBAL__sub_I_c:
        mov     QWORD PTR c[rip], OFFSET FLAT:.LC0
        ret
c:
        .zero   8

template <class T> constexpr const T& min(const T& a, const T& b) { return a < b ? a : b; }
template <class T> constexpr const T& max(const T& a, const T& b) { return a > b ? a : b; }

template <class T> // deprecated name, use clamp
constexpr T minmax(T x, T _min, T _max) { return min(max(x, _min), _max); }

template <class T>
constexpr T clamp(T x, T _min, T _max) { return minmax(x, _min, _max); }

inline constexpr const char *get_i(int i, const char *p0, __List##I(E__NFValue)) \

.LC0:
        .string "zero"
c:
        .quad   .LC0

template <typename A, typename... T>
constexpr A get_i(int i, const A& p0, const T& ...args)
{
	A list[] = {p0, args...};
	int n = sizeof...(args);
	return list[clamp(i, 0, n)];
}

const char* cr = get_i(1, "zero", "one", "two");
RDUMP(cr);
int ir = get_i(1, 0, 1, 2);
RDUMP(ir);

template <typename T>
constexpr T get_i(int i, std::initializer_list<T> list)
{
	return list[clamp(i, 0, list.size())];
}

enum e {
  e01 = 1,
  e02 = 100,
  e03 = e01 + e02
};

enum e {
  e01 = min(something, something_else),
  e02 = max(something, something_else)
};

template <class T, class V>
constexpr V decode(const T& sel, const V& def)
{
	return def;
}

template <class T>
constexpr const char *decode(const T& sel, const char *def)
{
	return def;
}

template <class T, class K, class V, typename... L>
constexpr V decode(const T& sel, const K& k, const V& v, const L& ...args)
{
	return sel == k ? v : (V)decode(sel, args...);
}

template <class T, class K, typename... L>
constexpr const char *decode(const T& sel, const K& k, const char *v, const L& ...args)
{
	return sel == k ? v : decode(sel, args...);
}


template <class T, class K>
constexpr int findarg(const T& x, const K& k)
{
	return x == k ? 0 : -1;
}

template <class T, class K, typename... L>
constexpr int findarg(const T& sel, const K& k, const L& ...args)
{
	if(sel == k)
		return 0;
	int q = findarg(sel, args...);
	return q >= 0 ? q + 1 : -1;
}

template <typename T>
constexpr T get_i2(int i, const std::initializer_list<T>& list)
{
	const int n = list.size();
	return *(list.begin() + clamp(i, 0, n));
}

const char* c = get_i2(1, {"zero", "one", "two"});

.L.str:
        .asciz  "one"

c:
        .quad   .L.str

	int ind = findarg(1, "0", 1.5, 2, 3);
	RDUMP(ind);

template <class T, class V>
constexpr auto decode(const T& sel, const V& def)
{
	return def;
}

template <class T, class K, class V, typename... L>
constexpr auto decode(const T& sel, const K& k, const V& v, const L& ...args)
{
	return sel == k ? v : decode(sel, args...);
}

template <class I, class V>
void iter_set(I t, V&& v)
{
	*t++ = v;
}

template <class I, class V, typename... Args>
void iter_set(I t, V&& v, Args&& ...args)
{
	*t++ = v;
	iter_set(t, args...);
}

template <class C, typename... Args>
C gather(Args&& ...args)
{
	C x;
	x.SetCount(sizeof...(args));
	iter_set(x.begin(), args...);
	return x;
}

template <class I, class V>
void iter_get(I s, V& v)
{
	v = *s++;
}

template <class I, class V, typename... Args>
void iter_get(I s, V& v, Args& ...args)
{
	v = *s++;
	iter_get(s, args...);
}

template <class C, typename... Args>
int scatter(int n, const C& c, Args& ...args)
{
	if(n < sizeof...(args))
		return 0;
	iter_get(c.begin(), args...);
	return sizeof...(args);
}

template <class C, typename... Args>
int scatter(const C& c, Args& ...args)
{
	return scatter(c.GetCount(), c, args...);
}

template <typename... Args>
String Format(const char *fmt, const Args& ...args)
{
	return Format(fmt, gather<Vector<Value>>(args...));
}

	template <class I, class V>
	void iter_set(I t, V&& v)
	{
		*t++ = std::forward<V>(v);
	}
	
	template <class I, class V, typename... Args>
	void iter_set(I t, V&& v, Args&& ...args)
	{
		*t++ = std::forward<V>(v);
		iter_set(t, std::forward<Args>(args)...);
	}
	
	template <class C, typename... Args>
	C gather(Args&& ...args)
	{
		C x;
		x.SetCount(sizeof...(args));
		iter_set(x.begin(), std::forward<Args>(args)...);
		return x;
	}

template <typename... Args>
String Format(const char *fmt, Args&& ...args)
{
	return Format(fmt, gather<Vector<Value>>(std::forward<Args>(args)...));
}

	template <class I, class V>
	void iter_set(I& t, V&& v)
	{
		*t = std::forward<V>(v);
	}
	
	template <class I, class V, typename... Args>
	void iter_set(I& t, V&& v, Args&& ...args)
	{
		*t++ = std::forward<V>(v);
		iter_set(t, std::forward<Args>(args)...);
	}
	
	template <class C, typename... Args>
	C gather(Args&& ...args)
	{
		C x;
		x.SetCount(sizeof...(args));
		auto iter = x.Begin();
		iter_set(iter, std::forward<Args>(args)...);
		return x;
	}