缺省源

2021/12/06

#define LOCAL
#define STDIO

#include<iostream>
#include<cstdio>
#include<climits>

using namespace std;

namespace IO
{
    #ifdef STDIO
    template<typename type>
    inline void read(type &x)
    {
        x=0;bool flag(0);char ch=getchar();
        while(!isdigit(ch)) flag^=ch=='-',ch=getchar();
        while(isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
        flag?x=-x:0;
    }
    template<typename type>
    inline void write(type x,bool mode=1)
    {
        x<0?x=-x,putchar('-'):0;static short Stack[50],top(0);
        do Stack[++top]=x%10,x/=10;while(x);
        while(top) putchar(Stack[top--]|48);
        mode?putchar('\n'):putchar(' ');
    }
    #endif
    signed _()
    {
        #ifndef STDIO
        ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
        #endif
        #ifndef LOCAL
        freopen(".in","r",stdin);
        freopen(".out","w",stdout);
        #endif
    }
    signed __=_();
}
using namespace IO;

#define ll long long
#define maxn 



signed solve()
{
    
}

signed _=solve();
signed main(){return 0;}

2022/10/14

#define LOCAL
#include<iostream>
#include<cstdio>
#include<climits>
#define ll long long

using namespace std;
namespace ly
{
    namespace IO
    {
        #ifndef LOCAL
            #define SIZE (1<<20)
            char in[SIZE],out[SIZE],*p1=in,*p2=in,*p3=out;
            #define getchar() (p1==p2&&(p2=(p1=in)+fread(in,1,SIZE,stdin),p1==p2)?EOF:*p1++)
            #define flush() (fwrite(out,1,SIZE,stdout))
            #define putchar(ch) (p3==out+SIZE&&(flush(),p3=out),*p3++=(ch))
            class Flush{public:~Flush(){flush();}}_;
        #endif
        template<typename type>
        inline type read(type &x)
        {
            x=0;bool flag(0);char ch=getchar();
            while(!isdigit(ch)) flag^=ch=='-',ch=getchar();
            while(isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
            return flag?x=-x:x;
        }
        template<typename type>
        inline void write(type x)
        {
            x<0?x=-x,putchar('-'):0;
            static short Stack[50],top(0);
            do Stack[++top]=x%10,x/=10;while(x);
            while(top) putchar(Stack[top--]|48);
        }
        inline char read(char &x){return x=getchar();}
        inline char write(const char &x){return putchar(x);}
        template<typename type,typename ...T>
        inline void read(type &x,T&...y){read(x),read(y...);}
        template<typename type,typename ...T>
        inline void write(type x,T...y){write(x),putchar(' '),write(y...),sizeof...(y)^1?0:putchar('\n');}
        inline __int128 read(){__int128 x;return read(x);}
        template<typename type>
        inline type put(const type &x,bool flag=1){write(x),putchar(flag?'\n':' ');return x;}
        #ifndef LOCAL
            #undef SIZE
            #undef getchar
            #undef flush
            #undef putchar
        #endif
    }using namespace IO;
}using namespace ly::IO;



signed main()
{
    
    return 0;
}

2022/10/20

#define LOCAL
#include<iostream>
#include<cstdio>
#include<climits>
#define define(a,b) constexpr auto (a)=(b)
#define ll long long

using namespace std;
namespace ly
{
    namespace IO
    {
        #ifndef LOCAL
            #define maxn (1<<20)
            char _in[maxn],_out[maxn],*p1=_in,*p2=_in,*p3=_out;
            #define getchar() (p1==p2&&(p2=(p1=_in)+fread(_in,1,maxn,stdin),p1==p2)?EOF:*p1++)
            #define flush() (fwrite(_out,1,p3-_out,stdout))
            #define putchar(ch) (p3==_out+maxn&&(flush(),p3=_out),*p3++=(ch))
            class Flush{public:~Flush(){flush();}}_;
        #endif
        template<typename type>
        inline type read(type &x)
        {
            x=0;bool flag(0);char ch=getchar();
            while(!isdigit(ch)) flag^=ch=='-',ch=getchar();
            while(isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
            return flag?x=-x:x;
        }
        template<typename type>
        inline void write(type x)
        {
            x<0?x=-x,putchar('-'):0;
            static short Stack[50],top(0);
            do Stack[++top]=x%10,x/=10;while(x);
            while(top) putchar(Stack[top--]|48);
        }
        inline char read(char &x){return x=getchar();}
        inline char write(const char &x){return putchar(x);}
        template<typename type,typename...T>
        inline void read(type &x,T&...y){read(x),read(y...);}
        template<typename type,typename...T>
        inline void write(const type &x,const T&...y){write(x),putchar(' '),write(y...),sizeof...(y)^1?0:putchar('\n');}
        inline __int128 read(){__int128 x;return read(x);}
        template<typename type>
        inline type put(const type &x,bool flag=1){write(x),flag?putchar('\n'):putchar(' ');return x;}
        #ifndef LOCAL
            #undef maxn
            #undef getchar
            #undef flush
            #undef putchar
        #endif
    }using namespace IO;
}using namespace ly::IO;



signed main()
{
    
    return 0;
}

2022/10/27

#define LOCAL
#include<iostream>
#include<cstdio>
#include<climits>
#include<cctype>
#define ll long long

using namespace std;
namespace ly
{
    namespace IO
    {
        #ifndef LOCAL
            constexpr auto maxn=1<<20;
            char _in[maxn],_out[maxn],*_p1=_in,*_p2=_in,*_p3=_out;
            #define getchar() (_p1==_p2&&(_p2=(_p1=_in)+fread(_in,1,maxn,stdin),_p1==_p2)?EOF:*_p1++)
            #define flush() (fwrite(_out,1,_p3-_out,stdout))
            #define putchar(x) (_p3==_out+maxn&&(flush(),_p3=_out),*_p3++=(x))
            class Flush{public:~Flush(){flush();}}_;
        #endif
        template<typename type>
        inline type read(type &x)
        {
            x=0;bool flag(0);char ch=getchar();
            while(!isdigit(ch)) flag^=ch=='-',ch=getchar();
            while(isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
            return flag?x=-x:x;
        }
        template<typename type>
        inline void write(type x)
        {
            x<0?x=-x,putchar('-'):0;
            static short Stack[50],top(0);
            do Stack[++top]=x%10,x/=10;while(x);
            while(top) putchar(Stack[top--]|48);
        }
        inline char read(char &x){do x=getchar();while(isspace(x));return x;}
        inline char write(const char &x){return putchar(x);}
        inline void read(char *x){static char ch;read(ch);do *(x++)=ch;while(!isspace(ch=getchar())&&~ch);}
        inline void write(const char *x){while(*x)putchar(*(x++));}
        inline void read(string &x){static char ch[50];read(ch),x=ch;}
        inline void write(const string &x){int len=x.length();for(int i=0;i<len;++i)putchar(x[i]);}
        template<typename type,typename...T>
        inline void read(type &x,T&...y){read(x),read(y...);}
        template<typename type,typename...T>
        inline void write(const type &x,const T&...y){write(x),putchar(' '),write(y...),sizeof...(y)^1?0:putchar('\n');}
        inline __int128 read(){__int128 x;return read(x);}
        template<typename type>
        inline type put(const type &x,bool flag=1){write(x),flag?putchar('\n'):putchar(' ');return x;}
        #ifndef LOCAL
            #undef getchar
            #undef flush
            #undef putchar
        #endif
    }using namespace IO;
}using namespace ly::IO;



signed main()
{
    
    return 0;
}

2022/10/28

#define LOCAL
#include<iostream>
#include<cstdio>
#include<climits>
#include<cctype>
#define ll long long

using namespace std;
namespace ly
{
    namespace IO
    {
        #ifndef LOCAL
            constexpr auto maxn=1<<20;
            char in[maxn],out[maxn],*p1=in,*p2=in,*p3=out;
            #define getchar() (p1==p2&&(p2=(p1=in)+fread(in,1,maxn,stdin),p1==p2)?EOF:*p1++)
            #define flush() (fwrite(out,1,p3-out,stdout))
            #define putchar(x) (p3==out+maxn&&(flush(),p3=out),*p3++=(x))
            class Flush{public:~Flush(){flush();}}_;
        #endif
        namespace usr
        {
            template<typename type>
            inline type read(type &x)
            {
                x=0;bool flag(0);char ch=getchar();
                while(!isdigit(ch)) flag^=ch=='-',ch=getchar();
                while(isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
                return flag?x=-x:x;
            }
            template<typename type>
            inline void write(type x)
            {
                x<0?x=-x,putchar('-'):0;
                static short Stack[50],top(0);
                do Stack[++top]=x%10,x/=10;while(x);
                while(top) putchar(Stack[top--]|48);
            }
            inline char read(char &x){do x=getchar();while(isspace(x));return x;}
            inline char write(const char &x){return putchar(x);}
            inline void read(char *x){static char ch;read(ch);do *(x++)=ch;while(!isspace(ch=getchar())&&~ch);}
            inline void write(const char *x){while(*x)putchar(*(x++));}
            inline void read(string &x){static char ch[50];read(ch),x=ch;}
            inline void write(const string &x){int len=x.length();for(int i=0;i<len;++i)putchar(x[i]);}
            template<typename type,typename...T>
            inline void read(type &x,T&...y){read(x),read(y...);}
            template<typename type,typename...T>
            inline void write(const type &x,const T&...y){write(x),putchar(' '),write(y...),sizeof...(y)^1?0:putchar('\n');}
            inline __int128 read(){static __int128 x;return read(x);}
            template<typename type>
            inline type put(const type &x,bool flag=1){write(x),flag?putchar('\n'):putchar(' ');return x;}
        }
        #ifndef LOCAL
            #undef getchar
            #undef flush
            #undef putchar
        #endif
    }using namespace IO::usr;
}using namespace ly::IO::usr;



signed main()
{
    
    return 0;
}

2022/10/29

#define LOCAL
#include<iostream>
#include<cstdio>
#include<climits>
#include<cctype>
#define ll long long

using namespace std;
namespace ly
{
    namespace IO
    {
        #ifndef LOCAL
            constexpr auto maxn=1<<20;
            char in[maxn],out[maxn],*p1=in,*p2=in,*p3=out;
            #define getchar() (p1==p2&&(p2=(p1=in)+fread(in,1,maxn,stdin),p1==p2)?EOF:*p1++)
            #define flush() (fwrite(out,1,p3-out,stdout))
            #define putchar(x) (p3==out+maxn&&(flush(),p3=out),*p3++=(x))
            class Flush{public:~Flush(){flush();}}_;
        #endif
        namespace usr
        {
            template<typename type>
            inline type read(type &x)
            {
                x=0;bool flag(0);char ch=getchar();
                while(!isdigit(ch)) flag^=ch=='-',ch=getchar();
                while(isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
                return flag?x=-x:x;
            }
            template<typename type>
            inline void write(type x)
            {
                x<0?x=-x,putchar('-'):0;
                static short Stack[50],top(0);
                do Stack[++top]=x%10,x/=10;while(x);
                while(top) putchar(Stack[top--]|48);
            }
            inline int read(double &x){return scanf("%lf",&x);}
            inline int read(long double &x){return scanf("%Lf",&x);}
            inline int dwrite(const double &x,int y=6){return printf("%.*lf\n",y,x);}
            inline int dwrite(const long double &x,int y=6){return printf("%.*Lf\n",y,x);}
            inline char read(char &x){do x=getchar();while(isspace(x));return x;}
            inline char write(const char &x){return putchar(x);}
            inline void read(char *x){static char ch;read(ch);do *(x++)=ch;while(!isspace(ch=getchar())&&~ch);}
            inline void write(const char *x){while(*x)putchar(*(x++));}
            inline void read(string &x){static char ch[50];read(ch),x=ch;}
            inline void write(const string &x){int len=x.length();for(int i=0;i<len;++i)putchar(x[i]);}
            template<typename type,typename...T>
            inline void read(type &x,T&...y){read(x),read(y...);}
            template<typename type,typename...T>
            inline void write(const type &x,const T&...y){write(x),putchar(' '),write(y...),sizeof...(y)^1?0:putchar('\n');}
            inline __int128 read(){static __int128 x;return read(x);}
            template<typename type>
            inline type put(type x,bool flag=1){write(x),flag?putchar('\n'):putchar(' ');return x;}
        }
        #ifndef LOCAL
            #undef getchar
            #undef flush
            #undef putchar
        #endif
    }using namespace IO::usr;
}using namespace ly::IO::usr;



signed main()
{
    
    return 0;
}

2022/11/17

#define LOCAL
#include<iostream>
#include<cstdio>
#include<climits>
#include<cctype>
#define ll long long

using namespace std;
namespace ly
{
    namespace IO
    {
        #ifndef LOCAL
            constexpr auto maxn=1<<20;
            char in[maxn],out[maxn],*p1=in,*p2=in,*p3=out;
            #define getchar() (p1==p2&&(p2=(p1=in)+fread(in,1,maxn,stdin),p1==p2)?EOF:*p1++)
            #define flush() (fwrite(out,1,p3-out,stdout))
            #define putchar(x) (p3==out+maxn&&(flush(),p3=out),*p3++=(x))
            class Flush{public:~Flush(){flush();}}_;
        #endif
        namespace usr
        {
            template<typename type>
            inline type read(type &x)
            {
                x=0;bool flag(0);char ch=getchar();
                while(!isdigit(ch)) flag^=ch=='-',ch=getchar();
                while(isdigit(ch)) x=(x<<1)+(x<<3)+(ch^48),ch=getchar();
                return flag?x=-x:x;
            }
            template<typename type>
            inline void write(type x)
            {
                x<0?x=-x,putchar('-'):0;
                static short Stack[50],top(0);
                do Stack[++top]=x%10,x/=10;while(x);
                while(top) putchar(Stack[top--]|48);
            }
            inline char read(char &x){do x=getchar();while(isspace(x));return x;}
            inline char write(const char &x){return putchar(x);}
            inline void read(char *x){static char ch;read(ch);do *(x++)=ch;while(!isspace(ch=getchar())&&~ch);}
            template<typename type>inline void write(type *x){while(*x)putchar(*(x++));}
            inline void read(string &x){static char ch;read(ch),x.clear();do x+=ch;while(!isspace(ch=getchar())&&~ch);}
            inline void write(const string &x){for(int i=0,len=x.length();i<len;++i)putchar(x[i]);}
            template<typename type,typename...T>inline void read(type &x,T&...y){read(x),read(y...);}
            template<typename type,typename...T>
            inline void write(const type &x,const T&...y){write(x),putchar(' '),write(y...),sizeof...(y)^1?0:putchar('\n');}
            template<typename type>
            inline void put(const type &x,bool flag=1){write(x),flag?putchar('\n'):putchar(' ');}
        }
        #ifndef LOCAL
            #undef getchar
            #undef flush
            #undef putchar
        #endif
    }using namespace IO::usr;
}using namespace ly::IO::usr;



signed main()
{
    
    return 0;
}