foo.cc: In function 'int main()':
foo.cc:3:35: warning: format '%d' expects argument of type 'int*', but argument 2 has type 'll* {aka long long int*}' [-Wformat=]
 #define GetI64(x) scanf("%I64d",&x)
                                 ~~^~
 #define PutI64(x,arg...) printf("%I64d" arg,x)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 ~                                  
 ll mod;
 ~~~~~~~~                           
 
 ~                                  
 ll mul(ll a,ll b){
 ~~~~~~~~~~~~~~~~~~~                
     ll ans=0;
     ~~~~~~~~~~                     
     while(b){
     ~~~~~~~~~~                     
         if(b&1)ans=(ans+a)%mod;
         ~~~~~~~~~~~~~~~~~~~~~~~~   
         a=(a+a)%mod;
         ~~~~~~~~~~~~~              
         b>>=1;
         ~~~~~~~                    
     }
     ~~                             
     return ans;
     ~~~~~~~~~~~~                   
 }
 ~~                                 
 
 ~                                  
 
 ~                                  
 
 ~                                  
 struct mat{
 ~~~~~~~~~~~~                       
     int m,n;
     ~~~~~~~~~                      
     ll a[3][3];
     ~~~~~~~~~~~~                   
     mat(int M=0,int N=0){m=M;n=N;}
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     void clear(){
     ~~~~~~~~~~~~~~                 
         for(int i=1;i<=m;++i){
         ~~~~~~~~~~~~~~~~~~~~~~~    
             for(int j=1;j<=n;++j){
             ~~~~~~~~~~~~~~~~~~~~~~~
                 a[i][j]=0;
                 ~~~~~~~~~~~        
             }
             ~~                     
         }
         ~~                         
     }
     ~~                             
     ll*operator[](int d){return a[d];}
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 };
 ~~~                                
 
 ~                                  
 mat operator*(mat a,mat b){
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~       
     mat c(a.m,b.n);
     ~~~~~~~~~~~~~~~~               
     //a.n==b.m
     ~~~~~~~~~~~                    
     c.clear();
     ~~~~~~~~~~~                    
     for(int k=1;k<=a.n;++k){
     ~~~~~~~~~~~~~~~~~~~~~~~~~      
         for(int i=1;i<=a.m;++i){
         ~~~~~~~~~~~~~~~~~~~~~~~~~  
             for(int j=1;j<=b.n;++j){
             ~~~~~~~~~~~~~~~~~~~~~~~~~
                 c[i][j]+=mul(a[i][k],b[k][j]);
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                 c[i][j]%=mod;
                 ~~~~~~~~~~~~~~     
                 if(c[i][j]<0)c[i][j]+=mod;
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
             }
             ~~                     
         }
         ~~                         
     }
     ~~                             
     return c;
     ~~~~~~~~~~                     
 }
 ~~                                 
 
 ~                                  
 mat operator^(mat x,ll p){
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~        
     if(p==1)return x;
     ~~~~~~~~~~~~~~~~~~             
     if(p==2)return x*x;
     ~~~~~~~~~~~~~~~~~~~~           
     mat t=x^(p/2);
     ~~~~~~~~~~~~~~~                
     t=t*t;
     ~~~~~~~                        
     if(p&1)t=t*x;
     ~~~~~~~~~~~~~~                 
     return t;
     ~~~~~~~~~~                     
 }
 ~~                                 
 
 ~                                  
 
 ~                                  
 int main(){
 ~~~~~~~~~~~~                       
     ll m,a,c,x0,n,g;
     ~~~~~~~~~~~~~~~~~              
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
     ~~~~~~~~                       
foo.cc:62:5: note: in expansion of macro 'GetI64'
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
     ^~~~~~
foo.cc:3:35: warning: format '%d' expects argument of type 'int*', but argument 2 has type 'll* {aka long long int*}' [-Wformat=]
 #define GetI64(x) scanf("%I64d",&x)
                                 ~~^~
 #define PutI64(x,arg...) printf("%I64d" arg,x)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 ~                                  
 ll mod;
 ~~~~~~~~                           
 
 ~                                  
 ll mul(ll a,ll b){
 ~~~~~~~~~~~~~~~~~~~                
     ll ans=0;
     ~~~~~~~~~~                     
     while(b){
     ~~~~~~~~~~                     
         if(b&1)ans=(ans+a)%mod;
         ~~~~~~~~~~~~~~~~~~~~~~~~   
         a=(a+a)%mod;
         ~~~~~~~~~~~~~              
         b>>=1;
         ~~~~~~~                    
     }
     ~~                             
     return ans;
     ~~~~~~~~~~~~                   
 }
 ~~                                 
 
 ~                                  
 
 ~                                  
 
 ~                                  
 struct mat{
 ~~~~~~~~~~~~                       
     int m,n;
     ~~~~~~~~~                      
     ll a[3][3];
     ~~~~~~~~~~~~                   
     mat(int M=0,int N=0){m=M;n=N;}
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     void clear(){
     ~~~~~~~~~~~~~~                 
         for(int i=1;i<=m;++i){
         ~~~~~~~~~~~~~~~~~~~~~~~    
             for(int j=1;j<=n;++j){
             ~~~~~~~~~~~~~~~~~~~~~~~
                 a[i][j]=0;
                 ~~~~~~~~~~~        
             }
             ~~                     
         }
         ~~                         
     }
     ~~                             
     ll*operator[](int d){return a[d];}
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 };
 ~~~                                
 
 ~                                  
 mat operator*(mat a,mat b){
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~       
     mat c(a.m,b.n);
     ~~~~~~~~~~~~~~~~               
     //a.n==b.m
     ~~~~~~~~~~~                    
     c.clear();
     ~~~~~~~~~~~                    
     for(int k=1;k<=a.n;++k){
     ~~~~~~~~~~~~~~~~~~~~~~~~~      
         for(int i=1;i<=a.m;++i){
         ~~~~~~~~~~~~~~~~~~~~~~~~~  
             for(int j=1;j<=b.n;++j){
             ~~~~~~~~~~~~~~~~~~~~~~~~~
                 c[i][j]+=mul(a[i][k],b[k][j]);
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                 c[i][j]%=mod;
                 ~~~~~~~~~~~~~~     
                 if(c[i][j]<0)c[i][j]+=mod;
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
             }
             ~~                     
         }
         ~~                         
     }
     ~~                             
     return c;
     ~~~~~~~~~~                     
 }
 ~~                                 
 
 ~                                  
 mat operator^(mat x,ll p){
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~        
     if(p==1)return x;
     ~~~~~~~~~~~~~~~~~~             
     if(p==2)return x*x;
     ~~~~~~~~~~~~~~~~~~~~           
     mat t=x^(p/2);
     ~~~~~~~~~~~~~~~                
     t=t*t;
     ~~~~~~~                        
     if(p&1)t=t*x;
     ~~~~~~~~~~~~~~                 
     return t;
     ~~~~~~~~~~                     
 }
 ~~                                 
 
 ~                                  
 
 ~                                  
 int main(){
 ~~~~~~~~~~~~                       
     ll m,a,c,x0,n,g;
     ~~~~~~~~~~~~~~~~~              
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
     ~~~~~~~~~~~~~~~~~~             
foo.cc:62:15: note: in expansion of macro 'GetI64'
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
               ^~~~~~
foo.cc:3:35: warning: format '%d' expects argument of type 'int*', but argument 2 has type 'll* {aka long long int*}' [-Wformat=]
 #define GetI64(x) scanf("%I64d",&x)
                                 ~~^~
 #define PutI64(x,arg...) printf("%I64d" arg,x)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 ~                                  
 ll mod;
 ~~~~~~~~                           
 
 ~                                  
 ll mul(ll a,ll b){
 ~~~~~~~~~~~~~~~~~~~                
     ll ans=0;
     ~~~~~~~~~~                     
     while(b){
     ~~~~~~~~~~                     
         if(b&1)ans=(ans+a)%mod;
         ~~~~~~~~~~~~~~~~~~~~~~~~   
         a=(a+a)%mod;
         ~~~~~~~~~~~~~              
         b>>=1;
         ~~~~~~~                    
     }
     ~~                             
     return ans;
     ~~~~~~~~~~~~                   
 }
 ~~                                 
 
 ~                                  
 
 ~                                  
 
 ~                                  
 struct mat{
 ~~~~~~~~~~~~                       
     int m,n;
     ~~~~~~~~~                      
     ll a[3][3];
     ~~~~~~~~~~~~                   
     mat(int M=0,int N=0){m=M;n=N;}
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     void clear(){
     ~~~~~~~~~~~~~~                 
         for(int i=1;i<=m;++i){
         ~~~~~~~~~~~~~~~~~~~~~~~    
             for(int j=1;j<=n;++j){
             ~~~~~~~~~~~~~~~~~~~~~~~
                 a[i][j]=0;
                 ~~~~~~~~~~~        
             }
             ~~                     
         }
         ~~                         
     }
     ~~                             
     ll*operator[](int d){return a[d];}
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 };
 ~~~                                
 
 ~                                  
 mat operator*(mat a,mat b){
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~       
     mat c(a.m,b.n);
     ~~~~~~~~~~~~~~~~               
     //a.n==b.m
     ~~~~~~~~~~~                    
     c.clear();
     ~~~~~~~~~~~                    
     for(int k=1;k<=a.n;++k){
     ~~~~~~~~~~~~~~~~~~~~~~~~~      
         for(int i=1;i<=a.m;++i){
         ~~~~~~~~~~~~~~~~~~~~~~~~~  
             for(int j=1;j<=b.n;++j){
             ~~~~~~~~~~~~~~~~~~~~~~~~~
                 c[i][j]+=mul(a[i][k],b[k][j]);
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                 c[i][j]%=mod;
                 ~~~~~~~~~~~~~~     
                 if(c[i][j]<0)c[i][j]+=mod;
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
             }
             ~~                     
         }
         ~~                         
     }
     ~~                             
     return c;
     ~~~~~~~~~~                     
 }
 ~~                                 
 
 ~                                  
 mat operator^(mat x,ll p){
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~        
     if(p==1)return x;
     ~~~~~~~~~~~~~~~~~~             
     if(p==2)return x*x;
     ~~~~~~~~~~~~~~~~~~~~           
     mat t=x^(p/2);
     ~~~~~~~~~~~~~~~                
     t=t*t;
     ~~~~~~~                        
     if(p&1)t=t*x;
     ~~~~~~~~~~~~~~                 
     return t;
     ~~~~~~~~~~                     
 }
 ~~                                 
 
 ~                                  
 
 ~                                  
 int main(){
 ~~~~~~~~~~~~                       
     ll m,a,c,x0,n,g;
     ~~~~~~~~~~~~~~~~~              
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~   
foo.cc:62:25: note: in expansion of macro 'GetI64'
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
                         ^~~~~~
foo.cc:3:35: warning: format '%d' expects argument of type 'int*', but argument 2 has type 'll* {aka long long int*}' [-Wformat=]
 #define GetI64(x) scanf("%I64d",&x)
                                 ~~^~
 #define PutI64(x,arg...) printf("%I64d" arg,x)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 ~                                  
 ll mod;
 ~~~~~~~~                           
 
 ~                                  
 ll mul(ll a,ll b){
 ~~~~~~~~~~~~~~~~~~~                
     ll ans=0;
     ~~~~~~~~~~                     
     while(b){
     ~~~~~~~~~~                     
         if(b&1)ans=(ans+a)%mod;
         ~~~~~~~~~~~~~~~~~~~~~~~~   
         a=(a+a)%mod;
         ~~~~~~~~~~~~~              
         b>>=1;
         ~~~~~~~                    
     }
     ~~                             
     return ans;
     ~~~~~~~~~~~~                   
 }
 ~~                                 
 
 ~                                  
 
 ~                                  
 
 ~                                  
 struct mat{
 ~~~~~~~~~~~~                       
     int m,n;
     ~~~~~~~~~                      
     ll a[3][3];
     ~~~~~~~~~~~~                   
     mat(int M=0,int N=0){m=M;n=N;}
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     void clear(){
     ~~~~~~~~~~~~~~                 
         for(int i=1;i<=m;++i){
         ~~~~~~~~~~~~~~~~~~~~~~~    
             for(int j=1;j<=n;++j){
             ~~~~~~~~~~~~~~~~~~~~~~~
                 a[i][j]=0;
                 ~~~~~~~~~~~        
             }
             ~~                     
         }
         ~~                         
     }
     ~~                             
     ll*operator[](int d){return a[d];}
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 };
 ~~~                                
 
 ~                                  
 mat operator*(mat a,mat b){
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~       
     mat c(a.m,b.n);
     ~~~~~~~~~~~~~~~~               
     //a.n==b.m
     ~~~~~~~~~~~                    
     c.clear();
     ~~~~~~~~~~~                    
     for(int k=1;k<=a.n;++k){
     ~~~~~~~~~~~~~~~~~~~~~~~~~      
         for(int i=1;i<=a.m;++i){
         ~~~~~~~~~~~~~~~~~~~~~~~~~  
             for(int j=1;j<=b.n;++j){
             ~~~~~~~~~~~~~~~~~~~~~~~~~
                 c[i][j]+=mul(a[i][k],b[k][j]);
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                 c[i][j]%=mod;
                 ~~~~~~~~~~~~~~     
                 if(c[i][j]<0)c[i][j]+=mod;
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
             }
             ~~                     
         }
         ~~                         
     }
     ~~                             
     return c;
     ~~~~~~~~~~                     
 }
 ~~                                 
 
 ~                                  
 mat operator^(mat x,ll p){
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~        
     if(p==1)return x;
     ~~~~~~~~~~~~~~~~~~             
     if(p==2)return x*x;
     ~~~~~~~~~~~~~~~~~~~~           
     mat t=x^(p/2);
     ~~~~~~~~~~~~~~~                
     t=t*t;
     ~~~~~~~                        
     if(p&1)t=t*x;
     ~~~~~~~~~~~~~~                 
     return t;
     ~~~~~~~~~~                     
 }
 ~~                                 
 
 ~                                  
 
 ~                                  
 int main(){
 ~~~~~~~~~~~~                       
     ll m,a,c,x0,n,g;
     ~~~~~~~~~~~~~~~~~              
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
foo.cc:62:35: note: in expansion of macro 'GetI64'
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
                                   ^~~~~~
foo.cc:3:35: warning: format '%d' expects argument of type 'int*', but argument 2 has type 'll* {aka long long int*}' [-Wformat=]
 #define GetI64(x) scanf("%I64d",&x)
                                 ~~^~
 #define PutI64(x,arg...) printf("%I64d" arg,x)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 ~                                  
 ll mod;
 ~~~~~~~~                           
 
 ~                                  
 ll mul(ll a,ll b){
 ~~~~~~~~~~~~~~~~~~~                
     ll ans=0;
     ~~~~~~~~~~                     
     while(b){
     ~~~~~~~~~~                     
         if(b&1)ans=(ans+a)%mod;
         ~~~~~~~~~~~~~~~~~~~~~~~~   
         a=(a+a)%mod;
         ~~~~~~~~~~~~~              
         b>>=1;
         ~~~~~~~                    
     }
     ~~                             
     return ans;
     ~~~~~~~~~~~~                   
 }
 ~~                                 
 
 ~                                  
 
 ~                                  
 
 ~                                  
 struct mat{
 ~~~~~~~~~~~~                       
     int m,n;
     ~~~~~~~~~                      
     ll a[3][3];
     ~~~~~~~~~~~~                   
     mat(int M=0,int N=0){m=M;n=N;}
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     void clear(){
     ~~~~~~~~~~~~~~                 
         for(int i=1;i<=m;++i){
         ~~~~~~~~~~~~~~~~~~~~~~~    
             for(int j=1;j<=n;++j){
             ~~~~~~~~~~~~~~~~~~~~~~~
                 a[i][j]=0;
                 ~~~~~~~~~~~        
             }
             ~~                     
         }
         ~~                         
     }
     ~~                             
     ll*operator[](int d){return a[d];}
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 };
 ~~~                                
 
 ~                                  
 mat operator*(mat a,mat b){
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~       
     mat c(a.m,b.n);
     ~~~~~~~~~~~~~~~~               
     //a.n==b.m
     ~~~~~~~~~~~                    
     c.clear();
     ~~~~~~~~~~~                    
     for(int k=1;k<=a.n;++k){
     ~~~~~~~~~~~~~~~~~~~~~~~~~      
         for(int i=1;i<=a.m;++i){
         ~~~~~~~~~~~~~~~~~~~~~~~~~  
             for(int j=1;j<=b.n;++j){
             ~~~~~~~~~~~~~~~~~~~~~~~~~
                 c[i][j]+=mul(a[i][k],b[k][j]);
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                 c[i][j]%=mod;
                 ~~~~~~~~~~~~~~     
                 if(c[i][j]<0)c[i][j]+=mod;
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
             }
             ~~                     
         }
         ~~                         
     }
     ~~                             
     return c;
     ~~~~~~~~~~                     
 }
 ~~                                 
 
 ~                                  
 mat operator^(mat x,ll p){
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~        
     if(p==1)return x;
     ~~~~~~~~~~~~~~~~~~             
     if(p==2)return x*x;
     ~~~~~~~~~~~~~~~~~~~~           
     mat t=x^(p/2);
     ~~~~~~~~~~~~~~~                
     t=t*t;
     ~~~~~~~                        
     if(p&1)t=t*x;
     ~~~~~~~~~~~~~~                 
     return t;
     ~~~~~~~~~~                     
 }
 ~~                                 
 
 ~                                  
 
 ~                                  
 int main(){
 ~~~~~~~~~~~~                       
     ll m,a,c,x0,n,g;
     ~~~~~~~~~~~~~~~~~              
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
foo.cc:62:46: note: in expansion of macro 'GetI64'
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
                                              ^~~~~~
foo.cc:3:35: warning: format '%d' expects argument of type 'int*', but argument 2 has type 'll* {aka long long int*}' [-Wformat=]
 #define GetI64(x) scanf("%I64d",&x)
                                 ~~^~
 #define PutI64(x,arg...) printf("%I64d" arg,x)
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 
 ~                                  
 ll mod;
 ~~~~~~~~                           
 
 ~                                  
 ll mul(ll a,ll b){
 ~~~~~~~~~~~~~~~~~~~                
     ll ans=0;
     ~~~~~~~~~~                     
     while(b){
     ~~~~~~~~~~                     
         if(b&1)ans=(ans+a)%mod;
         ~~~~~~~~~~~~~~~~~~~~~~~~   
         a=(a+a)%mod;
         ~~~~~~~~~~~~~              
         b>>=1;
         ~~~~~~~                    
     }
     ~~                             
     return ans;
     ~~~~~~~~~~~~                   
 }
 ~~                                 
 
 ~                                  
 
 ~                                  
 
 ~                                  
 struct mat{
 ~~~~~~~~~~~~                       
     int m,n;
     ~~~~~~~~~                      
     ll a[3][3];
     ~~~~~~~~~~~~                   
     mat(int M=0,int N=0){m=M;n=N;}
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
     void clear(){
     ~~~~~~~~~~~~~~                 
         for(int i=1;i<=m;++i){
         ~~~~~~~~~~~~~~~~~~~~~~~    
             for(int j=1;j<=n;++j){
             ~~~~~~~~~~~~~~~~~~~~~~~
                 a[i][j]=0;
                 ~~~~~~~~~~~        
             }
             ~~                     
         }
         ~~                         
     }
     ~~                             
     ll*operator[](int d){return a[d];}
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
 };
 ~~~                                
 
 ~                                  
 mat operator*(mat a,mat b){
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~       
     mat c(a.m,b.n);
     ~~~~~~~~~~~~~~~~               
     //a.n==b.m
     ~~~~~~~~~~~                    
     c.clear();
     ~~~~~~~~~~~                    
     for(int k=1;k<=a.n;++k){
     ~~~~~~~~~~~~~~~~~~~~~~~~~      
         for(int i=1;i<=a.m;++i){
         ~~~~~~~~~~~~~~~~~~~~~~~~~  
             for(int j=1;j<=b.n;++j){
             ~~~~~~~~~~~~~~~~~~~~~~~~~
                 c[i][j]+=mul(a[i][k],b[k][j]);
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
                 c[i][j]%=mod;
                 ~~~~~~~~~~~~~~     
                 if(c[i][j]<0)c[i][j]+=mod;
                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~
             }
             ~~                     
         }
         ~~                         
     }
     ~~                             
     return c;
     ~~~~~~~~~~                     
 }
 ~~                                 
 
 ~                                  
 mat operator^(mat x,ll p){
 ~~~~~~~~~~~~~~~~~~~~~~~~~~~        
     if(p==1)return x;
     ~~~~~~~~~~~~~~~~~~             
     if(p==2)return x*x;
     ~~~~~~~~~~~~~~~~~~~~           
     mat t=x^(p/2);
     ~~~~~~~~~~~~~~~                
     t=t*t;
     ~~~~~~~                        
     if(p&1)t=t*x;
     ~~~~~~~~~~~~~~                 
     return t;
     ~~~~~~~~~~                     
 }
 ~~                                 
 
 ~                                  
 
 ~                                  
 int main(){
 ~~~~~~~~~~~~                       
     ll m,a,c,x0,n,g;
     ~~~~~~~~~~~~~~~~~              
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
     ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
foo.cc:62:56: note: in expansion of macro 'GetI64'
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
                                                        ^~~~~~
foo.cc:4:46: warning: format '%d' expects argument of type 'int', but argument 2 has type 'll {aka long long int}' [-Wformat=]
 #define PutI64(x,arg...) printf("%I64d" arg,x)
                                              ^
foo.cc:75:5: note: in expansion of macro 'PutI64'
     PutI64(x,"\n");
     ^~~~~~
foo.cc:3:24: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
 #define GetI64(x) scanf("%I64d",&x)
                   ~~~~~^~~~~~~~~~~~
foo.cc:62:5: note: in expansion of macro 'GetI64'
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
     ^~~~~~
foo.cc:3:24: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
 #define GetI64(x) scanf("%I64d",&x)
                   ~~~~~^~~~~~~~~~~~
foo.cc:62:15: note: in expansion of macro 'GetI64'
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
               ^~~~~~
foo.cc:3:24: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
 #define GetI64(x) scanf("%I64d",&x)
                   ~~~~~^~~~~~~~~~~~
foo.cc:62:25: note: in expansion of macro 'GetI64'
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
                         ^~~~~~
foo.cc:3:24: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
 #define GetI64(x) scanf("%I64d",&x)
                   ~~~~~^~~~~~~~~~~~
foo.cc:62:35: note: in expansion of macro 'GetI64'
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
                                   ^~~~~~
foo.cc:3:24: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
 #define GetI64(x) scanf("%I64d",&x)
                   ~~~~~^~~~~~~~~~~~
foo.cc:62:46: note: in expansion of macro 'GetI64'
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
                                              ^~~~~~
foo.cc:3:24: warning: ignoring return value of 'int scanf(const char*, ...)', declared with attribute warn_unused_result [-Wunused-result]
 #define GetI64(x) scanf("%I64d",&x)
                   ~~~~~^~~~~~~~~~~~
foo.cc:62:56: note: in expansion of macro 'GetI64'
     GetI64(m);GetI64(a);GetI64(c);GetI64(x0);GetI64(n);GetI64(g);
                                                        ^~~~~~

正在同步测试数据，请稍后
自豪的采用HydroJudge(https://github.com/hydro-dev/Hydro)进行评测。