#pragma once

//±ê×¼¿âÀàÐÍÀ©Õ¹²Ù×÷
//20191212-1029

#include <cassert>
#include <cmath>
#include <cstdint>

#include <type_traits>
#include <limits>
#include <algorithm>
#include <utility>
#include <tuple>
#include <functional>
#include <iterator>

#include <string>

#include <exception>
#include <stdexcept>
#include <random>
#include <ratio>

#include <chrono>




//************
//ÀàÐͱðÃûÀ©Õ¹
//************


//durationÀ©Õ¹
namespace std
{
namespace chrono
{
typedef duration<long, ratio<3600*24>> days;
typedef duration<long, ratio<3600*24*7>> weeks;
}
}



//************
//»ù´¡ÀàÐÍÀ©Õ¹
//************

//ÎÞÓÃռλÀàÐÍ
template<int N>
class BlankType
{
};



//²âÊÔ²ÎÊýÊÇ·ñºÏ·¨Àà
template<typename ...>
struct ParamValidTester
{
	typedef void type;
};


//ÏÈÈ¥³ýÒýÓÃÔÙÈ¥³ý³£ÊýÒ×±äÊôÐÔ
template<typename Ty>
struct RemoveCVRef
{
	using type = typename std::remove_cv<typename std::remove_reference<Ty>::type>::type;
};

//ºóÕßÈ¥³ýÒýÓó£ÊýÒ×±äºóÊÇ·ñΪǰÕß
template<typename TyDst, typename TySrc>
struct IsRemoveCVRefSame:
	std::is_same<TyDst, typename RemoveCVRef<TySrc>::type>
{
};


//ºóÕß²ÎÊý°üÊÇ·ñÒª²»Ã»ÓвÎÊý£¬Òª²»Ö»ÓÐÒ»¸ö²¢ÇÒΪǰÕß
template<typename TyDst, typename ...TySrc_S>
struct IsNoneOrSame:
	std::integral_constant<bool, sizeof...(TySrc_S)==0>
{
};
template<typename TyDst, typename TySrc>
struct IsNoneOrSame<TyDst, TySrc>:
	std::is_same<TyDst, TySrc>
{
};

//ºóÕß²ÎÊý°üÊÇ·ñÒª²»Ã»ÓвÎÊý£¬Òª²»Ö»ÓÐÒ»¸ö²¢ÇÒÈ¥³ýÒýÓó£ÊýÒ×±äºóΪǰÕß
template<typename TyDst, typename ...TySrc_S>
struct IsNoneOrRemoveCVRefSame:
	std::integral_constant<bool, sizeof...(TySrc_S)==0>
{
};
template<typename TyDst, typename TySrc>
struct IsNoneOrRemoveCVRefSame<TyDst, TySrc>:
	IsRemoveCVRefSame<TyDst, TySrc>
{
};


//²âÊÔÊÇ·ñΪµü´úÆ÷
template<class Ty, class= void>
struct IsIteratorType:
	std::false_type
{
};
template<class Ty>
struct IsIteratorType<Ty, typename ParamValidTester<
	typename std::iterator_traits<Ty>::iterator_category>::type
>: std::true_type
{
};


//²âÊÔÈ¥³ý³£Ò×±äÒ×ÓÃÊôÐÔºó£¬ÊÇ·ñΪ×Ö·ûÖ¸Õ룬×Ö·ûÊý×é»òstringÀàÐÍ
template<class Ty>
struct IsRemoveCVRefSameSzOrString:
	std::integral_constant<bool, IsRemoveCVRefSame<char *, Ty>::value
	|| IsRemoveCVRefSame<const char *, Ty>::value
	|| (std::is_array<typename RemoveCVRef<Ty>::type>::value
	&& IsRemoveCVRefSame<char, typename std::remove_extent<
	typename RemoveCVRef<Ty>::type>::type>::value)
	|| IsRemoveCVRefSame<std::string, Ty>::value>
{
};



//Éú³Éµü´úÆ÷½âÒýÓõÄÀàÐÍ£¬±£Áô³£Ò×±äÒýÓÃÊôÐÔ
template<typename TyIt>
struct IteratorDerefType
{
	using type = decltype(*std::declval<TyIt>());
};

//Éú³Éµü´úÆ÷½âÒýÓõÄÀàÐÍÔÙÈ¥³ý³£Ò×±äÒýÓÃÊôÐÔ
template<typename TyIt>
struct IteratorRemoveCVRefDerefType
{
	using type = typename RemoveCVRef<typename IteratorDerefType<TyIt>::type>::type;
};



//¸ù¾ÝÌṩÀ´Ô´ÀàÐ͵ÄÒýÓᢳ£Êý¡¢Ò×±äÊôÐÔ£¬¶ÔÄ¿µÄÀàÐ͸½¼ÓͬÑùµÄÊôÐÔ
template<typename TySrc, typename TyDst>
struct TypeAttachAttribute
{
	using type = TyDst;
};
//³£ÊôÐÔÌØ»¯
template<typename TySrc, typename TyDst>
struct TypeAttachAttribute<const TySrc, TyDst>
{
	using type = typename std::add_const<
		typename TypeAttachAttribute<TySrc, TyDst>::type>::type;
};
//Ò×±äÊôÐÔÌØ»¯
template<typename TySrc, typename TyDst>
struct TypeAttachAttribute<volatile TySrc, TyDst>
{
	using type = typename std::add_volatile<
		typename TypeAttachAttribute<TySrc, TyDst>::type>::type;
};
//×óÖµÒýÓÃÊôÐÔÌØ»¯
template<typename TySrc, typename TyDst>
struct TypeAttachAttribute<TySrc &, TyDst>
{
	using type = typename std::add_lvalue_reference<
		typename TypeAttachAttribute<TySrc, TyDst>::type>::type;
};
//ÓÒÖµÒýÓÃÊôÐÔÌØ»¯
template<typename TySrc, typename TyDst>
struct TypeAttachAttribute<TySrc &&, TyDst>
{
	using type = typename std::add_rvalue_reference<
		typename TypeAttachAttribute<TySrc, TyDst>::type>::type;
};



