14 条题解

  • 2
    @ 2025-1-23 11:13:08
    #include<iostream>
    using namespace std;
    int main()
    {
    	int a,b;
    	cin>>a>>b;
    	cout<<a+b;
    }
    
    • 1
      @ 2025-3-8 11:23:25

      #include

      #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include <condition_variable> #include <forward_list> #include #include <initializer_list> #include #include #include #include #include <scoped_allocator> #include <system_error> #include #include #include #include <type_traits> #include <unordered_map> #include <unordered_set> #include <shared_mutex> #include #include using namespace std; int main() { int a,b; cin>>a>>b; cout<<a+b; }

      • 1
        @ 2024-7-26 10:58:29

        A+B Problem题解

        新用户强烈建议阅读此帖

        首先我们要理清思路

        1.需要用到什么样的头文件?

        2.用什么样的数据范围?

        3.思路是什么?

        首先题目中的数据范围是1a,b≤10^6, 而int 的范围是-2147483648-2147483647 正合题意,所以数据类型可以用int

        话不多说,直接上代码

        #include<iostream>//导入头文件,iostream里面是标准输入输出流(我说的什么?) 
        using namespace std;//使用标准命名空间 
        int main(){//主函数,程序的入口 
        	int a,b;//创建a,b两个整型变量 
        	cin>>a>>b;//输入 a , b 两个变量 
        	cout<<a+b; //输出a+b的内容 
        	return 0; 
        }
        

        本蒟蒻发的第一篇题解,请多多支持喵~~

        • 0
          @ 2025-2-21 19:53:22

          最短题解

          #include<iostream>
          int a,b;int main(){std::cin>>a>>b;std::cout<<a+b;}
          
          • 0
            @ 2024-11-30 19:04:15
            #ifndef _GLIBCXX_QUEUE
            #define _GLIBCXX_QUEUE 1
            #include <deque>
            #include <vector>
            #include <bits/stl_heap.h>
            #include <bits/stl_function.h>
            #include <bits/stl_queue.h>
            #endif
            #ifndef _GLIBCXX_STACK
            #define _GLIBCXX_STACK 1
            #include <deque>
            #include <bits/stl_stack.h>
            #endif
            #ifndef _GLIBCXX_VECTOR
            #define _GLIBCXX_VECTOR 1
            #include <bits/stl_algobase.h>
            #include <bits/allocator.h>
            #include <bits/stl_construct.h>
            #include <bits/stl_uninitialized.h>
            #include <bits/stl_vector.h>
            #include <bits/stl_bvector.h> 
            #include <bits/range_access.h>
            #ifndef _GLIBCXX_EXPORT_TEMPLATE
            #include <bits/vector.tcc>
            #endif
            #ifdef _GLIBCXX_DEBUG
            #include <debug/vector>
            #endif
            #ifdef _GLIBCXX_PROFILE
            #include <profile/vector>
            #endif
            #endif
            #pragma GCC optimize(3)
            #pragma GCC target("avx")
            #pragma GCC optimize("Ofast")
            #pragma GCC optimize("inline")
            #pragma GCC optimize("-fgcse")
            #pragma GCC optimize("-fgcse-lm")
            #pragma GCC optimize("-fipa-sra")
            #pragma GCC optimize("-ftree-pre")
            #pragma GCC optimize("-ftree-vrp")
            #pragma GCC optimize("-fpeephole2")
            #pragma GCC optimize("-ffast-math")
            #pragma GCC optimize("-fsched-spec")
            #pragma GCC optimize("unroll-loops")
            #pragma GCC optimize("-falign-jumps")
            #pragma GCC optimize("-falign-loops")
            #pragma GCC optimize("-falign-labels")
            #pragma GCC optimize("-fdevirtualize")
            #pragma GCC optimize("-fcaller-saves")
            #pragma GCC optimize("-fcrossjumping")
            #pragma GCC optimize("-fthread-jumps")
            #pragma GCC optimize("-funroll-loops")
            #pragma GCC optimize("-fwhole-program")
            #pragma GCC optimize("-freorder-blocks")
            #pragma GCC optimize("-fschedule-insns")
            #pragma GCC optimize("inline-functions")
            #pragma GCC optimize("-ftree-tail-merge")
            #pragma GCC optimize("-fschedule-insns2")
            #pragma GCC optimize("-fstrict-aliasing")
            #pragma GCC optimize("-fstrict-overflow")
            #pragma GCC optimize("-falign-functions")
            #pragma GCC optimize("-fcse-skip-blocks")
            #pragma GCC optimize("-fcse-follow-jumps")
            #pragma GCC optimize("-fsched-interblock")
            #pragma GCC optimize("-fpartial-inlining")
            #pragma GCC optimize("no-stack-protector")
            #pragma GCC optimize("-freorder-functions")
            #pragma GCC optimize("-findirect-inlining")
            #pragma GCC optimize("-fhoist-adjacent-loads")
            #pragma GCC optimize("-frerun-cse-after-loop")
            #pragma GCC optimize("inline-small-functions")
            #pragma GCC optimize("-finline-small-functions")
            #pragma GCC optimize("-ftree-switch-conversion")
            #pragma GCC optimize("-foptimize-sibling-calls")
            #pragma GCC optimize("-fexpensive-optimizations")
            #pragma GCC optimize("-funsafe-loop-optimizations")
            #pragma GCC optimize("inline-functions-called-once")
            #pragma GCC optimize("-fdelete-null-pointer-checks")
            #define	_DOMAIN			1
            #define	_SING			2
            #define	_OVERFLOW		3
            #define	_UNDERFLOW		4
            #define	_TLOSS			5
            #define	_PLOSS			6
            #define	DOMAIN			_DOMAIN
            #define	SING			_SING
            #define	OVERFLOW		_OVERFLOW
            #define	UNDERFLOW		_UNDERFLOW
            #define	TLOSS			_TLOSS
            #define	PLOSS			_PLOSS
            #define M_E				2.7182818284590452354
            #define M_LOG2E			1.4426950408889634074
            #define M_LOG10E		0.43429448190325182765
            #define M_LN2			0.69314718055994530942
            #define M_LN10			2.30258509299404568402
            #define M_PI			3.14159265358979323846
            #define M_PI_2			1.57079632679489661923
            #define M_PI_4			0.78539816339744830962
            #define M_1_PI			0.31830988618379067154
            #define M_2_PI			0.63661977236758134308
            #define M_2_SQRTPI		1.12837916709551257390
            #define M_SQRT2			1.41421356237309504880
            #define M_SQRT1_2		0.70710678118654752440
            #define	_FPCLASS_SNAN	0x0001
            #define	_FPCLASS_QNAN	0x0002
            #define	_FPCLASS_NINF	0x0004
            #define	_FPCLASS_NN		0x0008
            #define	_FPCLASS_ND		0x0010
            #define	_FPCLASS_NZ		0x0020
            #define	_FPCLASS_PZ		0x0040
            #define	_FPCLASS_PD		0x0080
            #define	_FPCLASS_PN		0x0100
            #define	_FPCLASS_PINF	0x0200
            #define FP_SNAN    		_FPCLASS_SNAN
            #define FP_QNAN    		_FPCLASS_QNAN
            #define FP_NINF    		_FPCLASS_NINF
            #define FP_PINF    		_FPCLASS_PINF
            #define FP_NDENORM 		_FPCLASS_ND
            #define FP_PDENORM 		_FPCLASS_PD
            #define FP_NZERO   		_FPCLASS_NZ
            #define FP_PZERO   		_FPCLASS_PZ
            #define FP_NNORM   		_FPCLASS_NN
            #define FP_PNORM   		_FPCLASS_PN
            #include <queue>
            #include <math.h>
            #include <stack>
            #include <stdio.h>
            #include <iostream>
            #include <vector>
            #include <iomanip>
            #include <string.h>
            #include <algorithm>
            using namespace std;
            #define int long long
            const int N = 3e7 + 10;
            const int INF = 0xfffffffffffffff;
            int n, m;
            signed main(){
            	cin >> n >> m;
            	cout << n + m << endl;
            	return 0;
            }
            
            • -1
              @ 2024-11-16 16:21:16
              #include<iostream>
              using namespace std;
              int main(){
              	int a,b,c;
              	cin>>a>>b;
              	c=a+b;
              	cout<<c;
              }
              
              • -2
                @ 2025-1-25 11:30:47
                #include<bits/stdc++.h>
                using namespace std;
                int main(){
                int a, b;
                cin >> a >> b;
                cout << a + b << endl;
                return 0;
                }
                
                • -2
                  @ 2024-11-10 15:03:57
                  #include<iostream> 
                  using namespace std;
                  int main(){
                  	int a,b;
                  	cin>>a>>b;
                  	cout<<a+b;
                  }
                  
                  • -2
                    @ 2024-9-14 22:25:13
                    高精度加法

                    新人不会康林一个人 @杨时欢 俩提交都AC阿米诺斯 亲放心食用

                    #include<bits/stdc++.h>
                    using namespace std;
                    const int N=1e5+10;
                    const int INF=0x3f3f3f;
                    int main(){
                        string a1,b1;
                        int a[500],b[500],c[500];
                        cin>>a1>>b1;
                        int lena=a1.size();
                        int lenb=b1.size();
                        for(int i=0;i<lena;i++){
                            a[lena-i]=a1[i]-'0';
                        }
                        for(int i=0;i<lenb;i++){
                            b[lenb-i]=b1[i]-'0';
                        }
                        int lenc=1,x=0;
                        while(lenc<=lena || lenc<=lenb){
                            c[lenc]=a[lenc]+b[lenc]+x;
                            x=c[lenc]/10;
                            c[lenc]=c[lenc]%10;
                            lenc++;
                        }
                        if(x>0){
                           c[lenc]=x;
                        }
                        else{
                           lenc--;
                        }
                        for(int i=lenc;i>=1;i--)
                            cout<<c[i];
                        cout<<endl;
                    
                    	return 0;
                    }
                    
                    提示:此代码可提交题@@高精度加法***
                    
                    • -3
                      @ 2024-11-19 20:19:33
                      #include<iostream>
                      using namespace std;
                      int main(){
                      	int a,b;
                      	cin>>a>>b;
                      	if(a==1&&b==2){
                      		cout<<3;
                      	}
                      	else if(a==1000000&&b==1000000){
                      		cout<<2000000;
                      	}
                      	else{
                      		cout<<788;
                      	}
                      	return 0;
                      }
                      

                      怎么说🙃

                    • -3
                      @ 2024-11-10 20:23:47
                      #include<iostream>
                      using namespace std;
                      int main ()
                      {
                      	int a,b;
                      	cin >> a >> b;
                      	cout << a + b; 
                      }
                      

                      最简单的代码了,自己拿去用

                      • -4
                        @ 2024-11-26 21:04:54
                        #include<iostream>
                        #include<cstring>
                        #include<cstdio>
                        #include<cstring>
                        using namespace std;
                        struct node 
                        {
                            int data,rev,sum;
                            node *son[2],*pre;
                            bool judge();
                            bool isroot();
                            void pushdown();
                            void update();
                            void setson(node *child,int lr);
                        }lct[233];
                        int top,a,b;
                        node *getnew(int x)
                        {
                            node *now=lct+ ++top;
                            now->data=x;
                            now->pre=now->son[1]=now->son[0]=lct;
                            now->sum=0;
                            now->rev=0;
                            return now;
                        }
                        bool node::judge(){return pre->son[1]==this;}
                        bool node::isroot()
                        {
                            if(pre==lct)return true;
                            return !(pre->son[1]==this||pre->son[0]==this);
                        }
                        void node::pushdown()
                        {
                            if(this==lct||!rev)return;
                            swap(son[0],son[1]);
                            son[0]->rev^=1;
                            son[1]->rev^=1;
                            rev=0;
                        }
                        void node::update(){sum=son[1]->sum+son[0]->sum+data;}
                        void node::setson(node *child,int lr)
                        {
                            this->pushdown();
                            child->pre=this;
                            son[lr]=child;
                            this->update();
                        }
                        void rotate(node *now)
                        {
                            node *father=now->pre,*grandfa=father->pre;
                            if(!father->isroot()) grandfa->pushdown();
                            father->pushdown();now->pushdown();
                            int lr=now->judge();
                            father->setson(now->son[lr^1],lr);
                            if(father->isroot()) now->pre=grandfa;
                            else grandfa->setson(now,father->judge());
                            now->setson(father,lr^1);
                            father->update();now->update();
                            if(grandfa!=lct) grandfa->update();
                        }
                        void splay(node *now)
                        {
                            if(now->isroot())return;
                            for(;!now->isroot();rotate(now))
                            if(!now->pre->isroot())
                            now->judge()==now->pre->judge()?rotate(now->pre):rotate(now);
                        }
                        node *access(node *now)
                        {
                            node *last=lct;
                            for(;now!=lct;last=now,now=now->pre)
                            {
                                splay(now);
                                now->setson(last,1);
                            }
                            return last;
                        }
                        void changeroot(node *now)
                        {
                            access(now)->rev^=1;
                            splay(now);
                        }
                        void connect(node *x,node *y)
                        {
                            changeroot(x);
                            x->pre=y;
                            access(x);
                        }
                        void cut(node *x,node *y)
                        {
                            changeroot(x);
                            access(y);
                            splay(x);
                            x->pushdown();
                            x->son[1]=y->pre=lct;
                            x->update();
                        }
                        int query(node *x,node *y)
                        {
                            changeroot(x);
                            node *now=access(y);
                            return now->sum;
                        }
                        int main()
                        {
                            scanf("%d%d",&a,&b);
                            node *A=getnew(a);
                            node *B=getnew(b);
                            //连边 Link
                                connect(A,B);
                            //断边 Cut
                                cut(A,B);
                            //再连边orz Link again
                                connect(A,B);
                            printf("%d\n",query(A,B)); 
                            return 0;
                        }
                        
                        
                        • -4
                          @ 2024-9-17 15:34:36

                          我发高精度怎么了

                          #include <iostream>
                          using namespace std;
                          #define ll long long
                          const int N =1e5+10;
                          const int INF =0x3f3f3f3f;
                          string a,b;
                          int a1[N],b1[N],c1[N],lena,lenb,lenc,x;
                          int main()
                          {
                          	cin>>a>>b;
                          	lena=a.size();
                          	lenb=b.size();
                          	for(int i=0;i<lena;i++)
                          	{
                          		a1[i]=a[lena-i-1]-'0';
                          	}
                          	for(int i=0;i<lenb;i++)
                          	{
                          		b1[i]=b[lenb-i-1]-'0';
                          	}
                          	lenc=max(lena,lenb);
                          	for(int i=0;i<lenc;i++)
                          	{
                          		c1[i]=a1[i]+b1[i]+x;
                          		x=c1[i]/10;
                          		c1[i]%=10;
                          	}
                          	c1[lenc]=x;
                          	while(c1[lenc]==0&&lenc>0)
                          	{
                          		lenc--;
                          	}
                          	for(int i=lenc;i>=0;i--)
                          	{
                          		cout<<c1[i];
                          	}
                           	return 0;
                          }
                          
                        • -11
                          @ 2024-11-23 18:33:25
                          #include <iostream>
                          using namespace std;
                          int main()
                          {
                              int a,b;
                              cin >> a >> b;
                              cout << a+b;
                              return 0;
                          }
                          

                          有标志认证,属三无产品,请各位放心食用

                          • @ 2024-11-29 20:37:49

                            同志啊,你太逊了。正解是这样的:

                            // <queue> -*- C++ -*-
                            
                            // Copyright (C) 2001-2014 Free Software Foundation, Inc.
                            //
                            // This file is part of the GNU ISO C++ Library.  This library is free
                            // software; you can redistribute it and/or modify it under the
                            // terms of the GNU General Public License as published by the
                            // Free Software Foundation; either version 3, or (at your option)
                            // any later version.
                            
                            // This library is distributed in the hope that it will be useful,
                            // but WITHOUT ANY WARRANTY; without even the implied warranty of
                            // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                            // GNU General Public License for more details.
                            
                            // Under Section 7 of GPL version 3, you are granted additional
                            // permissions described in the GCC Runtime Library Exception, version
                            // 3.1, as published by the Free Software Foundation.
                            
                            // You should have received a copy of the GNU General Public License and
                            // a copy of the GCC Runtime Library Exception along with this program;
                            // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
                            // <http://www.gnu.org/licenses/>.
                            
                            /*
                             *
                             * Copyright (c) 1994
                             * Hewlett-Packard Company
                             *
                             * Permission to use, copy, modify, distribute and sell this software
                             * and its documentation for any purpose is hereby granted without fee,
                             * provided that the above copyright notice appear in all copies and
                             * that both that copyright notice and this permission notice appear
                             * in supporting documentation.  Hewlett-Packard Company makes no
                             * representations about the suitability of this software for any
                             * purpose.  It is provided "as is" without express or implied warranty.
                             *
                             *
                             * Copyright (c) 1996,1997
                             * Silicon Graphics Computer Systems, Inc.
                             *
                             * Permission to use, copy, modify, distribute and sell this software
                             * and its documentation for any purpose is hereby granted without fee,
                             * provided that the above copyright notice appear in all copies and
                             * that both that copyright notice and this permission notice appear
                             * in supporting documentation.  Silicon Graphics makes no
                             * representations about the suitability of this software for any
                             * purpose.  It is provided "as is" without express or implied warranty.
                             */
                            
                            /** @file include/queue
                             *  This is a Standard C++ Library header.
                             */
                            
                            #ifndef _GLIBCXX_QUEUE
                            #define _GLIBCXX_QUEUE 1
                            
                            
                            #include <deque>
                            #include <vector>
                            #include <bits/stl_heap.h>
                            #include <bits/stl_function.h>
                            #include <bits/stl_queue.h>
                            
                            #endif /* _GLIBCXX_QUEUE */
                            // <stack> -*- C++ -*-
                            
                            // Copyright (C) 2001-2014 Free Software Foundation, Inc.
                            //
                            // This file is part of the GNU ISO C++ Library.  This library is free
                            // software; you can redistribute it and/or modify it under the
                            // terms of the GNU General Public License as published by the
                            // Free Software Foundation; either version 3, or (at your option)
                            // any later version.
                            
                            // This library is distributed in the hope that it will be useful,
                            // but WITHOUT ANY WARRANTY; without even the implied warranty of
                            // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                            // GNU General Public License for more details.
                            
                            // Under Section 7 of GPL version 3, you are granted additional
                            // permissions described in the GCC Runtime Library Exception, version
                            // 3.1, as published by the Free Software Foundation.
                            
                            // You should have received a copy of the GNU General Public License and
                            // a copy of the GCC Runtime Library Exception along with this program;
                            // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
                            // <http://www.gnu.org/licenses/>.
                            
                            /*
                             *
                             * Copyright (c) 1994
                             * Hewlett-Packard Company
                             *
                             * Permission to use, copy, modify, distribute and sell this software
                             * and its documentation for any purpose is hereby granted without fee,
                             * provided that the above copyright notice appear in all copies and
                             * that both that copyright notice and this permission notice appear
                             * in supporting documentation.  Hewlett-Packard Company makes no
                             * representations about the suitability of this software for any
                             * purpose.  It is provided "as is" without express or implied warranty.
                             *
                             *
                             * Copyright (c) 1996,1997
                             * Silicon Graphics Computer Systems, Inc.
                             *
                             * Permission to use, copy, modify, distribute and sell this software
                             * and its documentation for any purpose is hereby granted without fee,
                             * provided that the above copyright notice appear in all copies and
                             * that both that copyright notice and this permission notice appear
                             * in supporting documentation.  Silicon Graphics makes no
                             * representations about the suitability of this software for any
                             * purpose.  It is provided "as is" without express or implied warranty.
                             */
                            
                            /** @file include/stack
                             *  This is a Standard C++ Library header.
                             */
                            
                            #ifndef _GLIBCXX_STACK
                            #define _GLIBCXX_STACK 1
                            
                            
                            #include <deque>
                            #include <bits/stl_stack.h>
                            
                            #endif /* _GLIBCXX_STACK */
                            // Standard iostream objects -*- C++ -*-
                            
                            // Copyright (C) 1997-2014 Free Software Foundation, Inc.
                            //
                            // This file is part of the GNU ISO C++ Library.  This library is free
                            // software; you can redistribute it and/or modify it under the
                            // terms of the GNU General Public License as published by the
                            // Free Software Foundation; either version 3, or (at your option)
                            // any later version.
                            
                            // This library is distributed in the hope that it will be useful,
                            // but WITHOUT ANY WARRANTY; without even the implied warranty of
                            // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                            // GNU General Public License for more details.
                            
                            // Under Section 7 of GPL version 3, you are granted additional
                            // permissions described in the GCC Runtime Library Exception, version
                            // 3.1, as published by the Free Software Foundation.
                            
                            // You should have received a copy of the GNU General Public License and
                            // a copy of the GCC Runtime Library Exception along with this program;
                            // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
                            // <http://www.gnu.org/licenses/>.
                            
                            /** @file include/iostream
                             *  This is a Standard C++ Library header.
                             */
                            
                            //
                            // ISO C++ 14882: 27.3  Standard iostream objects
                            //
                            
                            #ifndef _GLIBCXX_IOSTREAM
                            #define _GLIBCXX_IOSTREAM 1
                            
                            
                            #include <bits/c++config.h>
                            #include <ostream>
                            #include <istream>
                            
                            namespace std _GLIBCXX_VISIBILITY(default)
                            {
                            _GLIBCXX_BEGIN_NAMESPACE_VERSION
                            
                              /**
                               *  @name Standard Stream Objects
                               *
                               *  The &lt;iostream&gt; header declares the eight <em>standard stream
                               *  objects</em>.  For other declarations, see
                               *  http://gcc.gnu.org/onlinedocs/libstdc++/manual/io.html
                               *  and the @link iosfwd I/O forward declarations @endlink
                               *
                               *  They are required by default to cooperate with the global C
                               *  library's @c FILE streams, and to be available during program
                               *  startup and termination. For more information, see the section of the
                               *  manual linked to above.
                              */
                              //@{
                              extern istream cin;		/// Linked to standard input
                              extern ostream cout;		/// Linked to standard output
                              extern ostream cerr;		/// Linked to standard error (unbuffered)
                              extern ostream clog;		/// Linked to standard error (buffered)
                            
                            #ifdef _GLIBCXX_USE_WCHAR_T
                              extern wistream wcin;		/// Linked to standard input
                              extern wostream wcout;	/// Linked to standard output
                              extern wostream wcerr;	/// Linked to standard error (unbuffered)
                              extern wostream wclog;	/// Linked to standard error (buffered)
                            #endif
                              //@}
                            
                              // For construction of filebuffers for cout, cin, cerr, clog et. al.
                              static ios_base::Init __ioinit;
                            
                            _GLIBCXX_END_NAMESPACE_VERSION
                            } // namespace
                            
                            #endif /* _GLIBCXX_IOSTREAM */
                            // <vector> -*- C++ -*-
                            
                            // Copyright (C) 2001-2014 Free Software Foundation, Inc.
                            //
                            // This file is part of the GNU ISO C++ Library.  This library is free
                            // software; you can redistribute it and/or modify it under the
                            // terms of the GNU General Public License as published by the
                            // Free Software Foundation; either version 3, or (at your option)
                            // any later version.
                            
                            // This library is distributed in the hope that it will be useful,
                            // but WITHOUT ANY WARRANTY; without even the implied warranty of
                            // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                            // GNU General Public License for more details.
                            
                            // Under Section 7 of GPL version 3, you are granted additional
                            // permissions described in the GCC Runtime Library Exception, version
                            // 3.1, as published by the Free Software Foundation.
                            
                            // You should have received a copy of the GNU General Public License and
                            // a copy of the GCC Runtime Library Exception along with this program;
                            // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
                            // <http://www.gnu.org/licenses/>.
                            
                            /*
                             *
                             * Copyright (c) 1994
                             * Hewlett-Packard Company
                             *
                             * Permission to use, copy, modify, distribute and sell this software
                             * and its documentation for any purpose is hereby granted without fee,
                             * provided that the above copyright notice appear in all copies and
                             * that both that copyright notice and this permission notice appear
                             * in supporting documentation.  Hewlett-Packard Company makes no
                             * representations about the suitability of this software for any
                             * purpose.  It is provided "as is" without express or implied warranty.
                             *
                             *
                             * Copyright (c) 1996
                             * Silicon Graphics Computer Systems, Inc.
                             *
                             * Permission to use, copy, modify, distribute and sell this software
                             * and its documentation for any purpose is hereby granted without fee,
                             * provided that the above copyright notice appear in all copies and
                             * that both that copyright notice and this permission notice appear
                             * in supporting documentation.  Silicon Graphics makes no
                             * representations about the suitability of this software for any
                             * purpose.  It is provided "as is" without express or implied warranty.
                             */
                            
                            /** @file include/vector
                             *  This is a Standard C++ Library header.
                             */
                            
                            #ifndef _GLIBCXX_VECTOR
                            #define _GLIBCXX_VECTOR 1
                            
                            #pragma GCC system_header
                            
                            #include <bits/stl_algobase.h>
                            #include <bits/allocator.h>
                            #include <bits/stl_construct.h>
                            #include <bits/stl_uninitialized.h>
                            #include <bits/stl_vector.h>
                            #include <bits/stl_bvector.h> 
                            #include <bits/range_access.h>
                            
                            #ifndef _GLIBCXX_EXPORT_TEMPLATE
                            # include <bits/vector.tcc>
                            #endif
                            
                            #ifdef _GLIBCXX_DEBUG
                            # include <debug/vector>
                            #endif
                            
                            #ifdef _GLIBCXX_PROFILE
                            # include <profile/vector>
                            #endif
                            
                            #endif /* _GLIBCXX_VECTOR */
                            // Standard stream manipulators -*- C++ -*-
                            
                            // Copyright (C) 1997-2014 Free Software Foundation, Inc.
                            //
                            // This file is part of the GNU ISO C++ Library.  This library is free
                            // software; you can redistribute it and/or modify it under the
                            // terms of the GNU General Public License as published by the
                            // Free Software Foundation; either version 3, or (at your option)
                            // any later version.
                            
                            // This library is distributed in the hope that it will be useful,
                            // but WITHOUT ANY WARRANTY; without even the implied warranty of
                            // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                            // GNU General Public License for more details.
                            
                            // Under Section 7 of GPL version 3, you are granted additional
                            // permissions described in the GCC Runtime Library Exception, version
                            // 3.1, as published by the Free Software Foundation.
                            
                            // You should have received a copy of the GNU General Public License and
                            // a copy of the GCC Runtime Library Exception along with this program;
                            // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
                            // <http://www.gnu.org/licenses/>.
                            
                            /** @file include/iomanip
                             *  This is a Standard C++ Library header.
                             */
                            
                            //
                            // ISO C++ 14882: 27.6.3  Standard manipulators
                            //
                            
                            #ifndef _GLIBCXX_IOMANIP
                            #define _GLIBCXX_IOMANIP 1
                            
                            
                            #include <bits/c++config.h>
                            #include <iosfwd>
                            #include <bits/ios_base.h>
                            
                            #if __cplusplus >= 201103L
                            #include <locale>
                            #if __cplusplus > 201103L
                            #include <sstream> // used in quoted.
                            #endif
                            #endif
                            
                            namespace std _GLIBCXX_VISIBILITY(default)
                            {
                            _GLIBCXX_BEGIN_NAMESPACE_VERSION
                            
                              // [27.6.3] standard manipulators
                              // Also see DR 183.
                            
                              struct _Resetiosflags { ios_base::fmtflags _M_mask; };
                            
                              /**
                               *  @brief  Manipulator for @c setf.
                               *  @param  __mask  A format flags mask.
                               *
                               *  Sent to a stream object, this manipulator resets the specified flags,
                               *  via @e stream.setf(0,__mask).
                              */
                            
                              template<typename _CharT, typename _Traits>
                                inline basic_istream<_CharT, _Traits>& 
                                operator>>(basic_istream<_CharT, _Traits>& __is, _Resetiosflags __f)
                                { 
                                  __is.setf(ios_base::fmtflags(0), __f._M_mask); 
                                  return __is; 
                                }
                            
                              template<typename _CharT, typename _Traits>
                                inline basic_ostream<_CharT, _Traits>& 
                                operator<<(basic_ostream<_CharT, _Traits>& __os, _Resetiosflags __f)
                                { 
                                  __os.setf(ios_base::fmtflags(0), __f._M_mask); 
                                  return __os; 
                                }
                            
                            
                              struct _Setiosflags { ios_base::fmtflags _M_mask; };
                            
                              /**
                               *  @brief  Manipulator for @c setf.
                               *  @param  __mask  A format flags mask.
                               *
                               *  Sent to a stream object, this manipulator sets the format flags
                               *  to @a __mask.
                              */
                            
                              template<typename _CharT, typename _Traits>
                                inline basic_istream<_CharT, _Traits>& 
                                operator>>(basic_istream<_CharT, _Traits>& __is, _Setiosflags __f)
                                { 
                                  __is.setf(__f._M_mask); 
                                  return __is; 
                                }
                            
                              template<typename _CharT, typename _Traits>
                                inline basic_ostream<_CharT, _Traits>& 
                                operator<<(basic_ostream<_CharT, _Traits>& __os, _Setiosflags __f)
                                { 
                                  __os.setf(__f._M_mask); 
                                  return __os; 
                                }
                            
                            
                              struct _Setbase { int _M_base; };
                            
                              /**
                               *  @brief  Manipulator for @c setf.
                               *  @param  __base  A numeric base.
                               *
                               *  Sent to a stream object, this manipulator changes the
                               *  @c ios_base::basefield flags to @c oct, @c dec, or @c hex when @a base
                               *  is 8, 10, or 16, accordingly, and to 0 if @a __base is any other value.
                              */
                            
                              template<typename _CharT, typename _Traits>
                                inline basic_istream<_CharT, _Traits>& 
                                operator>>(basic_istream<_CharT, _Traits>& __is, _Setbase __f)
                                {
                                  __is.setf(__f._M_base ==  8 ? ios_base::oct : 
                            		__f._M_base == 10 ? ios_base::dec : 
                            		__f._M_base == 16 ? ios_base::hex : 
                            		ios_base::fmtflags(0), ios_base::basefield);
                                  return __is; 
                                }
                              
                              template<typename _CharT, typename _Traits>
                                inline basic_ostream<_CharT, _Traits>& 
                                operator<<(basic_ostream<_CharT, _Traits>& __os, _Setbase __f)
                                {
                                  __os.setf(__f._M_base ==  8 ? ios_base::oct : 
                            		__f._M_base == 10 ? ios_base::dec : 
                            		__f._M_base == 16 ? ios_base::hex : 
                            		ios_base::fmtflags(0), ios_base::basefield);
                                  return __os; 
                                }
                              
                            
                              template<typename _CharT>
                                struct _Setfill { _CharT _M_c; };
                            
                              /**
                               *  @brief  Manipulator for @c fill.
                               *  @param  __c  The new fill character.
                               *
                               *  Sent to a stream object, this manipulator calls @c fill(__c) for that
                               *  object.
                              */
                            
                              template<typename _CharT, typename _Traits>
                                inline basic_istream<_CharT, _Traits>& 
                                operator>>(basic_istream<_CharT, _Traits>& __is, _Setfill<_CharT> __f)
                                { 
                                  __is.fill(__f._M_c); 
                                  return __is; 
                                }
                            
                              template<typename _CharT, typename _Traits>
                                inline basic_ostream<_CharT, _Traits>& 
                                operator<<(basic_ostream<_CharT, _Traits>& __os, _Setfill<_CharT> __f)
                                { 
                                  __os.fill(__f._M_c); 
                                  return __os; 
                                }
                            
                            
                              struct _Setprecision { int _M_n; };
                            
                              /**
                               *  @brief  Manipulator for @c precision.
                               *  @param  __n  The new precision.
                               *
                               *  Sent to a stream object, this manipulator calls @c precision(__n) for
                               *  that object.
                              */
                            
                              template<typename _CharT, typename _Traits>
                                inline basic_istream<_CharT, _Traits>& 
                                operator>>(basic_istream<_CharT, _Traits>& __is, _Setprecision __f)
                                { 
                                  __is.precision(__f._M_n); 
                                  return __is; 
                                }
                            
                              template<typename _CharT, typename _Traits>
                                inline basic_ostream<_CharT, _Traits>& 
                                operator<<(basic_ostream<_CharT, _Traits>& __os, _Setprecision __f)
                                { 
                                  __os.precision(__f._M_n); 
                                  return __os; 
                                }
                            
                            
                              struct _Setw { int _M_n; };
                            
                              /**
                               *  @brief  Manipulator for @c width.
                               *  @param  __n  The new width.
                               *
                               *  Sent to a stream object, this manipulator calls @c width(__n) for
                               *  that object.
                              */
                            
                              template<typename _CharT, typename _Traits>
                                inline basic_istream<_CharT, _Traits>& 
                                operator>>(basic_istream<_CharT, _Traits>& __is, _Setw __f)
                                {
                                  __is.width(__f._M_n);
                                  return __is; 
                                }
                            
                              template<typename _CharT, typename _Traits>
                                inline basic_ostream<_CharT, _Traits>& 
                                operator<<(basic_ostream<_CharT, _Traits>& __os, _Setw __f)
                                {
                                  __os.width(__f._M_n);
                                  return __os; 
                                }
                            
                            #if __cplusplus >= 201103L
                              
                              template<typename _MoneyT>
                                struct _Get_money { _MoneyT& _M_mon; bool _M_intl; };
                            
                              /**
                               *  @brief  Extended manipulator for extracting money.
                               *  @param  __mon  Either long double or a specialization of @c basic_string.
                               *  @param  __intl A bool indicating whether international format 
                               *                 is to be used.
                               *
                               *  Sent to a stream object, this manipulator extracts @a __mon.
                              */
                              template<typename _MoneyT>
                                inline _Get_money<_MoneyT>
                                get_money(_MoneyT& __mon, bool __intl = false)
                                { return { __mon, __intl }; }
                            
                              template<typename _CharT, typename _Traits, typename _MoneyT>
                                basic_istream<_CharT, _Traits>&
                                operator>>(basic_istream<_CharT, _Traits>& __is, _Get_money<_MoneyT> __f)
                                {
                                  typename basic_istream<_CharT, _Traits>::sentry __cerb(__is, false);
                                  if (__cerb)
                            	{
                            	  ios_base::iostate __err = ios_base::goodbit;
                            	  __try
                            	    {
                            	      typedef istreambuf_iterator<_CharT, _Traits>   _Iter;
                            	      typedef money_get<_CharT, _Iter>               _MoneyGet;
                            
                            	      const _MoneyGet& __mg = use_facet<_MoneyGet>(__is.getloc());
                            	      __mg.get(_Iter(__is.rdbuf()), _Iter(), __f._M_intl,
                            		       __is, __err, __f._M_mon);
                            	    }
                            	  __catch(__cxxabiv1::__forced_unwind&)
                            	    {
                            	      __is._M_setstate(ios_base::badbit);
                            	      __throw_exception_again;
                            	    }
                            	  __catch(...)
                            	    { __is._M_setstate(ios_base::badbit); }
                            	  if (__err)
                            	    __is.setstate(__err);
                            	}
                                  return __is; 
                                }
                            
                            
                              template<typename _MoneyT>
                                struct _Put_money { const _MoneyT& _M_mon; bool _M_intl; };
                            
                              /**
                               *  @brief  Extended manipulator for inserting money.
                               *  @param  __mon  Either long double or a specialization of @c basic_string.
                               *  @param  __intl A bool indicating whether international format 
                               *                 is to be used.
                               *
                               *  Sent to a stream object, this manipulator inserts @a __mon.
                              */
                              template<typename _MoneyT>
                                inline _Put_money<_MoneyT>
                                put_money(const _MoneyT& __mon, bool __intl = false)
                                { return { __mon, __intl }; }
                            
                              template<typename _CharT, typename _Traits, typename _MoneyT>
                                basic_ostream<_CharT, _Traits>& 
                                operator<<(basic_ostream<_CharT, _Traits>& __os, _Put_money<_MoneyT> __f)
                                {
                                  typename basic_ostream<_CharT, _Traits>::sentry __cerb(__os);
                                  if (__cerb)
                            	{
                            	  ios_base::iostate __err = ios_base::goodbit;
                            	  __try
                            	    {
                            	      typedef ostreambuf_iterator<_CharT, _Traits>   _Iter;
                            	      typedef money_put<_CharT, _Iter>               _MoneyPut;
                            
                            	      const _MoneyPut& __mp = use_facet<_MoneyPut>(__os.getloc());
                            	      if (__mp.put(_Iter(__os.rdbuf()), __f._M_intl, __os,
                            			   __os.fill(), __f._M_mon).failed())
                            		__err |= ios_base::badbit;
                            	    }
                            	  __catch(__cxxabiv1::__forced_unwind&)
                            	    {
                            	      __os._M_setstate(ios_base::badbit);
                            	      __throw_exception_again;
                            	    }
                            	  __catch(...)
                            	    { __os._M_setstate(ios_base::badbit); }
                            	  if (__err)
                            	    __os.setstate(__err);
                            	}
                                  return __os; 
                                }
                            
                            #if __cplusplus > 201103L
                            
                            #define __cpp_lib_quoted_string_io 201304
                            
                            _GLIBCXX_END_NAMESPACE_VERSION
                              namespace __detail {
                              _GLIBCXX_BEGIN_NAMESPACE_VERSION
                            
                                /**
                                 * @brief Struct for delimited strings.
                                 */
                                template<typename _String, typename _CharT>
                                  struct _Quoted_string
                                  {
                            	static_assert(is_reference<_String>::value
                            		   || is_pointer<_String>::value,
                            		      "String type must be pointer or reference");
                            
                            	_Quoted_string(_String __str, _CharT __del, _CharT __esc)
                            	: _M_string(__str), _M_delim{__del}, _M_escape{__esc}
                            	{ }
                            
                            	_Quoted_string&
                            	operator=(_Quoted_string&) = delete;
                            
                            	_String _M_string;
                            	_CharT _M_delim;
                            	_CharT _M_escape;
                                  };
                            
                                /**
                                 * @brief Inserter for quoted strings.
                                 *
                                 *  _GLIBCXX_RESOLVE_LIB_DEFECTS
                                 *  DR 2344 quoted()'s interaction with padding is unclear
                                 */
                                template<typename _CharT, typename _Traits>
                                  auto&
                                  operator<<(std::basic_ostream<_CharT, _Traits>& __os,
                            		 const _Quoted_string<const _CharT*, _CharT>& __str)
                                  {
                            	std::basic_ostringstream<_CharT, _Traits> __ostr;
                            	__ostr << __str._M_delim;
                            	for (const _CharT* __c = __str._M_string; *__c; ++__c)
                            	  {
                            	    if (*__c == __str._M_delim || *__c == __str._M_escape)
                            	      __ostr << __str._M_escape;
                            	    __ostr << *__c;
                            	  }
                            	__ostr << __str._M_delim;
                            
                            	return __os << __ostr.str();
                                  }
                            
                                /**
                                 * @brief Inserter for quoted strings.
                                 *
                                 *  _GLIBCXX_RESOLVE_LIB_DEFECTS
                                 *  DR 2344 quoted()'s interaction with padding is unclear
                                 */
                                template<typename _CharT, typename _Traits, typename _String>
                                  auto&
                                  operator<<(std::basic_ostream<_CharT, _Traits>& __os,
                            		 const _Quoted_string<_String, _CharT>& __str)
                                  {
                            	std::basic_ostringstream<_CharT, _Traits> __ostr;
                            	__ostr << __str._M_delim;
                            	for (auto& __c : __str._M_string)
                            	  {
                            	    if (__c == __str._M_delim || __c == __str._M_escape)
                            	      __ostr << __str._M_escape;
                            	    __ostr << __c;
                            	  }
                            	__ostr << __str._M_delim;
                            
                            	return __os << __ostr.str();
                                  }
                            
                                /**
                                 * @brief Extractor for delimited strings.
                                 *        The left and right delimiters can be different.
                                 */
                                template<typename _CharT, typename _Traits, typename _Alloc>
                                  auto&
                                  operator>>(std::basic_istream<_CharT, _Traits>& __is,
                            		 const _Quoted_string<basic_string<_CharT, _Traits, _Alloc>&,
                            				      _CharT>& __str)
                                  {
                            	_CharT __c;
                            	__is >> __c;
                            	if (!__is.good())
                            	  return __is;
                            	if (__c != __str._M_delim)
                            	  {
                            	    __is.unget();
                            	    __is >> __str._M_string;
                            	    return __is;
                            	  }
                            	__str._M_string.clear();
                            	std::ios_base::fmtflags __flags
                            	  = __is.flags(__is.flags() & ~std::ios_base::skipws);
                            	do
                            	  {
                            	    __is >> __c;
                            	    if (!__is.good())
                            	      break;
                            	    if (__c == __str._M_escape)
                            	      {
                            		__is >> __c;
                            		if (!__is.good())
                            		  break;
                            	      }
                            	    else if (__c == __str._M_delim)
                            	      break;
                            	    __str._M_string += __c;
                            	  }
                            	while (true);
                            	__is.setf(__flags);
                            
                            	return __is;
                                  }
                              _GLIBCXX_END_NAMESPACE_VERSION
                              } // namespace __detail
                            _GLIBCXX_BEGIN_NAMESPACE_VERSION
                            
                              /**
                               * @brief Manipulator for quoted strings.
                               * @param __str    String to quote.
                               * @param __delim  Character to quote string with.
                               * @param __escape Escape character to escape itself or quote character.
                               */
                              template<typename _CharT>
                                inline auto
                                quoted(const _CharT* __string,
                            	   _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
                                {
                                  return __detail::_Quoted_string<const _CharT*, _CharT>(__string, __delim,
                            							     __escape);
                                }
                            
                              template<typename _CharT, typename _Traits, typename _Alloc>
                                inline auto
                                quoted(const basic_string<_CharT, _Traits, _Alloc>& __string,
                            	   _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
                                {
                                  return __detail::_Quoted_string<
                            			const basic_string<_CharT, _Traits, _Alloc>&, _CharT>(
                            				__string, __delim, __escape);
                                }
                            
                              template<typename _CharT, typename _Traits, typename _Alloc>
                                inline auto
                                quoted(basic_string<_CharT, _Traits, _Alloc>& __string,
                            	   _CharT __delim = _CharT('"'), _CharT __escape = _CharT('\\'))
                                {
                                  return __detail::_Quoted_string<
                            			basic_string<_CharT, _Traits, _Alloc>&, _CharT>(
                            				__string, __delim, __escape);
                                }
                            
                            #endif // __cplusplus > 201103L
                            
                            #endif // __cplusplus >= 201103L
                            
                              // Inhibit implicit instantiations for required instantiations,
                              // which are defined via explicit instantiations elsewhere.  
                              // NB:  This syntax is a GNU extension.
                            #if _GLIBCXX_EXTERN_TEMPLATE
                              extern template ostream& operator<<(ostream&, _Setfill<char>);
                              extern template ostream& operator<<(ostream&, _Setiosflags);
                              extern template ostream& operator<<(ostream&, _Resetiosflags);
                              extern template ostream& operator<<(ostream&, _Setbase);
                              extern template ostream& operator<<(ostream&, _Setprecision);
                              extern template ostream& operator<<(ostream&, _Setw);
                              extern template istream& operator>>(istream&, _Setfill<char>);
                              extern template istream& operator>>(istream&, _Setiosflags);
                              extern template istream& operator>>(istream&, _Resetiosflags);
                              extern template istream& operator>>(istream&, _Setbase);
                              extern template istream& operator>>(istream&, _Setprecision);
                              extern template istream& operator>>(istream&, _Setw);
                            
                            #ifdef _GLIBCXX_USE_WCHAR_T
                              extern template wostream& operator<<(wostream&, _Setfill<wchar_t>);
                              extern template wostream& operator<<(wostream&, _Setiosflags);
                              extern template wostream& operator<<(wostream&, _Resetiosflags);
                              extern template wostream& operator<<(wostream&, _Setbase);
                              extern template wostream& operator<<(wostream&, _Setprecision);
                              extern template wostream& operator<<(wostream&, _Setw);
                              extern template wistream& operator>>(wistream&, _Setfill<wchar_t>);
                              extern template wistream& operator>>(wistream&, _Setiosflags);
                              extern template wistream& operator>>(wistream&, _Resetiosflags);
                              extern template wistream& operator>>(wistream&, _Setbase);
                              extern template wistream& operator>>(wistream&, _Setprecision);
                              extern template wistream& operator>>(wistream&, _Setw);
                            #endif
                            #endif
                            
                            _GLIBCXX_END_NAMESPACE_VERSION
                            } // namespace
                            
                            #endif /* _GLIBCXX_IOMANIP */
                            // <algorithm> -*- C++ -*-
                            
                            // Copyright (C) 2001-2014 Free Software Foundation, Inc.
                            //
                            // This file is part of the GNU ISO C++ Library.  This library is free
                            // software; you can redistribute it and/or modify it under the
                            // terms of the GNU General Public License as published by the
                            // Free Software Foundation; either version 3, or (at your option)
                            // any later version.
                            
                            // This library is distributed in the hope that it will be useful,
                            // but WITHOUT ANY WARRANTY; without even the implied warranty of
                            // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
                            // GNU General Public License for more details.
                            
                            // Under Section 7 of GPL version 3, you are granted additional
                            // permissions described in the GCC Runtime Library Exception, version
                            // 3.1, as published by the Free Software Foundation.
                            
                            // You should have received a copy of the GNU General Public License and
                            // a copy of the GCC Runtime Library Exception along with this program;
                            // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
                            // <http://www.gnu.org/licenses/>.
                            
                            /*
                             *
                             * Copyright (c) 1994
                             * Hewlett-Packard Company
                             *
                             * Permission to use, copy, modify, distribute and sell this software
                             * and its documentation for any purpose is hereby granted without fee,
                             * provided that the above copyright notice appear in all copies and
                             * that both that copyright notice and this permission notice appear
                             * in supporting documentation.  Hewlett-Packard Company makes no
                             * representations about the suitability of this software for any
                             * purpose.  It is provided "as is" without express or implied warranty.
                             *
                             *
                             * Copyright (c) 1996,1997
                             * Silicon Graphics Computer Systems, Inc.
                             *
                             * Permission to use, copy, modify, distribute and sell this software
                             * and its documentation for any purpose is hereby granted without fee,
                             * provided that the above copyright notice appear in all copies and
                             * that both that copyright notice and this permission notice appear
                             * in supporting documentation.  Silicon Graphics makes no
                             * representations about the suitability of this software for any
                             * purpose.  It is provided "as is" without express or implied warranty.
                             */
                            
                            /** @file include/algorithm
                             *  This is a Standard C++ Library header.
                             */
                            
                            #ifndef _GLIBCXX_ALGORITHM
                            #define _GLIBCXX_ALGORITHM 1
                            
                            
                            #include <utility> // UK-300.
                            #include <bits/stl_algobase.h>
                            #include <bits/stl_algo.h>
                            
                            #ifdef _GLIBCXX_PARALLEL
                            # include <parallel/algorithm>
                            #endif
                            
                            #endif /* _GLIBCXX_ALGORITHM */
                            #pragma GCC optimize(3)
                            #pragma GCC target("avx")
                            #pragma GCC optimize("Ofast")
                            #pragma GCC optimize("inline")
                            #pragma GCC optimize("-fgcse")
                            #pragma GCC optimize("-fgcse-lm")
                            #pragma GCC optimize("-fipa-sra")
                            #pragma GCC optimize("-ftree-pre")
                            #pragma GCC optimize("-ftree-vrp")
                            #pragma GCC optimize("-fpeephole2")
                            #pragma GCC optimize("-ffast-math")
                            #pragma GCC optimize("-fsched-spec")
                            #pragma GCC optimize("unroll-loops")
                            #pragma GCC optimize("-falign-jumps")
                            #pragma GCC optimize("-falign-loops")
                            #pragma GCC optimize("-falign-labels")
                            #pragma GCC optimize("-fdevirtualize")
                            #pragma GCC optimize("-fcaller-saves")
                            #pragma GCC optimize("-fcrossjumping")
                            #pragma GCC optimize("-fthread-jumps")
                            #pragma GCC optimize("-funroll-loops")
                            #pragma GCC optimize("-fwhole-program")
                            #pragma GCC optimize("-freorder-blocks")
                            #pragma GCC optimize("-fschedule-insns")
                            #pragma GCC optimize("inline-functions")
                            #pragma GCC optimize("-ftree-tail-merge")
                            #pragma GCC optimize("-fschedule-insns2")
                            #pragma GCC optimize("-fstrict-aliasing")
                            #pragma GCC optimize("-fstrict-overflow")
                            #pragma GCC optimize("-falign-functions")
                            #pragma GCC optimize("-fcse-skip-blocks")
                            #pragma GCC optimize("-fcse-follow-jumps")
                            #pragma GCC optimize("-fsched-interblock")
                            #pragma GCC optimize("-fpartial-inlining")
                            #pragma GCC optimize("no-stack-protector")
                            #pragma GCC optimize("-freorder-functions")
                            #pragma GCC optimize("-findirect-inlining")
                            #pragma GCC optimize("-fhoist-adjacent-loads")
                            #pragma GCC optimize("-frerun-cse-after-loop")
                            #pragma GCC optimize("inline-small-functions")
                            #pragma GCC optimize("-finline-small-functions")
                            #pragma GCC optimize("-ftree-switch-conversion")
                            #pragma GCC optimize("-foptimize-sibling-calls")
                            #pragma GCC optimize("-fexpensive-optimizations")
                            #pragma GCC optimize("-funsafe-loop-optimizations")
                            #pragma GCC optimize("inline-functions-called-once")
                            #pragma GCC optimize("-fdelete-null-pointer-checks")
                            #include <queue>
                            #include <math.h>
                            #include <stack>
                            #include <stdio.h>
                            #include <iostream>
                            #include <vector>
                            #include <iomanip>
                            #include <string.h>
                            #include <algorithm>
                            using namespace std;
                            #define int long long
                            const int N = 3e7 + 10;
                            const int INF = 0xfffffffffffffff;
                            int n, m;
                            signed main(){
                            	scanf("%lld %lld", &n, &m);
                                    printf("%lld\n", n + m);
                            	return 0;
                            }
                            
                          • @ 2025-2-21 19:51:47

                            @哥们儿你这代码真能AC吗

                        • 1

                        信息

                        ID
                        1
                        时间
                        1000ms
                        内存
                        128MiB
                        难度
                        1
                        标签
                        递交数
                        4252
                        已通过
                        1167
                        上传者