//Containers
#include <array>
#include <deque>
#include <forward_list>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <stack>
#include <unordered_map>
#include <unordered_set>
#include <vector>
//Input/Output
#include <iostream>
//Other
#include <algorithm>
#include <bitset>
#include <chrono>
#include <complex>
#include <exception>
#include <functional>
#include <initializer_list>
#include <iterator>
#include <limits>
#include <locale>
#include <memory>
#include <new>
#include <numeric>
#include <random>
#include <ratio>
#include <regex>
#include <stdexcept>
#include <string>
#include <system_error>
#include <tuple>
#include <typeindex>
#include <typeinfo>
#include <utility>
#include <valarray>
#if 1 // Not in C++11
template <std::size_t...> struct index_sequence {};
template <std::size_t N, std::size_t... Is>
struct make_index_sequence : make_index_sequence<N - 1, N - 1, Is...> {};
template <std::size_t... Is>
struct make_index_sequence<0u, Is...> : index_sequence<Is...> {};
#endif
namespace detail
{
template<typename T>
void debug(const std::string& name, const T& t)
{
std::cout << name << ": " << t << std::endl;
}
template<typename T>
void debug(const std::string& name, const std::stack<T>& a) {
auto t = a;
int i = 0;
while(!t.empty()){
std::cout << name << "[" << i << "]: " << t.top() << std::endl;
t.pop();
i++;
}
}
template<typename T>
void debug(const std::string& name, const std::queue<T>& a) {
auto t = a;
int i = 0;
while(!t.empty()){
std::cout << name << "[" << i << "]: " << t.front() << std::endl;
t.pop();
i++;
}
}
template<typename K, typename V>
void debug(const std::string& /*name*/, const std::map<K, V>& m){
for (const auto & p : m) {
std::cout << p.first << " => " << p.second << std::endl;
}
}
template<typename T>
void debug(const std::string& name, std::vector<T>& c) {
std::size_t i = 0;
for (const auto& e : c)
std::cout << name << "[" << i++ << "]: " << e << std::endl;
}
template<typename T>
void debug(const std::string& name, std::set<T>& c) {
std::size_t i = 0;
for (const auto& e : c)
std::cout << name << "[" << i++ << "]: " << e << std::endl;
}
template<typename T>
void debug(const std::string& name, std::list<T>& c) {
std::size_t i = 0;
for (const auto& e : c)
std::cout << name << "[" << i++ << "]: " << e << std::endl;
}
template<typename T>
void debug(const std::string& name, std::forward_list<T>& c) {
std::size_t i = 0;
for (const auto& e : c)
std::cout << name << "[" << i++ << "]: " << e << std::endl;
}
template<typename T>
void debug(const std::string& name, std::deque<T>& c) {
std::size_t i = 0;
for (const auto& e : c)
std::cout << name << "[" << i++ << "]: " << e << std::endl;
}
template <typename Tuple, std::size_t ... Is>
void debug(const std::vector<std::string>& names, const Tuple& t, index_sequence<Is...>)
{
std::initializer_list<int>{(debug(names[Is], std::get<Is>(t)), 0)...};
}
template<typename ... Ts>
void dispatch(const char* namesWithComma, std::tuple<Ts...> const& args){
std::vector<std::string> names;
std::istringstream is(namesWithComma);
for (std::string name; getline(is, name, ',');){
names.push_back(name);
}
detail::debug(names, args, make_index_sequence<sizeof...(Ts)>());
}
}
#define debug(...) detail::dispatch(#__VA_ARGS__, std::tie(__VA_ARGS__))
int main(){
int a = 1;
float b = 2;
std::vector<int> c{3};
std::deque<int> d{4};
std::stack<float> e; e.push(5);
std::queue<double> f; f.push(6);
std::map<char,int> g{{'g', 7}};
std::forward_list<int> h{8};
std::set<int> i{9};
debug(a,b,c,d,e,f,g,h,i);
return 0;
}
Ly9Db250YWluZXJzCiNpbmNsdWRlIDxhcnJheT4KI2luY2x1ZGUgPGRlcXVlPgojaW5jbHVkZSA8Zm9yd2FyZF9saXN0PgojaW5jbHVkZSA8bGlzdD4KI2luY2x1ZGUgPG1hcD4KI2luY2x1ZGUgPHF1ZXVlPgojaW5jbHVkZSA8c2V0PgojaW5jbHVkZSA8c3RhY2s+CiNpbmNsdWRlIDx1bm9yZGVyZWRfbWFwPgojaW5jbHVkZSA8dW5vcmRlcmVkX3NldD4KI2luY2x1ZGUgPHZlY3Rvcj4KCi8vSW5wdXQvT3V0cHV0CiNpbmNsdWRlIDxpb3N0cmVhbT4KCi8vT3RoZXIKI2luY2x1ZGUgPGFsZ29yaXRobT4KI2luY2x1ZGUgPGJpdHNldD4KI2luY2x1ZGUgPGNocm9ubz4KI2luY2x1ZGUgPGNvbXBsZXg+CiNpbmNsdWRlIDxleGNlcHRpb24+CiNpbmNsdWRlIDxmdW5jdGlvbmFsPgojaW5jbHVkZSA8aW5pdGlhbGl6ZXJfbGlzdD4KI2luY2x1ZGUgPGl0ZXJhdG9yPgojaW5jbHVkZSA8bGltaXRzPgojaW5jbHVkZSA8bG9jYWxlPgojaW5jbHVkZSA8bWVtb3J5PgojaW5jbHVkZSA8bmV3PgojaW5jbHVkZSA8bnVtZXJpYz4KI2luY2x1ZGUgPHJhbmRvbT4KI2luY2x1ZGUgPHJhdGlvPgojaW5jbHVkZSA8cmVnZXg+CiNpbmNsdWRlIDxzdGRleGNlcHQ+CiNpbmNsdWRlIDxzdHJpbmc+CiNpbmNsdWRlIDxzeXN0ZW1fZXJyb3I+CiNpbmNsdWRlIDx0dXBsZT4KI2luY2x1ZGUgPHR5cGVpbmRleD4KI2luY2x1ZGUgPHR5cGVpbmZvPgojaW5jbHVkZSA8dXRpbGl0eT4KI2luY2x1ZGUgPHZhbGFycmF5PgoKI2lmIDEgLy8gTm90IGluIEMrKzExCgp0ZW1wbGF0ZSA8c3RkOjpzaXplX3QuLi4+IHN0cnVjdCBpbmRleF9zZXF1ZW5jZSB7fTsKCnRlbXBsYXRlIDxzdGQ6OnNpemVfdCBOLCBzdGQ6OnNpemVfdC4uLiBJcz4Kc3RydWN0IG1ha2VfaW5kZXhfc2VxdWVuY2UgOiBtYWtlX2luZGV4X3NlcXVlbmNlPE4gLSAxLCBOIC0gMSwgSXMuLi4+IHt9OwoKdGVtcGxhdGUgPHN0ZDo6c2l6ZV90Li4uIElzPgpzdHJ1Y3QgbWFrZV9pbmRleF9zZXF1ZW5jZTwwdSwgSXMuLi4+IDogaW5kZXhfc2VxdWVuY2U8SXMuLi4+IHt9OwoKI2VuZGlmCgpuYW1lc3BhY2UgZGV0YWlsCnsKCiAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPgogICAgdm9pZCBkZWJ1Zyhjb25zdCBzdGQ6OnN0cmluZyYgbmFtZSwgY29uc3QgVCYgdCkKICAgIHsKICAgICAgICBzdGQ6OmNvdXQgPDwgbmFtZSA8PCAiOiAiIDw8IHQgPDwgc3RkOjplbmRsOwogICAgfQoKICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQ+CiAgICB2b2lkIGRlYnVnKGNvbnN0IHN0ZDo6c3RyaW5nJiBuYW1lLCBjb25zdCBzdGQ6OnN0YWNrPFQ+JiBhKSB7CiAgICAgICAgYXV0byB0ID0gYTsKICAgICAgICBpbnQgaSA9IDA7CiAgICAgICAgd2hpbGUoIXQuZW1wdHkoKSl7CiAgICAgICAgICAgIHN0ZDo6Y291dCA8PCBuYW1lIDw8ICJbIiA8PCBpIDw8ICJdOiAiIDw8IHQudG9wKCkgPDwgc3RkOjplbmRsOwogICAgICAgICAgICB0LnBvcCgpOwogICAgICAgICAgICBpKys7CiAgICAgICAgfQogICAgfQoKICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQ+CiAgICB2b2lkIGRlYnVnKGNvbnN0IHN0ZDo6c3RyaW5nJiBuYW1lLCBjb25zdCBzdGQ6OnF1ZXVlPFQ+JiBhKSB7CiAgICAgICAgYXV0byB0ID0gYTsKICAgICAgICBpbnQgaSA9IDA7CiAgICAgICAgd2hpbGUoIXQuZW1wdHkoKSl7CiAgICAgICAgICAgIHN0ZDo6Y291dCA8PCBuYW1lIDw8ICJbIiA8PCBpIDw8ICJdOiAiIDw8IHQuZnJvbnQoKSA8PCBzdGQ6OmVuZGw7CiAgICAgICAgICAgIHQucG9wKCk7CiAgICAgICAgICAgIGkrKzsKICAgICAgICB9CiAgICB9CgogICAgdGVtcGxhdGU8dHlwZW5hbWUgSywgdHlwZW5hbWUgVj4KICAgIHZvaWQgZGVidWcoY29uc3Qgc3RkOjpzdHJpbmcmIC8qbmFtZSovLCBjb25zdCBzdGQ6Om1hcDxLLCBWPiYgbSl7CiAgICAgICAgZm9yIChjb25zdCBhdXRvICYgcCA6IG0pIHsKICAgICAgICAgICAgc3RkOjpjb3V0IDw8IHAuZmlyc3QgPDwgIiA9PiAiIDw8IHAuc2Vjb25kIDw8IHN0ZDo6ZW5kbDsKICAgICAgICB9CiAgICB9CgogICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4KICAgIHZvaWQgZGVidWcoY29uc3Qgc3RkOjpzdHJpbmcmIG5hbWUsIHN0ZDo6dmVjdG9yPFQ+JiBjKSB7CiAgICAgICAgc3RkOjpzaXplX3QgaSA9IDA7CiAgICAgICAgZm9yIChjb25zdCBhdXRvJiBlIDogYykKICAgICAgICAgICAgc3RkOjpjb3V0IDw8IG5hbWUgPDwgIlsiIDw8IGkrKyA8PCAiXTogIiA8PCBlIDw8IHN0ZDo6ZW5kbDsKICAgIH0KCiAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPgogICAgdm9pZCBkZWJ1Zyhjb25zdCBzdGQ6OnN0cmluZyYgbmFtZSwgc3RkOjpzZXQ8VD4mIGMpIHsKICAgICAgICBzdGQ6OnNpemVfdCBpID0gMDsKICAgICAgICBmb3IgKGNvbnN0IGF1dG8mIGUgOiBjKQogICAgICAgICAgICBzdGQ6OmNvdXQgPDwgbmFtZSA8PCAiWyIgPDwgaSsrIDw8ICJdOiAiIDw8IGUgPDwgc3RkOjplbmRsOwogICAgfQoKICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQ+CiAgICB2b2lkIGRlYnVnKGNvbnN0IHN0ZDo6c3RyaW5nJiBuYW1lLCBzdGQ6Omxpc3Q8VD4mIGMpIHsKICAgICAgICBzdGQ6OnNpemVfdCBpID0gMDsKICAgICAgICBmb3IgKGNvbnN0IGF1dG8mIGUgOiBjKQogICAgICAgICAgICBzdGQ6OmNvdXQgPDwgbmFtZSA8PCAiWyIgPDwgaSsrIDw8ICJdOiAiIDw8IGUgPDwgc3RkOjplbmRsOwogICAgfQoKICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQ+CiAgICB2b2lkIGRlYnVnKGNvbnN0IHN0ZDo6c3RyaW5nJiBuYW1lLCBzdGQ6OmZvcndhcmRfbGlzdDxUPiYgYykgewogICAgICAgIHN0ZDo6c2l6ZV90IGkgPSAwOwogICAgICAgIGZvciAoY29uc3QgYXV0byYgZSA6IGMpCiAgICAgICAgICAgIHN0ZDo6Y291dCA8PCBuYW1lIDw8ICJbIiA8PCBpKysgPDwgIl06ICIgPDwgZSA8PCBzdGQ6OmVuZGw7CiAgICB9CgogICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4KICAgIHZvaWQgZGVidWcoY29uc3Qgc3RkOjpzdHJpbmcmIG5hbWUsIHN0ZDo6ZGVxdWU8VD4mIGMpIHsKICAgICAgICBzdGQ6OnNpemVfdCBpID0gMDsKICAgICAgICBmb3IgKGNvbnN0IGF1dG8mIGUgOiBjKQogICAgICAgICAgICBzdGQ6OmNvdXQgPDwgbmFtZSA8PCAiWyIgPDwgaSsrIDw8ICJdOiAiIDw8IGUgPDwgc3RkOjplbmRsOwogICAgfQoKICAgIHRlbXBsYXRlIDx0eXBlbmFtZSBUdXBsZSwgc3RkOjpzaXplX3QgLi4uIElzPgogICAgdm9pZCBkZWJ1Zyhjb25zdCBzdGQ6OnZlY3RvcjxzdGQ6OnN0cmluZz4mIG5hbWVzLCBjb25zdCBUdXBsZSYgdCwgaW5kZXhfc2VxdWVuY2U8SXMuLi4+KQogICAgewogICAgICAgIHN0ZDo6aW5pdGlhbGl6ZXJfbGlzdDxpbnQ+eyhkZWJ1ZyhuYW1lc1tJc10sIHN0ZDo6Z2V0PElzPih0KSksIDApLi4ufTsKICAgIH0KCiAgICB0ZW1wbGF0ZTx0eXBlbmFtZSAuLi4gVHM+CiAgICB2b2lkIGRpc3BhdGNoKGNvbnN0IGNoYXIqIG5hbWVzV2l0aENvbW1hLCBzdGQ6OnR1cGxlPFRzLi4uPiBjb25zdCYgYXJncyl7CiAgICAgICAgc3RkOjp2ZWN0b3I8c3RkOjpzdHJpbmc+IG5hbWVzOwogICAgICAgIHN0ZDo6aXN0cmluZ3N0cmVhbSBpcyhuYW1lc1dpdGhDb21tYSk7CiAgICAgICAgZm9yIChzdGQ6OnN0cmluZyBuYW1lOyBnZXRsaW5lKGlzLCBuYW1lLCAnLCcpOyl7CiAgICAgICAgICAgIG5hbWVzLnB1c2hfYmFjayhuYW1lKTsKICAgICAgICB9CiAgICAgICAgZGV0YWlsOjpkZWJ1ZyhuYW1lcywgYXJncywgbWFrZV9pbmRleF9zZXF1ZW5jZTxzaXplb2YuLi4oVHMpPigpKTsKICAgIH0KCn0KCiNkZWZpbmUgZGVidWcoLi4uKSBkZXRhaWw6OmRpc3BhdGNoKCNfX1ZBX0FSR1NfXywgc3RkOjp0aWUoX19WQV9BUkdTX18pKQoKaW50IG1haW4oKXsKICAgIGludCBhID0gMTsKICAgIGZsb2F0IGIgPSAyOwogICAgc3RkOjp2ZWN0b3I8aW50PiBjezN9OwogICAgc3RkOjpkZXF1ZTxpbnQ+IGR7NH07CiAgICBzdGQ6OnN0YWNrPGZsb2F0PiBlOyBlLnB1c2goNSk7CiAgICBzdGQ6OnF1ZXVlPGRvdWJsZT4gZjsgZi5wdXNoKDYpOwogICAgc3RkOjptYXA8Y2hhcixpbnQ+IGd7eydnJywgN319OwogICAgc3RkOjpmb3J3YXJkX2xpc3Q8aW50PiBoezh9OwogICAgc3RkOjpzZXQ8aW50PiBpezl9OwogICAgZGVidWcoYSxiLGMsZCxlLGYsZyxoLGkpOwogICAgcmV0dXJuIDA7Cn0K