//Çóµ÷Ó÷µ»ØÖµÀàÐÍ
template<typename TyFunc, typename ...Ty_S>
struct InvokeReturnType
{
	using type = decltype(std::declval<TyFunc>()(std::declval<Ty_S>()...));
};



//ÕûÊýÐòÁÐÄ£°å
template<size_t ...c_idx_s>
struct IndexSequence
{
};
template<>
struct IndexSequence<>
{
	using value_type = size_t;
	static constexpr size_t size()
	{
		return 0;
	}
};
template<int c_idx, int ...c_rest_s>
struct IndexSequence<c_idx, c_rest_s...>
{
	using value_type = size_t;
	static constexpr size_t size()
	{
		return IndexSequence<c_rest_s...>::size()+1;
	}
};

//ÕûÊýÄ£°åÌí¼ÓÔªËغ¯Êý
template<size_t c_new, size_t ...c_idx_s>
inline IndexSequence<c_idx_s..., c_new> AddIndexSequence(IndexSequence<c_idx_s...>)
{
	return IndexSequence<c_idx_s..., c_new>();
}

//Éú³É˳ÐòµÝÔöÕûÊýÄ£°å¸¨ÖúÀà
template<size_t c_size>
struct _MakeIndexSequenceAssist
{
	using type = decltype(AddIndexSequence<c_size-1>(
		typename _MakeIndexSequenceAssist<c_size-1>::type()));
};
template<>
struct _MakeIndexSequenceAssist<0>
{
	using type = IndexSequence<>;
};
//Éú³É˳ÐòµÝÔöÕûÊýÄ£°åÀà
template<size_t c_size>
using MakeIndexSequence = typename _MakeIndexSequenceAssist<c_size>::type;



//Ä£°å¶¨³¤ÕûÐÎ
template<bool c_bSigned, int c_size>
struct TemplateInt
{
};
template<>
struct TemplateInt<true, 1>
{
	using type = int8_t;
};
template<>
struct TemplateInt<false, 1>
{
	using type = uint8_t;
};
template<>
struct TemplateInt<true, 2>
{
	using type = int16_t;
};
template<>
struct TemplateInt<false, 2>
{
	using type = uint16_t;
};
template<>
struct TemplateInt<true, 4>
{
	using type = int32_t;
};
template<>
struct TemplateInt<false, 4>
{
	using type = uint32_t;
};
template<>
struct TemplateInt<true, 8>
{
	using type = int64_t;
};
template<>
struct TemplateInt<false, 8>
{
	using type = uint64_t;
};



//¹ãÒåµÄ±È½Ïº¯ÊýÀà
template<typename Ty1, typename Ty2= Ty1>
struct GeneralLess
{
	typedef bool result_type;
	typedef Ty1 first_argument_type;
	typedef Ty2 second_argument_type;
	result_type operator()(const first_argument_type &arg1,
		const second_argument_type &arg2) const
	{
		return arg1<arg2;
	}
};
template<typename Ty1, typename Ty2= Ty1>
struct GeneralEqualTo
{
	typedef bool result_type;
	typedef Ty1 first_argument_type;
	typedef Ty2 second_argument_type;
	result_type operator()(const first_argument_type &arg1,
		const second_argument_type &arg2) const
	{
		return arg1==arg2;
	}
};
template<typename Ty1, typename Ty2= Ty1>
struct GeneralLessEqual
{
	typedef bool result_type;
	typedef Ty1 first_argument_type;
	typedef Ty2 second_argument_type;
	result_type operator()(const first_argument_type &arg1,
		const second_argument_type &arg2) const
	{
		return arg1<=arg2;
	}
};
template<typename Ty1, typename Ty2= Ty1>
struct GeneralGreater
{
	typedef bool result_type;
	typedef Ty1 first_argument_type;
	typedef Ty2 second_argument_type;
	result_type operator()(const first_argument_type &arg1,
		const second_argument_type &arg2) const
	{
		return arg1>arg2;
	}
};
template<typename Ty1, typename Ty2= Ty1>
struct GeneralGreaterEqual
{
	typedef bool result_type;
	typedef Ty1 first_argument_type;
	typedef Ty2 second_argument_type;
	result_type operator()(const first_argument_type &arg1,
		const second_argument_type &arg2) const
	{
		return arg1>=arg2;
	}
};
template<typename Ty1, typename Ty2= Ty1>
struct GeneralNotEqualTo
{
	typedef bool result_type;
	typedef Ty1 first_argument_type;
	typedef Ty2 second_argument_type;
	result_type operator()(const first_argument_type &arg1,
		const second_argument_type &arg2) const
	{
		return arg1!=arg2;
	}
};


