template <class T1, class T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
  return os << '{' << p.first << ", " << p.second << '}';
}

template <class T, class = decay_t<decltype(*begin(declval<T>()))>,
          class = enable_if_t<!is_same<T, string>::value>>
ostream &operator<<(ostream &os, const T &c) {
  os << '[';
  for (auto it = c.begin(); it != c.end(); ++it)
    os << &", "[2 * (it == c.begin())] << *it;
  return os << ']';
}
//support up to 5 args
#define _NTH_ARG(_1, _2, _3, _4, _5, _6, N, ...) N
#define _FE_0(_CALL, ...)
#define _FE_1(_CALL, x) _CALL(x)
#define _FE_2(_CALL, x, ...) _CALL(x) _FE_1(_CALL, __VA_ARGS__)
#define _FE_3(_CALL, x, ...) _CALL(x) _FE_2(_CALL, __VA_ARGS__)
#define _FE_4(_CALL, x, ...) _CALL(x) _FE_3(_CALL, __VA_ARGS__)
#define _FE_5(_CALL, x, ...) _CALL(x) _FE_4(_CALL, __VA_ARGS__)
#define FOR_EACH_MACRO(MACRO, ...)                                             \
  _NTH_ARG(dummy, ##__VA_ARGS__, _FE_5, _FE_4, _FE_3, _FE_2, _FE_1, _FE_0)     \
  (MACRO, ##__VA_ARGS__)
//Change output format here
#define out(x) #x " = " << x << "; "
#define dbg(...)                                                              \
  cerr << "Line " << __LINE__ << ": " FOR_EACH_MACRO(out, __VA_ARGS__) << "\n"

#pragma GCC target ("avx2")
#pragma GCC optimization ("O3")
#pragma GCC optimization ("unroll-loops")

#include <bits/stdc++.h>

using namespace std;

typedef long long ll;
#define io ios_base::sync_with_stdio(false);cin.tie(NULL);

// ************************DEBUG START********************************
#ifndef ONLINE_JUDGE  // if ONLINE_JUDGE is not defined (when compiling on our pc, this is true)
//#define cerr cout  // if you want to print to stdout, uncomment this
#include "myprettyprint.hpp" // include myprettyprint.hpp
#else
#define dbg(...) // else, when defined (most modern CP sites have this defined), define dbg(...).
                 // this basically just would do nothing on seeing dbg() and thus no need to remove dbg() while submitting.
#endif
// ************************DEBUG END**********************************

ll my_func(ll a, ll b)
{
    return a*b;
}

void test()
{
    int x=5, y=4;
    string s="Hello";
    vector<int> v={1,2,3,4,5};
    set<int> st={34,45};
    map<int, vector<int> > m;

    for(int i=0;i<3;i++)
    {
        for(int j=0;j<4;j++)
        {
            m[i].push_back(i+j);
        }
    }

    dbg(x, y, s, v, st);
    dbg(m, my_func(3,7));
}

int main()
{
    io;
    ll tests=1;
    //cin>>tests;
    while(tests--)
    {
    	test();
    }
    return 0;
}

Line 43: x = 5; y = 4; s = Hello; v = [1, 2, 3, 4, 5]; st = [34, 45]; 
Line 44: m = [{0, [0, 1, 2, 3]}, {1, [1, 2, 3, 4]}, {2, [2, 3, 4, 5]}]; my_func(3,7) = 21;

#ifdef EPSILON

    #define deb(args...)       cerr << "[ " #args << " ] : " , debug(args);
    #define debx(args...)      (Debugger(" ")),args
    #define debug(args...)     (Debugger()) , args
 
    class Debugger
    {
        public:
        Debugger(const std::string& _separator = ", ") :
        first(true), separator(_separator){}
 
        template<typename ObjectType>
        Debugger& operator , (const ObjectType& v)
        {
            if(!first)
                std::cerr << separator;
            std::cerr << v;
            first = false;
            return *this;
        }
        ~Debugger() {  std::cerr << endl;}
 
        private:
        bool first;
        std::string separator;
    };
 
    template <typename T1, typename T2>
    inline std::ostream& operator << (std::ostream& os, const std::pair<T1, T2>& p)
    {
        return os << "(" << p.first << ", " << p.second << ")";
    }
 
    template<typename T>
    inline std::ostream &operator << (std::ostream & os,const std::vector<T>& v)
    {
        bool first = true;
        os << "[";
        for(unsigned int i = 0; i < v.size(); i++)
        {
            if(!first)
                os << ", ";
            os << v[i];
            first = false;
        }
        return os << "]";
    }
 
    template<typename T>
    inline std::ostream &operator << (std::ostream & os,const std::set<T>& v)
    {
        bool first = true;
        os << "[";
        for (typename std::set<T>::const_iterator ii = v.begin(); ii != v.end(); ++ii)
        {
            if(!first)
                os << ", ";
            os << *ii;
            first = false;
        }
        return os << "]";
    }

    template<typename T>
    inline std::ostream &operator << (std::ostream & os,const std::multiset<T>& v)
    {
        bool first = true;
        os << "[";
        for (typename std::set<T>::const_iterator ii = v.begin(); ii != v.end(); ++ii)
        {
            if(!first)
                os << ", ";
            os << *ii;
            first = false;
        }
        return os << "]";
    }

    template<typename T1, typename T2>
    inline std::ostream &operator << (std::ostream & os,const std::map<T1, T2>& v)
    {
        bool first = true;
        os << "[";
        for (typename std::map<T1, T2>::const_iterator ii = v.begin(); ii != v.end(); ++ii)
        {
            if(!first)
                os << ", ";
            os << *ii ;
            first = false;
        }
        return os << "]";
    }
 
#else

    #define deb(args...)
    #define debx(args...)
    #define debug(args...)

#endif

#define SFINAE(x, ...)             \
    template <class, class = void> \
    struct x : std::false_type {}; \
    template <class T>             \
    struct x<T, std::void_t<__VA_ARGS__>> : std::true_type {}

SFINAE(DefaultIO, decltype(std::cout << std::declval<T &>()));
SFINAE(IsTuple, typename std::tuple_size<T>::type);
SFINAE(Iterable, decltype(std::begin(std::declval<T>())));

template <class T>
constexpr char Space(const T &) {
    return (Iterable<T>::value or IsTuple<T>::value) ? '\n' : ' ';
}

template <auto &os>
struct Writer {
    template <class T>
    void Impl(T const &t) const {
        if constexpr (DefaultIO<T>::value) os << t;
        else if constexpr (Iterable<T>::value) {
            int i = 0;
            for (auto &&x : t) ((i++) ? (os << Space(x), Impl(x)) : Impl(x));
        } else if constexpr (IsTuple<T>::value)
            std::apply([this](auto const &... args) {
                    int i = 0;
                    (((i++) ? (os << ' ', Impl(args)) : Impl(args)), ...);
                }, t);
        else static_assert(IsTuple<T>::value, "No matching type for print");
    }
    template <class F, class... Ts>
    auto &operator()(F const &f, Ts const &... ts) const {
        return Impl(f), ((os << ' ', Impl(ts)), ...), os << '\n', *this;
    }
};

#ifdef DEBUG
    #define debug(args...)                                    \
        {                                                     \
            std::string _s = #args;                           \
            std::replace(_s.begin(), _s.end(), ',', ' ');     \
            std::stringstream _ss(_s);                        \
            std::istream_iterator<std::string> _it(_ss);      \
            std::cerr << "Line " << __LINE__ << "\n";         \
            err(_it, args);                                   \
        }

void err(std::istream_iterator<std::string> it) {
    std::ignore = it;
}

template <typename T, typename... Args>
void err(std::istream_iterator<std::string> it, T a, Args... args) {
    std::cerr << "\033[0;31m" << *it << " = ";
    Writer<std::cerr>{}(a);
    std::cerr << "\033[0m";
    err(++it, args...);
}

    #define ASSERT(...) \
        if (not(__VA_ARGS__)) throw runtime_error(#__VA_ARGS__)
#else
    #define debug(...) 0
    #define ASSERT(...) 0
#endif

1. The SFINAE macro uses, very predictably, SFINAE (Substitution Failure Is Not An Error). For those unfamiliar with SFINAE, I'll try to explain it in an intuitive sense without going into too much detail. SFINAE tries to keep compiling when it gets a substitution failure according to the type system, and we can use the order of priority of compilation to our advantage. The usage here tries to perform a certain action and based on whether that action can be compiled or not, it stores the truth value of whether it failed or not in a struct's type (for instance, if T is an integral type, then DefaultIO<T>::value is true, while IsTuple<T>::value is false, and this will be useful when we implement our Writer class which can print everything that we care about.

2. In the Writer class, using this type information, we determine at compile-time which kind of print we want to implement for each class. For a "trivially-printable" type, we can do stuff pretty easily. For a container, we just print everything recursively using our Writer and we win. For a tuple, using std::apply, we can print stuff in the tuple just like what we would do for a container.

3. Now coming to the debugging part, the debug macro takes the arguments, splits them into tokens, prints the line number, and then calls a function that iterates over all the variables and prints them alongside their name using our Writer.