//À©Õ¹µÄ¹ãÒå±È½Ïº¯ÊýÀ࣬ʹÓÃСÓں͵ÈÓÚ²Ù×÷ÔËËã
template<typename Ty1, typename Ty2= Ty1>
struct ExtendGeneralLessEqual
{
	typedef bool result_type;
	typedef Ty1 first_argument_type;
	typedef Ty2 second_argument_type;
	result_type operator()(const first_argument_type &arg1,
		const second_argument_type &arg2) const
	{
		return arg1<arg2 || arg1==arg2;
	}
};
template<typename Ty1, typename Ty2= Ty1>
struct ExtendGeneralGreater
{
	typedef bool result_type;
	typedef Ty1 first_argument_type;
	typedef Ty2 second_argument_type;
	result_type operator()(const first_argument_type &arg1,
		const second_argument_type &arg2) const
	{
		return !(arg1<arg2 || arg1==arg2);
	}
};
template<typename Ty1, typename Ty2= Ty1>
struct ExtendGeneralGreaterEqual
{
	typedef bool result_type;
	typedef Ty1 first_argument_type;
	typedef Ty2 second_argument_type;
	result_type operator()(const first_argument_type &arg1,
		const second_argument_type &arg2) const
	{
		return !(arg1<arg2);
	}
};
template<typename Ty1, typename Ty2= Ty1>
struct ExtendGeneralNotEqualTo
{
	typedef bool result_type;
	typedef Ty1 first_argument_type;
	typedef Ty2 second_argument_type;
	result_type operator()(const first_argument_type &arg1,
		const second_argument_type &arg2) const
	{
		return !(arg1==arg2);
	}
};


//±È½ÏÀàÐ͵ĺ¯Êý·â×°
template<typename Ty1, typename Ty2= Ty1>
using CompareType = std::function<bool(const Ty1 &, const Ty2 &)>;


//±È½ÏÀຯÊýÀ©Õ¹£¬Ê¹ÓÃСÓں͵ÈÓÚº¯Êý
template<typename Ty1, typename Ty2= Ty1>
struct ExtendLessEqualWrap
{
	typedef bool result_type;
	typedef Ty1 first_argument_type;
	typedef Ty2 second_argument_type;
public:
	CompareType<Ty1, Ty2> funcLT;
	CompareType<Ty1, Ty2> funcEQ;
public:
	explicit ExtendLessEqualWrap(const CompareType<Ty1, Ty2> &o_funcLT,
		const CompareType<Ty1, Ty2> &o_funcEQ)
		:
		funcLT(o_funcLT), funcEQ(o_funcEQ)
	{
	}
	result_type operator()(const first_argument_type &arg1,
		const second_argument_type &arg2) const
	{
		return funcLT(arg1, arg2) || funcEQ(arg1, arg2);
	}
};
template<typename Ty1, typename Ty2= Ty1>
struct ExtendGreaterWrap
{
	typedef bool result_type;
	typedef Ty1 first_argument_type;
	typedef Ty2 second_argument_type;
public:
	CompareType<Ty1, Ty2> funcLT;
	CompareType<Ty1, Ty2> funcEQ;
public:
	explicit ExtendGreaterWrap(const CompareType<Ty1, Ty2> &o_funcLT,
		const CompareType<Ty1, Ty2> &o_funcEQ)
		:
		funcLT(o_funcLT), funcEQ(o_funcEQ)
	{
	}
	result_type operator()(const first_argument_type &arg1,
		const second_argument_type &arg2) const
	{
		return !(funcLT(arg1, arg2) || funcEQ(arg1, arg2));
	}
};
template<typename Ty1, typename Ty2= Ty1>
struct ExtendGreaterEqualWrap
{
	typedef bool result_type;
	typedef Ty1 first_argument_type;
	typedef Ty2 second_argument_type;
public:
	CompareType<Ty1, Ty2> funcLT;
	CompareType<Ty1, Ty2> funcEQ;
public:
	explicit ExtendGreaterEqualWrap(const CompareType<Ty1, Ty2> &o_funcLT,
		const CompareType<Ty1, Ty2> &o_funcEQ)
		:
		funcLT(o_funcLT), funcEQ(o_funcEQ)
	{
	}
	result_type operator()(const first_argument_type &arg1,
		const second_argument_type &arg2) const
	{
		return !funcLT(arg1, arg2);
	}
};
template<typename Ty1, typename Ty2= Ty1>
struct ExtendNotEqualToWrap
{
	typedef bool result_type;
	typedef Ty1 first_argument_type;
	typedef Ty2 second_argument_type;
public:
	CompareType<Ty1, Ty2> funcLT;
	CompareType<Ty1, Ty2> funcEQ;
public:
	explicit ExtendNotEqualToWrap(const CompareType<Ty1, Ty2> &o_funcLT,
		const CompareType<Ty1, Ty2> &o_funcEQ)
		:
		funcLT(o_funcLT), funcEQ(o_funcEQ)
	{
	}
	result_type operator()(const first_argument_type &arg1,
		const second_argument_type &arg2) const
	{
		return !funcEQ(arg1, arg2);
	}
};



//´æ´¢Ä³ÀàÐÍ£¬¿ÉÒÔΪֵ»òÒýÓ㬶Ը÷ÖÖÇé¿öÒѽøÐÐÌØ»¯
//ÖµÀàÐÍÌØ»¯
template<typename Ty>
struct TypeHolder
{
	Ty hold;
public:
	//¹¹Ôì
	TypeHolder(const Ty &o_hold):
		hold(o_hold)
	{
	}
	TypeHolder(Ty &&o_hold):
		hold(std::move(o_hold))
	{
	}
};
//×óÖµÒýÓÃÌØ»¯
template<typename Ty>
struct TypeHolder<Ty &>
{
	Ty &hold;
public:
	//¹¹Ôì
	TypeHolder(Ty &o_hold):
		hold(o_hold)
	{
	}
};
//ÓÒÖµÒýÓÃÌØ»¯
template<typename Ty>
struct TypeHolder<Ty &&>
{
	Ty &&hold;
public:
	//¹¹Ôì
	TypeHolder(Ty &&o_hold):
		hold(std::move(o_hold))
	{
	}
};



//´æ´¢Ä³ÖµÀàÐÍ£¬²»ÄÜΪÒýÓã¬ÀàÐÍÖ§³Övoid
template<typename Ty>
struct ValueHolder
{
public:
	using RefType = Ty &;
	using ConstRefType = const Ty &;
	using PtrType = Ty *;
	using ConstPtrType = const Ty *;
public:
	Ty hold;
public:
	//Ä£°å¹¹Ôì
	template<typename ...Ty_S>
	explicit ValueHolder(Ty_S &&...args):
		hold(std::forward<Ty_S>(args)...)
	{
	}
};
//voidÌØ»¯
template<>
struct ValueHolder<void>
{
	using RefType = void;
	using ConstRefType = void;
	using PtrType = void;
	using ConstPtrType = void;
};



//**********************
//ÀàÐͳÉÔ±»ò¸¨Öúº¯ÊýÀ©Õ¹
//**********************

//µ÷ÓñäÁ¿µÄÎö¹¹º¯Êý
template<typename Ty>
inline void CallDestruct(Ty &value)
{
	value.~Ty();
}

//µ÷ÓñäÁ¿µÄ¹¹Ô캯Êý£¬ÒªÇó±äÁ¿ÒѾ­Îö¹¹
template<typename Ty, typename ...Ty_S>
inline void CallConstruct(Ty &value, Ty_S &&...arg_s)
{
	new(&value) Ty(std::forward<Ty_S>(arg_s)...);
}

//µ÷ÓñäÁ¿µÄÎö¹¹º¯ÊýºÍ¹¹Ô캯Êý
template<typename Ty, typename ...Ty_S>
inline void CallRestruct(Ty &value, Ty_S &&...arg_s)
{
	CallDestruct(value);
	CallConstruct(value, std::forward<Ty_S>(arg_s)...);
}



//ÌáÈ¡±äÁ¿µÄ×óÖµÒýÓÃ
template<typename Ty>
inline Ty &GetLref(Ty &&value)
{
	return value;
}
//ÌáÈ¡±äÁ¿µÄ³£×óÖµÒýÓÃ
template<typename Ty>
inline const Ty &GetConstLref(Ty &&value)
{
	return value;
}


//¶Ô±äÁ¿½øÐÐÖµ¿½±´
template<typename Ty>
inline Ty GetValueCopy(const Ty &value)
{
	return Ty(value);
}



//c·ç¸ñ×Ö·û´®×ª»¯×Ö·û´®£¬×Ö·ûÖ¸ÕëÖØÔØ
inline std::string OverrideSzToStr(const char *sz)
{
	return std::string(sz);
}
inline std::string OverrideSzToStr(char *sz)
{
	return std::string(sz);
}
//c·ç¸ñ×Ö·û´®×ª»¯×Ö·û´®£¬×Ö·ûÊý×éÖØÔØ
template<typename Ty>
inline typename std::enable_if<std::is_array<typename RemoveCVRef<Ty>::type>::value
	&& IsRemoveCVRefSame<char, typename std::remove_extent<
	typename RemoveCVRef<Ty>::type>::type>::value, std::string
>::type OverrideSzToStr(Ty &&sz)
{
	return std::string(std::forward<Ty>(sz));
}
//c·ç¸ñ×Ö·û´®×ª»¯×Ö·û´®£¬ÆäÓàÇé¿öÖØÔØ
template<typename Ty>
inline Ty &&OverrideSzToStr(Ty &&arg)
{
	return std::forward<Ty>(arg);
}



//ÕûÐαȽϸ¨Öúºê
#define _IS_INT_TYPE(Ty1, Ty2) \
 (std::is_integral<Ty1>::value && std::is_integral<Ty2>::value)
#define _INT_SIGN_UNSIGN(Ty1, Ty2) \
	((std::is_integral<Ty1>::value && std::is_signed<Ty1>::value)\
	&& std::is_unsigned<Ty2>::value)

//ÕûÐÎÀàÐÍ°²È«ÅжÏСÓÚ
template<typename Ty1, typename Ty2>
inline constexpr typename std::enable_if<_INT_SIGN_UNSIGN(Ty1, Ty2), bool
>::type IntLT(Ty1 num1, Ty2 num2)
{
	return (num1<0) ? (true)
		: (static_cast<typename std::make_unsigned<Ty1>::type>(num1)<num2);
}
template<typename Ty1, typename Ty2>
inline constexpr typename std::enable_if<_INT_SIGN_UNSIGN(Ty2, Ty1), bool
>::type IntLT(Ty1 num1, Ty2 num2)
{
	return (num2<0) ? (false)
		: (num1<static_cast<typename std::make_unsigned<Ty2>::type>(num2));
}
template<typename Ty1, typename Ty2>
inline constexpr typename std::enable_if<_IS_INT_TYPE(Ty1, Ty2)
	&& !_INT_SIGN_UNSIGN(Ty1, Ty2) && !_INT_SIGN_UNSIGN(Ty2, Ty1), bool
>::type IntLT(Ty1 num1, Ty2 num2)
{
	return num1<num2;
}

//ÕûÐÎÀàÐÍ°²È«ÅжϵÈÓÚ
template<typename Ty1, typename Ty2>
inline constexpr typename std::enable_if<_INT_SIGN_UNSIGN(Ty1, Ty2), bool
>::type IntEQ(Ty1 num1, Ty2 num2)
{
	return (num1<0) ? (false)
		: (static_cast<typename std::make_unsigned<Ty1>::type>(num1)==num2);
}
template<typename Ty1, typename Ty2>
inline constexpr typename std::enable_if<_INT_SIGN_UNSIGN(Ty2, Ty1), bool
>::type IntEQ(Ty1 num1, Ty2 num2)
{
	return (num2<0) ? (false)
		: (num1==static_cast<typename std::make_unsigned<Ty2>::type>(num2));
}
template<typename Ty1, typename Ty2>
inline constexpr typename std::enable_if<_IS_INT_TYPE(Ty1, Ty2)
	&& !_INT_SIGN_UNSIGN(Ty1, Ty2) && !_INT_SIGN_UNSIGN(Ty2, Ty1), bool
>::type IntEQ(Ty1 num1, Ty2 num2)
{
	return num1==num2;
}

//ÕûÐÎÀàÐÍ°²È«ÅжÏСÓÚµÈÓÚ
template<typename Ty1, typename Ty2>
inline constexpr typename std::enable_if<_IS_INT_TYPE(Ty1, Ty2), bool
>::type IntLTE(Ty1 num1, Ty2 num2)
{
	return IntLT(num1, num2) || IntEQ(num1, num2);
}

//ÕûÐÎÀàÐÍ°²È«ÅжϴóÓÚ
template<typename Ty1, typename Ty2>
inline constexpr typename std::enable_if<_IS_INT_TYPE(Ty1, Ty2), bool
>::type IntGT(Ty1 num1, Ty2 num2)
{
	return !(IntLT(num1, num2) || IntEQ(num1, num2));
}

//ÕûÐÎÀàÐÍ°²È«ÅжϴóÓÚµÈÓÚ
template<typename Ty1, typename Ty2>
inline constexpr typename std::enable_if<_IS_INT_TYPE(Ty1, Ty2), bool
>::type IntGTE(Ty1 num1, Ty2 num2)
{
	return !IntLT(num1, num2);
}

//ÕûÐÎÀàÐÍ°²È«Åжϲ»µÈÓÚ
template<typename Ty1, typename Ty2>
inline constexpr typename std::enable_if<_IS_INT_TYPE(Ty1, Ty2), bool
>::type IntNEQ(Ty1 num1, Ty2 num2)
{
	return !IntEQ(num1, num2);
}
#undef _IS_INT_TYPE
#undef _INT_SIGN_UNSIGN



//¸¡µãÊý±È½Ï¸¨Öúºê
#define _FLOAT_DEFAULT_ULP 10
#define _FLOAT_DEFAULT_ABS_MODE true
#define _IS_FLOAT_TYPE(Ty1, Ty2) \
	(std::is_floating_point<Ty1>::value && std::is_floating_point<Ty2>::value)
#define _FLOAT_COMMON_EPSILON(Ty1, Ty2) \
	(std::max(std::numeric_limits<Ty1>::epsilon(), std::numeric_limits<Ty2>::epsilon()))
#define _FLOAT_COMMON_MIN(Ty1, Ty2) \
	(std::max(std::numeric_limits<Ty1>::min(), std::numeric_limits<Ty2>::min()))
#define _FLOAT_ABS(num) ((num)>=0? (num):-(num))

//¸¡µãÊý±È½ÏÏàµÈ£¬±£Ö¤Âß¼­¹Øϵ
template<typename Ty1, typename Ty2>
inline constexpr typename std::enable_if<_IS_FLOAT_TYPE(Ty1, Ty2), bool
>::type FloatEQ(Ty1 num1, Ty2 num2, bool bAbs= _FLOAT_DEFAULT_ABS_MODE, int ulp= _FLOAT_DEFAULT_ULP)
{
	return bAbs ?
		(_FLOAT_ABS(num1-num2)<_FLOAT_COMMON_EPSILON(Ty1, Ty2)*ulp)
		:
		(_FLOAT_ABS(num1-num2)<_FLOAT_COMMON_EPSILON(Ty1, Ty2)
		*(_FLOAT_ABS(num1)+_FLOAT_ABS(num2))*ulp
		|| _FLOAT_ABS(num1-num2)<_FLOAT_COMMON_MIN(Ty1, Ty2)*ulp);
}

//¸¡µãÊý±È½ÏСÓÚ£¬±£Ö¤Âß¼­¹Øϵ
template<typename Ty1, typename Ty2>
inline constexpr typename std::enable_if<_IS_FLOAT_TYPE(Ty1, Ty2), bool
>::type FloatLT(Ty1 num1, Ty2 num2, bool bAbs= _FLOAT_DEFAULT_ABS_MODE, int ulp= _FLOAT_DEFAULT_ULP)
{
	return num1<num2 && !FloatEQ(num1, num2, bAbs, ulp);
}

//¸¡µãÊý±È½ÏСÓÚµÈÓÚ£¬±£Ö¤Âß¼­¹Øϵ
template<typename Ty1, typename Ty2>
inline constexpr typename std::enable_if<_IS_FLOAT_TYPE(Ty1, Ty2), bool
>::type FloatLTE(Ty1 num1, Ty2 num2, bool bAbs= _FLOAT_DEFAULT_ABS_MODE, int ulp= _FLOAT_DEFAULT_ULP)
{
	return FloatLT(num1, num2, bAbs, ulp) || FloatEQ(num1, num2, bAbs, ulp);
}

//¸¡µãÊý±È½Ï´óÓÚ£¬±£Ö¤Âß¼­¹Øϵ
template<typename Ty1, typename Ty2>
inline constexpr typename std::enable_if<_IS_FLOAT_TYPE(Ty1, Ty2), bool
>::type FloatGT(Ty1 num1, Ty2 num2, bool bAbs= _FLOAT_DEFAULT_ABS_MODE, int ulp= _FLOAT_DEFAULT_ULP)
{
	return !(FloatLT(num1, num2, bAbs, ulp) || FloatEQ(num1, num2, bAbs, ulp));
}

//¸¡µãÊý±È½Ï´óÓÚµÈÓÚ£¬±£Ö¤Âß¼­¹Øϵ
template<typename Ty1, typename Ty2>
inline constexpr typename std::enable_if<_IS_FLOAT_TYPE(Ty1, Ty2), bool
>::type FloatGTE(Ty1 num1, Ty2 num2, bool bAbs= _FLOAT_DEFAULT_ABS_MODE, int ulp= _FLOAT_DEFAULT_ULP)
{
	return !FloatLT(num1, num2, bAbs, ulp);
}

//¸¡µãÊý±È½Ï²»µÈÓÚ£¬±£Ö¤Âß¼­¹Øϵ
template<typename Ty1, typename Ty2>
inline constexpr typename std::enable_if<_IS_FLOAT_TYPE(Ty1, Ty2), bool
>::type FloatNEQ(Ty1 num1, Ty2 num2, bool bAbs= _FLOAT_DEFAULT_ABS_MODE, int ulp= _FLOAT_DEFAULT_ULP)
{
	return !FloatEQ(num1, num2, bAbs, ulp);
}


//¸¡µãÊýÏÂת»¯ÕûÊý
template<typename Ty>
inline typename std::enable_if<std::is_floating_point<Ty>::value, Ty
>::type FloatFloor(Ty num, bool bAbs= _FLOAT_DEFAULT_ABS_MODE, int ulp= _FLOAT_DEFAULT_ULP)
{
	Ty res = std::round(num);
	if(FloatEQ(num, res, bAbs, ulp))
		return res;
	return std::floor(num);
}

//¸¡µãÊýÉÏת»¯ÕûÊý
template<typename Ty>
inline typename std::enable_if<std::is_floating_point<Ty>::value, Ty
>::type FloatCeil(Ty num, bool bAbs= _FLOAT_DEFAULT_ABS_MODE, int ulp= _FLOAT_DEFAULT_ULP)
{
	Ty res = std::round(num);
	if(FloatEQ(num, res, bAbs, ulp))
		return res;
	return std::ceil(num);
}
#undef _FLOAT_DEFAULT_ULP
#undef _IS_FLOAT_TYPE
#undef _FLOAT_COMMON_EPSILON
#undef _FLOAT_COMMON_MIN
#undef _FLOAT_ABS



//stringµÄÀÛ¼Ó²Ù×÷£¬Ê¹ÓÃ×óÒÆÔËËã·û
template<typename Ele, typename Ty>
inline std::string &operator <<(std::basic_string<Ele> &str, Ty &&arg)
{
	return str += std::forward<Ty>(arg);
}



//·¶Î§ÄÚ×ÖµäÐò±È½Ï²Ù×÷£¬Ê¹Óõü´úÆ÷£¬Ð¡ÓÚµÈÓÚ´óÓڷֱ𷵻Ø-1,0,1
template<typename TyIt1, typename TyIt2,
	typename TyLess= GeneralLess<typename IteratorRemoveCVRefDerefType<TyIt1>::type,
	typename IteratorRemoveCVRefDerefType<TyIt2>::type>,
	typename TyEqual= GeneralEqualTo<typename IteratorRemoveCVRefDerefType<TyIt1>::type,
	typename IteratorRemoveCVRefDerefType<TyIt2>::type>
> inline int SequenceCompare(TyIt1 st1, TyIt1 ed1, TyIt2 st2, TyIt2 ed2,
	TyLess funcLess= TyLess(), TyEqual funcEqual= TyEqual())
{
	for(; ; ++st1, ++st2) {
		//ÅжϽáÊøÌõ¼þ
		if(st1==ed1) {
			if(st2==ed2)
				return 0;
			else
				return -1;
		}
		else if(st2==ed2)
			return 1;
		//ÅжϴóС
		if(funcLess(*st1, *st2))
			return -1;
		else if(!(funcEqual(*st1, *st2)))
			return 1;
	}
}



//¼ì²éÊÇ·ñΪtupleÀà
template<typename Ty>
struct IsTupleType:
	std::false_type
{
};
template<typename ...Ty_S>
struct IsTupleType<std::tuple<Ty_S...>>:
	std::true_type
{
};


//tupleÀàÐÍת»»À©Õ¹¸¨Öúº¯Êý
template<typename TyDst, typename TySrc, size_t ...c_idx_s>
inline TyDst _TupleCastAssist(TySrc &&src, IndexSequence<c_idx_s...>)
{
	return TyDst(std::get<c_idx_s>(std::forward<TySrc>(src))...);
}
//tupleÀàÐÍת»»À©Õ¹£¬Ö±½ÓÍêÃÀת·¢ÒÔÖ§³ÖËùÓеÄÒýÓÃÇé¿ö£¬ÈôÐèÓÒÖµÔò½«tupleÒÔÓÒÖµ´«Èë
//Ô´ÀàÐÍÐèÒªÄܱ»getº¯Êý²ð½â£¬Ä¿µÄÀàÐÍÐèÒªÄܽÓÊÜÔ´ÀàÐͲð½âºóµÄ¹¹Ô캯Êý
template<typename TyDst, typename TySrc>
inline TyDst TupleCast(TySrc &&src)
{
	return _TupleCastAssist<TyDst>(std::forward<TySrc>(src), MakeIndexSequence<
		std::tuple_size<typename std::remove_reference<TySrc>::type>::value>());
}



//tupleÀàÐ͵÷Óú¯Êý·µ»ØÖµÀàÐ͸¨ÖúÀàÐÍ
template<typename TyFunc, typename TyTup, typename TyIdx>
struct _TupleInvokeReturnTypeAssist
{
};
template<typename TyFunc, typename TyTup, size_t ...c_idx_s>
struct _TupleInvokeReturnTypeAssist<TyFunc, TyTup, IndexSequence<c_idx_s...>>
{
	using type = decltype(std::declval<TyFunc>()(std::get<c_idx_s>(std::declval<TyTup>())...));
};
//tupleÀàÐ͵÷Óú¯Êý·µ»ØÖµÀàÐÍ£¬Ê¹ÓôøcvrefµÄÀàÐÍ´«Èë
template<typename TyFunc, typename TyTup>
struct TupleInvokeReturnType
{
	using type = typename _TupleInvokeReturnTypeAssist<TyFunc, TyTup, MakeIndexSequence<
		std::tuple_size<typename std::remove_reference<TyTup>::type>::value>>::type;
};

//tupleÀàÐ͵÷Óú¯Êý¸¨Öúº¯Êý
template<typename TyFunc, typename TyTup, size_t ...c_idx_s>
inline typename TupleInvokeReturnType<TyFunc &&, TyTup &&
>::type _TupleInvokeAssist(TyFunc &&func, TyTup &&tup, IndexSequence<c_idx_s...>)
{
	return std::forward<TyFunc>(func)(std::get<c_idx_s>(std::forward<TyTup>(tup))...);
}
//tupleÀàÐ͵÷Óú¯Êý£¬±¾ÖÊÉÏÖ»ÒªÄܱ»getº¯Êý²ð½â¼´¿É£¬ÈôÐèÓÒÖµÔò½«tupleÒÔÓÒÖµ´«Èë
template<typename TyFunc, typename TyTup>
inline typename TupleInvokeReturnType<TyFunc &&, TyTup &&
>::type TupleInvoke(TyFunc &&func, TyTup &&tup)
{
	return _TupleInvokeAssist(std::forward<TyFunc>(func), std::forward<TyTup>(tup),
		MakeIndexSequence<std::tuple_size<typename std::remove_reference<TyTup>::type>::value>());
}



//hashµ÷Óú¯Êý
template<typename Ty>
inline auto HashFunc(Ty &&arg)->
decltype(std::hash<typename RemoveCVRef<Ty>::type>()(std::forward<Ty>(arg)))
{
	return std::hash<typename RemoveCVRef<Ty>::type>()(std::forward<Ty>(arg));
}


//hashµÄÌØÀý»¯
namespace std
{
//¶ÔpairÌØÀý»¯£¬Ã»Óн»»»²»±äÐÔ£¬Óëtuple¼æÈÝ
template<typename Ty1, typename Ty2>
struct hash<std::pair<Ty1, Ty2>>
{
	typedef size_t result_type;
	typedef std::pair<Ty1, Ty2> argument_type;
	result_type operator()(const argument_type &pr) const
	{
		return HashFunc(HashFunc(pr.first))
			^ HashFunc(pr.second);
	}
};

//¶ÔtupleÌØÀý»¯£¬Ã»Óн»»»²»±äÐÔ
template<typename ...Tys>
struct hash<std::tuple<Tys...>>
{
	typedef size_t result_type;
	typedef std::tuple<Tys...> argument_type;
	result_type operator()(const argument_type &tup) const
	{
		return Assist<sizeof...(Tys)>(tup);
	}
private:
	template<size_t c_index>
	static typename std::enable_if<c_index>=2, result_type
	>::type Assist(const std::tuple<Tys...> &tup)
	{
		return HashFunc(Assist<c_index-1>(tup))
			^ HashFunc(std::get<c_index-1>(tup));
	}
	template<size_t c_index>
	static typename std::enable_if<c_index==1, result_type
	>::type Assist(const std::tuple<Tys...> &tup)
	{
		return HashFunc(std::get<0>(tup));
	}
	template<size_t c_index>
	static typename std::enable_if<c_index==0, result_type
	>::type Assist(const std::tuple<Tys...> &tup)
	{
		return 0;
	}
};
}


//¸÷Ààµü´úÆ÷hashÀ࣬βºóµü´úÆ÷½âÒýÓò»°²È«
template<typename Ty>
struct IteratorHash
{
	typedef size_t result_type;
	typedef Ty argument_type;
	result_type operator()(argument_type it) const
	{
		return std::hash<decltype(&*it)>()(&*it);
	}
};



//¸÷Ààµü´úÆ÷±È½ÏÀ࣬βºóµü´úÆ÷½âÒýÓò»°²È«
template<typename Ty>
struct IteratorLess
{
	typedef bool result_type;
	typedef Ty first_argument_type;
	typedef Ty second_argument_type;
	result_type operator()(const first_argument_type &it1,
		const second_argument_type &it2) const
	{
		return &*it1<&*it2;
	}
};
template<typename Ty>
struct IteratorEuqalTo
{
	typedef bool result_type;
	typedef Ty first_argument_type;
	typedef Ty second_argument_type;
	result_type operator()(const first_argument_type &it1,
		const second_argument_type &it2) const
	{
		return &*it1==&*it2;
	}
};


//¸÷Ààµü´úÆ÷½âÒýÓÃÖµ±È½ÏÀà
template<typename Ty>
struct IteratorDerefLess
{
	typedef bool result_type;
	typedef Ty first_argument_type;
	typedef Ty second_argument_type;
	result_type operator()(const first_argument_type &it1,
		const second_argument_type &it2) const
	{
		return *it1<*it2;
	}
};
template<typename Ty>
struct IteratorDerefEuqalTo
{
	typedef bool result_type;
	typedef Ty first_argument_type;
	typedef Ty second_argument_type;
	result_type operator()(const first_argument_type &it1,
		const second_argument_type &it2) const
	{
		return *it1==*it2;
	}
};



//×Ö·ûÊý×ÖÅжÏ
inline constexpr bool IsNumChar(char ch)
{
	return ch>='0' && ch<='9';
}
inline constexpr bool IsNotNumChar(char ch)
{
	return !IsNumChar(ch);
}
//×Ö·û´óд×ÖĸÅжÏ
inline constexpr bool IsUppChar(char ch)
{
	return (ch>='A' && ch<='Z');
}
inline constexpr bool IsNotUppChar(char ch)
{
	return !IsUppChar(ch);
}
//×Ö·û´óд×ÖĸÅжÏ
inline constexpr bool IsLowChar(char ch)
{
	return (ch>='a' && ch<='z');
}
inline constexpr bool IsNotLowChar(char ch)
{
	return !IsLowChar(ch);
}
//×Ö·û×ÖĸÅжÏ
inline constexpr bool IsLetChar(char ch)
{
	return IsUppChar(ch) || IsLowChar(ch);
}
inline constexpr bool IsNotLetChar(char ch)
{
	return !IsLetChar(ch);
}
//×Ö·ûÊý×Ö×ÖĸÅжÏ
inline constexpr bool IsNumLetChar(char ch)
{
	return IsNumChar(ch) || IsLetChar(ch);
}
inline constexpr bool IsNotNumLetChar(char ch)
{
	return !IsNumLetChar(ch);
}
//×Ö·û±êʶ·ûÅжÏ
inline constexpr bool IsIdChar(char ch)
{
	return IsNumLetChar(ch) || (ch=='_');
}
inline constexpr bool IsNotIdChar(char ch)
{
	return !IsIdChar(ch);
}
//×Ö·ûÊ®Áù½øÖÆÅжÏ
inline constexpr bool IsHexChar(char ch)
{
	return (ch>='0' && ch<='9')
		|| (ch>='a' && ch<='f') || (ch>='A' && ch<='F');
}
inline constexpr bool IsNotHexChar(char ch)
{
	return !IsHexChar(ch);
}
//×Ö·ûasciiÅжÏ
inline constexpr bool IsAsciiChar(char ch)
{
	return ch>=0x00 && ch<=0x7F;
}
inline constexpr bool IsNotAsciiChar(char ch)
{
	return !IsAsciiChar(ch);
}
//×Ö·û¹ãÒå±êʶ·ûÅжÏ
inline constexpr bool IsBroadIdChar(char ch)
{
	return IsIdChar(ch) || IsNotAsciiChar(ch);
}
inline constexpr bool IsNotBroadIdChar(char ch)
{
	return !IsBroadIdChar(ch);
}
//×Ö·û¿Õ°×·ûÅжÏ
inline constexpr bool IsBlankChar(char ch)
{
	return ch==' ' || ch=='\t' || ch=='\r' || ch=='\n'
		|| ch=='\v' || ch=='\f';
}
inline constexpr bool IsNotBlankChar(char ch)
{
	return !IsBlankChar(ch);
}


//Сд×Öĸת»»´óд×Öĸ
inline constexpr char LowCharToUppChar(char ch)
{
	return (char)
		(IsLowChar(ch) ?
		'A'+(ch-'a')
		:
		ch);
}
//´óд×ÖĸתСд×Öĸ
inline constexpr char UppCharToLowChar(char ch)
{
	return (char)
		(IsUppChar(ch) ?
		'a'+(ch-'A')
		:
		ch);
}


//Êý×Ö×Ö·ûת»¯Êý×Ö
inline constexpr int NumCharToNum(char ch)
{
	return IsNumChar(ch) ?
		ch-'0'
		:
		-1;
}
//×Öĸ×Ö·ûת»¯Êý×Ö
inline constexpr int LetCharToNum(char ch)
{
	return IsLowChar(ch) ?
		ch-'a'
		: IsUppChar(ch) ?
		ch-'A'
		:
		-1;
}
//Ê®Áù½øÖÆ×Ö·ûת»¯Êý×Ö
inline constexpr int HexCharToNum(char ch)
{
	return (ch>='0' && ch<='9') ?
		ch-'0'
		: (ch>='a' && ch<='f') ?
		ch-'a'+10
		: (ch>='A' && ch<='F') ?
		ch-'A'+10
		:
		-1;
}


//Êý×Öת»¯Êý×Ö×Ö·û
inline constexpr char NumToNumChar(int i)
{
	return (char)
		((i>=0 && i<=9) ?
		i+'0'
		:
		0);
}
//Êý×Öת»¯´óд×Öĸ×Ö·û
inline constexpr char NumToUppChar(int i)
{
	return (char)
		((i>=0 && i<=25) ?
		i+'A'
		:
		0);
}
//Êý×Öת»¯Ð¡Ð´×Öĸ×Ö·û
inline constexpr char NumToLowChar(int i)
{
	return (char)
		((i>=0 && i<=25) ?
		i+'a'
		:
		0);
}
//Êý×Öת»¯´óдʮÁù½øÖÆ×Ö·û
inline constexpr char NumToUppHexChar(int i)
{
	return (char)
		((i>=0 && i<=9) ?
		i+'0'
		: (i>=10 && i<=15) ?
		i+'A'
		:
		0);
}
//Êý×Öת»¯Ð¡Ð´Ê®Áù½øÖÆ×Ö·û
inline constexpr char NumToLowHexChar(int i)
{
	return (char)
		((i>=0 && i<=9) ?
		i+'0'
		: (i>=10 && i<=15) ?
		i+'a'
		:
		0);
}