比一比谁的代码更长

我的代码(不是用来比的)

#include <bits/stdc++.h>
using namespace std;

int a, b, c[100], lc = 1;
priority_queue<int> h;

int main() {
	scanf("%d%d", &a, &b);
	h.push(a);
	h.push(b);
	memset(c, 0, sizeof(c));
	while (!h.empty()) {
		int x = h.top();
		h.pop();
		if (x > 1) {
			h.push(x - 1);
			h.push(1);
		}
		else {
			c[1] += x;
			for (int i = 1; i <= lc; i++) {
				c[i + 1] += c[i] / 10;
				c[i] %= 10;
			}
			if (c[lc + 1] > 0)
				lc++;
		}
	}
	for (int i = lc; i >= 1; i--)
		printf("%d", c[i]);
	printf("\n");
	return 0;
}

亮出你们的杰作吧！

前提是这段代码能Accepted！

12 条评论

  • @ 2025-4-15 21:41:22

    从前有一个东西叫做洛谷Luogu。

    #include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <cmath>
#include <thread>
#include <chrono>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <functional>
#include <memory>
#include <random>
#include <numeric>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <climits>
#include <cfloat>
#include <cstddef>
#include <cstdint>
#include <cassert>
#include <cwchar>
#include <cwctype>
#include <exception>
#include <stdexcept>
#include <typeinfo>
#include <type_traits>
#include <bitset>
#include <complex>
#include <valarray>
#include <array>
#include <forward_list>
#include <list>
#include <deque>
#include <initializer_list>
#include <tuple>
#include <utility>
#include <variant>
#include <optional>
#include <any>
#include <filesystem>
#include <regex>
#include <atomic>
#include <mutex>
#include <condition_variable>
#include <future>
#include <shared_mutex>
#include <execution>
#include <codecvt>
#include <locale>
#include <ciso646>
#include <cerrno>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdarg>
#include <cstdbool>
#include <ctgmath>
#include <cuchar>
#include <limits>
#include <ios>
#include <iosfwd>
#include <istream>
#include <ostream>
#include <streambuf>
#include <sstream>
#include <iomanip>
#include <bits/stdc++.h>
using namespace std;
int read() {
	int k=0,f=1;
	char c=getchar();
	while(c<'0'||c>'9') {
		if(c=='-') {
			f=-1;
		}
		c=getchar();
	}
	while(c>='0'&&c<='9') {
		k=k*10+c-'0';
		c=getchar();
	}
	return k*f;
}
void write(int x) {
	if(x<0) {
		putchar('-');
		x=-x;
	}
	if(x<10) {
		putchar(x+'0');
	} else {
		write(x/10);
		putchar(x%10+'0');
	}
	return ;
}
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;
	return ;
}
void node::update() {
	sum=son[1]->sum+son[0]->sum+data;
	return ;
}
void node::setson(node *child,int lr) {
	this->pushdown();
	child->pre=this;
	son[lr]=child;
	this->update();
	return ;
}
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();
	}
	return ;
}
void splay(node *now) {
	if(now->isroot()) {
		return;
	}
	for(; !now->isroot(); rotate(now)) {
		if(!now->pre->isroot()) {
			if(now->judge()==now->pre->judge()) {
				rotate(now->pre);
			} else {
				rotate(now);
			}
		}
	}
	return ;
}
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);
	return ;
}
void connect(node *x,node *y) {
	changeroot(x);
	x->pre=y;
	access(x);
	return ;
}
void cut(node *x,node *y) {
	changeroot(x);
	access(y);
	splay(x);
	x->pushdown();
	x->son[1]=y->pre=lct;
	x->update();
	return ;
}
int query(node *x,node *y) {
	changeroot(x);
	node *now=access(y);
	return now->sum;
	return ;
}
int main() {
	a=read();
	b=read();
	node *A=getnew(a);
	node *B=getnew(b);
	connect(A,B);
	cut(A,B);
	connect(A,B);
	wirte(query(A,B));
	return 0;
}
  • @ 2025-4-13 20:25:30 
    // RTTI support for -*- C++ -*-
// Copyright (C) 1994-2021 Free Software Foundation, Inc.
//
// This file is part of GCC.
//
// GCC 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.
//
// GCC 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 typeinfo
 *  This is a Standard C++ Library header.
 */

#ifndef _TYPEINFO
#define _TYPEINFO

#pragma GCC system_header

#include <bits/exception.h>
#if __cplusplus >= 201103L
#include <bits/hash_bytes.h>
#endif

#pragma GCC visibility push(default)

extern "C++" {

namespace __cxxabiv1
{
  class __class_type_info;
} // namespace __cxxabiv1

// Determine whether typeinfo names for the same type are merged (in which
// case comparison can just compare pointers) or not (in which case strings
// must be compared), and whether comparison is to be implemented inline or
// not.  We used to do inline pointer comparison by default if weak symbols
// are available, but even with weak symbols sometimes names are not merged
// when objects are loaded with RTLD_LOCAL, so now we always use strcmp by
// default.  For ABI compatibility, we do the strcmp inline if weak symbols
// are available, and out-of-line if not.  Out-of-line pointer comparison
// is used where the object files are to be portable to multiple systems,
// some of which may not be able to use pointer comparison, but the
// particular system for which libstdc++ is being built can use pointer
// comparison; in particular for most ARM EABI systems, where the ABI
// specifies out-of-line comparison.  The compiler's target configuration
// can override the defaults by defining __GXX_TYPEINFO_EQUALITY_INLINE to
// 1 or 0 to indicate whether or not comparison is inline, and
// __GXX_MERGED_TYPEINFO_NAMES to 1 or 0 to indicate whether or not pointer
// comparison can be used.

#ifndef __GXX_MERGED_TYPEINFO_NAMES
// By default, typeinfo names are not merged.
#define __GXX_MERGED_TYPEINFO_NAMES 0
#endif

// By default follow the old inline rules to avoid ABI changes.
#ifndef __GXX_TYPEINFO_EQUALITY_INLINE
  #if !__GXX_WEAK__
    #define __GXX_TYPEINFO_EQUALITY_INLINE 0
  #else
    #define __GXX_TYPEINFO_EQUALITY_INLINE 1
  #endif
#endif

namespace std
{
  /**
   *  @brief  Part of RTTI.
   *
   *  The @c type_info class describes type information generated by
   *  an implementation.
  */
  class type_info
  {
  public:
    /** Destructor first. Being the first non-inline virtual function, this
     *  controls in which translation unit the vtable is emitted. The
     *  compiler makes use of that information to know where to emit
     *  the runtime-mandated type_info structures in the new-abi.  */
    virtual ~type_info();

    /** Returns an @e implementation-defined byte string; this is not
     *  portable between compilers!  */
    const char* name() const _GLIBCXX_NOEXCEPT
    { return __name[0] == '*' ? __name + 1 : __name; }

#if !__GXX_TYPEINFO_EQUALITY_INLINE
    // In old abi, or when weak symbols are not supported, there can
    // be multiple instances of a type_info object for one
    // type. Uniqueness must use the _name value, not object address.
    bool before(const type_info& __arg) const _GLIBCXX_NOEXCEPT;
    bool operator==(const type_info& __arg) const _GLIBCXX_NOEXCEPT;
#else
  #if !__GXX_MERGED_TYPEINFO_NAMES
    /** Returns true if @c *this precedes @c __arg in the implementation's
     *  collation order.  */
    // Even with the new abi, on systems that support dlopen
    // we can run into cases where type_info names aren't merged,
    // so we still need to do string comparison.
    bool before(const type_info& __arg) const _GLIBCXX_NOEXCEPT
    { return (__name[0] == '*' && __arg.__name[0] == '*')
	? __name < __arg.__name
	: __builtin_strcmp (__name, __arg.__name) < 0; }

    bool operator==(const type_info& __arg) const _GLIBCXX_NOEXCEPT
    {
      return ((__name == __arg.__name)
	      || (__name[0] != '*' &&
		  __builtin_strcmp (__name, __arg.__name) == 0));
    }
  #else
    // On some targets we can rely on type_info's NTBS being unique,
    // and therefore address comparisons are sufficient.
    bool before(const type_info& __arg) const _GLIBCXX_NOEXCEPT
    { return __name < __arg.__name; }

    bool operator==(const type_info& __arg) const _GLIBCXX_NOEXCEPT
    { return __name == __arg.__name; }
  #endif
#endif

#if __cpp_impl_three_way_comparison < 201907L
    bool operator!=(const type_info& __arg) const _GLIBCXX_NOEXCEPT
    { return !operator==(__arg); }
#endif

#if __cplusplus >= 201103L
    size_t hash_code() const noexcept
    {
#  if !__GXX_MERGED_TYPEINFO_NAMES
      return _Hash_bytes(name(), __builtin_strlen(name()),
			 static_cast<size_t>(0xc70f6907UL));
#  else
      return reinterpret_cast<size_t>(__name);
#  endif
    }
#endif // C++11

    // Return true if this is a pointer type of some kind
    virtual bool __is_pointer_p() const;

    // Return true if this is a function type
    virtual bool __is_function_p() const;

    // Try and catch a thrown type. Store an adjusted pointer to the
    // caught type in THR_OBJ. If THR_TYPE is not a pointer type, then
    // THR_OBJ points to the thrown object. If THR_TYPE is a pointer
    // type, then THR_OBJ is the pointer itself. OUTER indicates the
    // number of outer pointers, and whether they were const
    // qualified.
    virtual bool __do_catch(const type_info *__thr_type, void **__thr_obj,
			    unsigned __outer) const;

    // Internally used during catch matching
    virtual bool __do_upcast(const __cxxabiv1::__class_type_info *__target,
			     void **__obj_ptr) const;

  protected:
    const char *__name;

    explicit type_info(const char *__n): __name(__n) { }

  private:
    /// Assigning type_info is not supported.
    type_info& operator=(const type_info&);
    type_info(const type_info&);
  };

  /**
   *  @brief  Thrown during incorrect typecasting.
   *  @ingroup exceptions
   *
   *  If you attempt an invalid @c dynamic_cast expression, an instance of
   *  this class (or something derived from this class) is thrown.  */
  class bad_cast : public exception
  {
  public:
    bad_cast() _GLIBCXX_USE_NOEXCEPT { }

    // This declaration is not useless:
    // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
    virtual ~bad_cast() _GLIBCXX_USE_NOEXCEPT;

    // See comment in eh_exception.cc.
    virtual const char* what() const _GLIBCXX_USE_NOEXCEPT;
  };

  /**
   *  @brief Thrown when a NULL pointer in a @c typeid expression is used.
   *  @ingroup exceptions
   */
  class bad_typeid : public exception
  {
  public:
    bad_typeid () _GLIBCXX_USE_NOEXCEPT { }

    // This declaration is not useless:
    // http://gcc.gnu.org/onlinedocs/gcc-3.0.2/gcc_6.html#SEC118
    virtual ~bad_typeid() _GLIBCXX_USE_NOEXCEPT;

    // See comment in eh_exception.cc.
    virtual const char* what() const _GLIBCXX_USE_NOEXCEPT;
  };
} // namespace std

} // extern "C++"

#pragma GCC visibility pop

#endif
    • @ 2025-4-13 20:16:18 
      #include<bits/stdc++.h>
using namespace std;
#define int long long
#define endl '\n'
#define all(x) x.begin(),x.end()
#define fi first
#define se second
#define pb push_back
#define mp make_pair
#define pii pair<int,int>
#define vi vector<int>
#define vpii vector<pair<int,int>>
#define vvi vector<vector<int>>
#define vpi vector<pair<int,int>>
#define vvpi vector<vector<pair<int,int>>>
#define vll vector<long long>
#define vvl vector<vector<long long>>
#define vvi vector<vector<int>>
#define vvvi vector<vector<vector<int>>>
#define vvvvi vector<vector<vector<vector<int>>>>
#define vvvi vector<vector<vector<int>>>
#define vvvvi vector<vector<vector<vector<int>>>>
#define vvvvvi vector<vector<vector<vector<vector<int>>>>>
#define vvvvvi vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvi vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvi vector<vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvvi vector<vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvvvi vector<vector<vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvvvvi vector<vector<vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvvvvvi vector<vector<vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvvvvvvi vector<vector<vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvvvvvvvi vector<vector<vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvvvvvvvvi vector<vector<vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvvvvvvvvvi vector<vector<vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvvvvvvvvvvi vector<vector<vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvvvvvvvvvvvi vector<vector<vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvvvvvvvvvvvvi vector<vector<vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvvvvvvvvvvvvvi vector<vector<vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvvvvvvvvvvvvvvi vector<vector<vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvvvvvvvvvvvvvvi vector<vector<vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvvvvvvvvvvvvvvvi vector<vector<vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvvvvvvvvvvvvvvi vector<vector<vector<vector<vector<vector<vector<int>>>>>
#define vvvvvvvvvvvvvvvvvvvvi vector<vector<vector<vector<vector<vector<vector<int>>>>>
struct d{
    int w,to,next;
}
e[200005];
int head[200005],tot=0;

int n,m;
// n表示点数，m表示边数
void add(int x,int y,int z) {
    e[++tot].w=z;
    e[tot].to=y;
    e[tot].next=head[x];
    head[x]=tot;
}
// head[i]表示i的邻接表头结点
// e[i].w表示i的边权，e[i].to表示i的终点，e[i].next表示i的下一个边

int dis[200005];
int vis[200005];
// dis[i]表示从s到i的最短距离
// vis[i]表示i是否被访问过
// dis[i]初始化为无穷大，vis[i]初始化为0
// dis[s]初始化为0，vis[s]初始化为1
void dijkstra(int s) {
    priority_queue<pair<int,int>,vector<pair<int,int>>,greater<pair<int,int>>> q;
    for (int i=1;i<=n;i++) dis[i]=LLONG_MAX,vis[i]=0;
    dis[s]=0;
    q.push({0,s});
    while (!q.empty()) {
        int x=q.top().second;
        q.pop();
        if (vis[x]) continue;
        vis[x]=1;
        for (int i=head[x];i;i=e[i].next) {
            int y=e[i].to;
            if (dis[y]>dis[x]+e[i].w) {
                dis[y]=dis[x]+e[i].w;
                q.push({dis[y],y});
            }
        }
    }
}

int32_t main() {
    ios::sync_with_stdio(0);
    cin.tie(0);
    cout.tie(0);
    /*cin>>n>>m;
    for (int i=1;i<=m;i++) {
        int x,y,z;
        cin>>x>>y>>z;
        add(x,y,z);
        add(y,x,z);
    }
    int s;
    cin>>s;
    dijkstra(s);
    for (int i=1;i<=n;i++) cout<<dis[i]<<" ";*/
    int n,m;
    cin>>n>>m;
    cout<<n+m;
}
      • @ 2025-4-13 20:15:20 
        // Standard iostream objects -*- C++ -*-

// Copyright (C) 1997-2021 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

#pragma GCC system_header

#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 */

// <algorithm> -*- C++ -*-

// Copyright (C) 2001-2021 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
 
 #pragma GCC system_header
 
 #include <utility> // UK-300.
 #include <bits/stl_algobase.h>
 #include <bits/stl_algo.h>
 #if __cplusplus > 201703L
 # include <bits/ranges_algo.h>
 #endif
 
 #if __cplusplus > 201402L
 // Parallel STL algorithms
 # if _PSTL_EXECUTION_POLICIES_DEFINED
 // If <execution> has already been included, pull in implementations
 #  include <pstl/glue_algorithm_impl.h>
 #  else
 // Otherwise just pull in forward declarations
 #    include <pstl/glue_algorithm_defs.h>
 #    define _PSTL_ALGORITHM_FORWARD_DECLARED 1
 #  endif
 
 // Feature test macro for parallel algorithms
 # define __cpp_lib_parallel_algorithm 201603L
 #endif // C++17
 
 #ifdef _GLIBCXX_PARALLEL
 # include <parallel/algorithm>
 #endif
 
 #endif /* _GLIBCXX_ALGORITHM */
 
// <unordered_map> -*- C++ -*-

// Copyright (C) 2007-2021 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/unordered_map
 *  This is a Standard C++ Library header.
 */

 #ifndef _GLIBCXX_UNORDERED_MAP
 #define _GLIBCXX_UNORDERED_MAP 1
 
 #pragma GCC system_header
 
 #if __cplusplus < 201103L
 # include <bits/c++0x_warning.h>
 #else
 
 #include <type_traits>
 #include <initializer_list>
 #include <bits/allocator.h>
 #include <ext/alloc_traits.h>
 #include <ext/aligned_buffer.h>
 #include <bits/stl_pair.h>
 #include <bits/stl_function.h> // equal_to, _Identity, _Select1st
 #include <bits/functional_hash.h>
 #include <bits/hashtable.h>
 #include <bits/unordered_map.h>
 #include <bits/range_access.h>
 #include <bits/erase_if.h>
 
 #ifdef _GLIBCXX_DEBUG
 # include <debug/unordered_map>
 #endif
 
 #if __cplusplus >= 201703L
 namespace std _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
   namespace pmr
   {
     template<typename _Tp> class polymorphic_allocator;
     template<typename _Key, typename _Tp, typename _Hash = std::hash<_Key>,
          typename _Pred = std::equal_to<_Key>>
       using unordered_map
     = std::unordered_map<_Key, _Tp, _Hash, _Pred,
                  polymorphic_allocator<pair<const _Key, _Tp>>>;
     template<typename _Key, typename _Tp, typename _Hash = std::hash<_Key>,
          typename _Pred = std::equal_to<_Key>>
       using unordered_multimap
     = std::unordered_multimap<_Key, _Tp, _Hash, _Pred,
                   polymorphic_allocator<pair<const _Key, _Tp>>>;
   } // namespace pmr
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace std
 #endif // C++17
 
 #if __cplusplus > 201703L
 namespace std _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
   template<typename _Key, typename _Tp, typename _Hash, typename _CPred,
        typename _Alloc, typename _Predicate>
     inline typename unordered_map<_Key, _Tp, _Hash, _CPred, _Alloc>::size_type
     erase_if(unordered_map<_Key, _Tp, _Hash, _CPred, _Alloc>& __cont,
          _Predicate __pred)
     { return __detail::__erase_nodes_if(__cont, __pred); }
 
   template<typename _Key, typename _Tp, typename _Hash, typename _CPred,
        typename _Alloc, typename _Predicate>
     inline typename unordered_multimap<_Key, _Tp, _Hash, _CPred, _Alloc>::
             size_type
     erase_if(unordered_multimap<_Key, _Tp, _Hash, _CPred, _Alloc>& __cont,
          _Predicate __pred)
     { return __detail::__erase_nodes_if(__cont, __pred); }
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace std
 #endif // C++20
 
 #endif // C++11
 
 #endif // _GLIBCXX_UNORDERED_MAP

 // Debugging vector implementation -*- C++ -*-

// Copyright (C) 2003-2021 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 debug/vector
 *  This file is a GNU debug extension to the Standard C++ Library.
 */

#ifndef _GLIBCXX_DEBUG_VECTOR
#define _GLIBCXX_DEBUG_VECTOR 1

#pragma GCC system_header

#include <bits/c++config.h>
namespace std _GLIBCXX_VISIBILITY(default) { namespace __debug {
  template<typename _Tp, typename _Allocator> class vector;
} } // namespace std::__debug

#include <vector>
#include <utility>
#include <debug/safe_sequence.h>
#include <debug/safe_container.h>
#include <debug/safe_iterator.h>

namespace __gnu_debug
{
  /** @brief Base class for Debug Mode vector.
   *
   * Adds information about the guaranteed capacity, which is useful for
   * detecting code which relies on non-portable implementation details of
   * the libstdc++ reallocation policy.
   */
  template<typename _SafeSequence,
	   typename _BaseSequence>
    class _Safe_vector
    {
      typedef typename _BaseSequence::size_type size_type;

      const _SafeSequence&
      _M_seq() const { return *static_cast<const _SafeSequence*>(this); }

    protected:
      _Safe_vector() _GLIBCXX_NOEXCEPT
	: _M_guaranteed_capacity(0)
      { _M_update_guaranteed_capacity(); }

      _Safe_vector(const _Safe_vector&) _GLIBCXX_NOEXCEPT
	: _M_guaranteed_capacity(0)
      { _M_update_guaranteed_capacity(); }

      _Safe_vector(size_type __n) _GLIBCXX_NOEXCEPT
	: _M_guaranteed_capacity(__n)
      { }

#if __cplusplus >= 201103L
      _Safe_vector(_Safe_vector&& __x) noexcept
	: _Safe_vector()
      { __x._M_guaranteed_capacity = 0; }

      _Safe_vector&
      operator=(const _Safe_vector&) noexcept
      {
	_M_update_guaranteed_capacity();
	return *this;
      }

      _Safe_vector&
      operator=(_Safe_vector&& __x) noexcept
      {
	_M_update_guaranteed_capacity();
	__x._M_guaranteed_capacity = 0;
	return *this;
      }
#endif

      size_type _M_guaranteed_capacity;

      bool
      _M_requires_reallocation(size_type __elements) const _GLIBCXX_NOEXCEPT
      { return __elements > _M_seq().capacity(); }

      void
      _M_update_guaranteed_capacity() _GLIBCXX_NOEXCEPT
      {
	if (_M_seq().size() > _M_guaranteed_capacity)
	  _M_guaranteed_capacity = _M_seq().size();
      }
    };
}

namespace std _GLIBCXX_VISIBILITY(default)
{
namespace __debug
{
  /// Class std::vector with safety/checking/debug instrumentation.
  template<typename _Tp,
	   typename _Allocator = std::allocator<_Tp> >
    class vector
    : public __gnu_debug::_Safe_container<
	vector<_Tp, _Allocator>, _Allocator, __gnu_debug::_Safe_sequence>,
      public _GLIBCXX_STD_C::vector<_Tp, _Allocator>,
      public __gnu_debug::_Safe_vector<
	vector<_Tp, _Allocator>,
	_GLIBCXX_STD_C::vector<_Tp, _Allocator> >
    {
      typedef _GLIBCXX_STD_C::vector<_Tp, _Allocator>		_Base;
      typedef __gnu_debug::_Safe_container<
	vector, _Allocator, __gnu_debug::_Safe_sequence>	_Safe;
      typedef __gnu_debug::_Safe_vector<vector, _Base>		_Safe_vector;

      typedef typename _Base::iterator		_Base_iterator;
      typedef typename _Base::const_iterator	_Base_const_iterator;
      typedef __gnu_debug::_Equal_to<_Base_const_iterator> _Equal;

      template<typename _ItT, typename _SeqT, typename _CatT>
	friend class ::__gnu_debug::_Safe_iterator;

      // Reference wrapper for base class. Disambiguates vector(const _Base&)
      // from copy constructor by requiring a user-defined conversion.
      // See PR libstdc++/90102.
      struct _Base_ref
      {
	_Base_ref(const _Base& __r) : _M_ref(__r) { }

	const _Base& _M_ref;
      };

    public:
      typedef typename _Base::reference			reference;
      typedef typename _Base::const_reference		const_reference;

      typedef __gnu_debug::_Safe_iterator<
	_Base_iterator, vector>				iterator;
      typedef __gnu_debug::_Safe_iterator<
	_Base_const_iterator, vector>			const_iterator;

      typedef typename _Base::size_type			size_type;
      typedef typename _Base::difference_type		difference_type;

      typedef _Tp					value_type;
      typedef _Allocator				allocator_type;
      typedef typename _Base::pointer			pointer;
      typedef typename _Base::const_pointer		const_pointer;
      typedef std::reverse_iterator<iterator>		reverse_iterator;
      typedef std::reverse_iterator<const_iterator>	const_reverse_iterator;

      // 23.2.4.1 construct/copy/destroy:

#if __cplusplus < 201103L
      vector() _GLIBCXX_NOEXCEPT
      : _Base() { }
#else
      vector() = default;
#endif

      explicit
      vector(const _Allocator& __a) _GLIBCXX_NOEXCEPT
      : _Base(__a) { }

#if __cplusplus >= 201103L
      explicit
      vector(size_type __n, const _Allocator& __a = _Allocator())
      : _Base(__n, __a), _Safe_vector(__n) { }

      vector(size_type __n, const __type_identity_t<_Tp>& __value,
	     const _Allocator& __a = _Allocator())
      : _Base(__n, __value, __a) { }
#else
      explicit
      vector(size_type __n, const _Tp& __value = _Tp(),
	     const _Allocator& __a = _Allocator())
      : _Base(__n, __value, __a) { }
#endif

#if __cplusplus >= 201103L
      template<class _InputIterator,
	       typename = std::_RequireInputIter<_InputIterator>>
#else
      template<class _InputIterator>
#endif
	vector(_InputIterator __first, _InputIterator __last,
	       const _Allocator& __a = _Allocator())
	: _Base(__gnu_debug::__base(
		  __glibcxx_check_valid_constructor_range(__first, __last)),
		__gnu_debug::__base(__last), __a) { }

#if __cplusplus < 201103L
      vector(const vector& __x)
      : _Base(__x) { }

      ~vector() _GLIBCXX_NOEXCEPT { }
#else
      vector(const vector&) = default;
      vector(vector&&) = default;

      vector(const vector& __x, const allocator_type& __a)
      : _Base(__x, __a) { }

      vector(vector&& __x, const allocator_type& __a)
      noexcept(
	std::is_nothrow_constructible<_Base,
	  _Base, const allocator_type&>::value )
      : _Safe(std::move(__x._M_safe()), __a),
	_Base(std::move(__x._M_base()), __a),
	_Safe_vector(std::move(__x)) { }

      vector(initializer_list<value_type> __l,
	     const allocator_type& __a = allocator_type())
      : _Base(__l, __a) { }

      ~vector() = default;
#endif

      /// Construction from a normal-mode vector
      vector(_Base_ref __x)
      : _Base(__x._M_ref) { }

#if __cplusplus < 201103L
      vector&
      operator=(const vector& __x)
      {
	this->_M_safe() = __x;
	_M_base() = __x;
	this->_M_update_guaranteed_capacity();
	return *this;
      }
#else
      vector&
      operator=(const vector&) = default;

      vector&
      operator=(vector&&) = default;

      vector&
      operator=(initializer_list<value_type> __l)
      {
	_M_base() = __l;
	this->_M_invalidate_all();
	this->_M_update_guaranteed_capacity();
	return *this;
      }
#endif

#if __cplusplus >= 201103L
      template<typename _InputIterator,
	       typename = std::_RequireInputIter<_InputIterator>>
#else
      template<typename _InputIterator>
#endif
	void
	assign(_InputIterator __first, _InputIterator __last)
	{
	  typename __gnu_debug::_Distance_traits<_InputIterator>::__type __dist;
	  __glibcxx_check_valid_range2(__first, __last, __dist);

	  if (__dist.second >= __gnu_debug::__dp_sign)
	    _Base::assign(__gnu_debug::__unsafe(__first),
			  __gnu_debug::__unsafe(__last));
	  else
	    _Base::assign(__first, __last);

	  this->_M_invalidate_all();
	  this->_M_update_guaranteed_capacity();
	}

      void
      assign(size_type __n, const _Tp& __u)
      {
	_Base::assign(__n, __u);
	this->_M_invalidate_all();
	this->_M_update_guaranteed_capacity();
      }

#if __cplusplus >= 201103L
      void
      assign(initializer_list<value_type> __l)
      {
	_Base::assign(__l);
	this->_M_invalidate_all();
	this->_M_update_guaranteed_capacity();
      }
#endif

      using _Base::get_allocator;

      // iterators:
      iterator
      begin() _GLIBCXX_NOEXCEPT
      { return iterator(_Base::begin(), this); }

      const_iterator
      begin() const _GLIBCXX_NOEXCEPT
      { return const_iterator(_Base::begin(), this); }

      iterator
      end() _GLIBCXX_NOEXCEPT
      { return iterator(_Base::end(), this); }

      const_iterator
      end() const _GLIBCXX_NOEXCEPT
      { return const_iterator(_Base::end(), this); }

      reverse_iterator
      rbegin() _GLIBCXX_NOEXCEPT
      { return reverse_iterator(end()); }

      const_reverse_iterator
      rbegin() const _GLIBCXX_NOEXCEPT
      { return const_reverse_iterator(end()); }

      reverse_iterator
      rend() _GLIBCXX_NOEXCEPT
      { return reverse_iterator(begin()); }

      const_reverse_iterator
      rend() const _GLIBCXX_NOEXCEPT
      { return const_reverse_iterator(begin()); }

#if __cplusplus >= 201103L
      const_iterator
      cbegin() const noexcept
      { return const_iterator(_Base::begin(), this); }

      const_iterator
      cend() const noexcept
      { return const_iterator(_Base::end(), this); }

      const_reverse_iterator
      crbegin() const noexcept
      { return const_reverse_iterator(end()); }

      const_reverse_iterator
      crend() const noexcept
      { return const_reverse_iterator(begin()); }
#endif

      // 23.2.4.2 capacity:
      using _Base::size;
      using _Base::max_size;

#if __cplusplus >= 201103L
      void
      resize(size_type __sz)
      {
	bool __realloc = this->_M_requires_reallocation(__sz);
	if (__sz < this->size())
	  this->_M_invalidate_after_nth(__sz);
	_Base::resize(__sz);
	if (__realloc)
	  this->_M_invalidate_all();
	this->_M_update_guaranteed_capacity();
      }

      void
      resize(size_type __sz, const _Tp& __c)
      {
	bool __realloc = this->_M_requires_reallocation(__sz);
	if (__sz < this->size())
	  this->_M_invalidate_after_nth(__sz);
	_Base::resize(__sz, __c);
	if (__realloc)
	  this->_M_invalidate_all();
	this->_M_update_guaranteed_capacity();
      }
#else
      void
      resize(size_type __sz, _Tp __c = _Tp())
      {
	bool __realloc = this->_M_requires_reallocation(__sz);
	if (__sz < this->size())
	  this->_M_invalidate_after_nth(__sz);
	_Base::resize(__sz, __c);
	if (__realloc)
	  this->_M_invalidate_all();
	this->_M_update_guaranteed_capacity();
      }
#endif

#if __cplusplus >= 201103L
      void
      shrink_to_fit()
      {
	if (_Base::_M_shrink_to_fit())
	  {
	    this->_M_guaranteed_capacity = _Base::capacity();
	    this->_M_invalidate_all();
	  }
      }
#endif

      size_type
      capacity() const _GLIBCXX_NOEXCEPT
      {
#ifdef _GLIBCXX_DEBUG_PEDANTIC
	return this->_M_guaranteed_capacity;
#else
	return _Base::capacity();
#endif
      }

      using _Base::empty;

      void
      reserve(size_type __n)
      {
	bool __realloc = this->_M_requires_reallocation(__n);
	_Base::reserve(__n);
	if (__n > this->_M_guaranteed_capacity)
	  this->_M_guaranteed_capacity = __n;
	if (__realloc)
	  this->_M_invalidate_all();
      }

      // element access:
      reference
      operator[](size_type __n) _GLIBCXX_NOEXCEPT
      {
	__glibcxx_check_subscript(__n);
	return _M_base()[__n];
      }

      const_reference
      operator[](size_type __n) const _GLIBCXX_NOEXCEPT
      {
	__glibcxx_check_subscript(__n);
	return _M_base()[__n];
      }

      using _Base::at;

      reference
      front() _GLIBCXX_NOEXCEPT
      {
	__glibcxx_check_nonempty();
	return _Base::front();
      }

      const_reference
      front() const _GLIBCXX_NOEXCEPT
      {
	__glibcxx_check_nonempty();
	return _Base::front();
      }

      reference
      back() _GLIBCXX_NOEXCEPT
      {
	__glibcxx_check_nonempty();
	return _Base::back();
      }

      const_reference
      back() const _GLIBCXX_NOEXCEPT
      {
	__glibcxx_check_nonempty();
	return _Base::back();
      }

      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // DR 464. Suggestion for new member functions in standard containers.
      using _Base::data;

      // 23.2.4.3 modifiers:
      void
      push_back(const _Tp& __x)
      {
	bool __realloc = this->_M_requires_reallocation(this->size() + 1);
	_Base::push_back(__x);
	if (__realloc)
	  this->_M_invalidate_all();
	this->_M_update_guaranteed_capacity();
      }

#if __cplusplus >= 201103L
      template<typename _Up = _Tp>
	typename __gnu_cxx::__enable_if<!std::__are_same<_Up, bool>::__value,
					void>::__type
	push_back(_Tp&& __x)
	{ emplace_back(std::move(__x)); }

      template<typename... _Args>
#if __cplusplus > 201402L
	reference
#else
	void
#endif
	emplace_back(_Args&&... __args)
	{
	  bool __realloc = this->_M_requires_reallocation(this->size() + 1);
	  _Base::emplace_back(std::forward<_Args>(__args)...);
	  if (__realloc)
	    this->_M_invalidate_all();
	  this->_M_update_guaranteed_capacity();
#if __cplusplus > 201402L
	  return back();
#endif
	}
#endif

      void
      pop_back() _GLIBCXX_NOEXCEPT
      {
	__glibcxx_check_nonempty();
	this->_M_invalidate_if(_Equal(--_Base::end()));
	_Base::pop_back();
      }

#if __cplusplus >= 201103L
      template<typename... _Args>
	iterator
	emplace(const_iterator __position, _Args&&... __args)
	{
	  __glibcxx_check_insert(__position);
	  bool __realloc = this->_M_requires_reallocation(this->size() + 1);
	  difference_type __offset = __position.base() - _Base::cbegin();
	  _Base_iterator __res = _Base::emplace(__position.base(),
						std::forward<_Args>(__args)...);
	  if (__realloc)
	    this->_M_invalidate_all();
	  else
	    this->_M_invalidate_after_nth(__offset);
	  this->_M_update_guaranteed_capacity();
	  return { __res, this };
	}
#endif

      iterator
#if __cplusplus >= 201103L
      insert(const_iterator __position, const _Tp& __x)
#else
      insert(iterator __position, const _Tp& __x)
#endif
      {
	__glibcxx_check_insert(__position);
	bool __realloc = this->_M_requires_reallocation(this->size() + 1);
	difference_type __offset = __position.base() - _Base::begin();
	_Base_iterator __res = _Base::insert(__position.base(), __x);
	if (__realloc)
	  this->_M_invalidate_all();
	else
	  this->_M_invalidate_after_nth(__offset);
	this->_M_update_guaranteed_capacity();
	return iterator(__res, this);
      }

#if __cplusplus >= 201103L
      template<typename _Up = _Tp>
	typename __gnu_cxx::__enable_if<!std::__are_same<_Up, bool>::__value,
					iterator>::__type
	insert(const_iterator __position, _Tp&& __x)
	{ return emplace(__position, std::move(__x)); }

      iterator
      insert(const_iterator __position, initializer_list<value_type> __l)
      { return this->insert(__position, __l.begin(), __l.end()); }
#endif

#if __cplusplus >= 201103L
      iterator
      insert(const_iterator __position, size_type __n, const _Tp& __x)
      {
	__glibcxx_check_insert(__position);
	bool __realloc = this->_M_requires_reallocation(this->size() + __n);
	difference_type __offset = __position.base() - _Base::cbegin();
	_Base_iterator __res = _Base::insert(__position.base(), __n, __x);
	if (__realloc)
	  this->_M_invalidate_all();
	else
	  this->_M_invalidate_after_nth(__offset);
	this->_M_update_guaranteed_capacity();
	return { __res, this };
      }
#else
      void
      insert(iterator __position, size_type __n, const _Tp& __x)
      {
	__glibcxx_check_insert(__position);
	bool __realloc = this->_M_requires_reallocation(this->size() + __n);
	difference_type __offset = __position.base() - _Base::begin();
	_Base::insert(__position.base(), __n, __x);
	if (__realloc)
	  this->_M_invalidate_all();
	else
	  this->_M_invalidate_after_nth(__offset);
	this->_M_update_guaranteed_capacity();
      }
#endif

#if __cplusplus >= 201103L
      template<class _InputIterator,
	       typename = std::_RequireInputIter<_InputIterator>>
	iterator
	insert(const_iterator __position,
	       _InputIterator __first, _InputIterator __last)
	{
	  typename __gnu_debug::_Distance_traits<_InputIterator>::__type __dist;
	  __glibcxx_check_insert_range(__position, __first, __last, __dist);

	  /* Hard to guess if invalidation will occur, because __last
	     - __first can't be calculated in all cases, so we just
	     punt here by checking if it did occur. */
	  _Base_iterator __old_begin = _M_base().begin();
	  difference_type __offset = __position.base() - _Base::cbegin();
	  _Base_iterator __res;
	  if (__dist.second >= __gnu_debug::__dp_sign)
	    __res = _Base::insert(__position.base(),
				  __gnu_debug::__unsafe(__first),
				  __gnu_debug::__unsafe(__last));
	  else
	    __res = _Base::insert(__position.base(), __first, __last);

	  if (_M_base().begin() != __old_begin)
	    this->_M_invalidate_all();
	  else
	    this->_M_invalidate_after_nth(__offset);
	  this->_M_update_guaranteed_capacity();
	  return { __res, this };
	}
#else
      template<class _InputIterator>
	void
	insert(iterator __position,
	       _InputIterator __first, _InputIterator __last)
	{
	  typename __gnu_debug::_Distance_traits<_InputIterator>::__type __dist;
	  __glibcxx_check_insert_range(__position, __first, __last, __dist);

	  /* Hard to guess if invalidation will occur, because __last
	     - __first can't be calculated in all cases, so we just
	     punt here by checking if it did occur. */
	  _Base_iterator __old_begin = _M_base().begin();
	  difference_type __offset = __position.base() - _Base::begin();
	  if (__dist.second >= __gnu_debug::__dp_sign)
	    _Base::insert(__position.base(), __gnu_debug::__unsafe(__first),
					     __gnu_debug::__unsafe(__last));
	  else
	    _Base::insert(__position.base(), __first, __last);

	  if (_M_base().begin() != __old_begin)
	    this->_M_invalidate_all();
	  else
	    this->_M_invalidate_after_nth(__offset);
	  this->_M_update_guaranteed_capacity();
	}
#endif

      iterator
#if __cplusplus >= 201103L
      erase(const_iterator __position)
#else
      erase(iterator __position)
#endif
      {
	__glibcxx_check_erase(__position);
	difference_type __offset = __position.base() - _Base::begin();
	_Base_iterator __res = _Base::erase(__position.base());
	this->_M_invalidate_after_nth(__offset);
	return iterator(__res, this);
      }

      iterator
#if __cplusplus >= 201103L
      erase(const_iterator __first, const_iterator __last)
#else
      erase(iterator __first, iterator __last)
#endif
      {
	// _GLIBCXX_RESOLVE_LIB_DEFECTS
	// 151. can't currently clear() empty container
	__glibcxx_check_erase_range(__first, __last);

	if (__first.base() != __last.base())
	  {
	    difference_type __offset = __first.base() - _Base::begin();
	    _Base_iterator __res = _Base::erase(__first.base(),
						__last.base());
	    this->_M_invalidate_after_nth(__offset);
	    return iterator(__res, this);
	  }
	else
#if __cplusplus >= 201103L
	  return { _Base::begin() + (__first.base() - _Base::cbegin()), this };
#else
	  return __first;
#endif
      }

      void
      swap(vector& __x)
      _GLIBCXX_NOEXCEPT_IF( noexcept(declval<_Base&>().swap(__x)) )
      {
	_Safe::_M_swap(__x);
	_Base::swap(__x);
	std::swap(this->_M_guaranteed_capacity, __x._M_guaranteed_capacity);
      }

      void
      clear() _GLIBCXX_NOEXCEPT
      {
	_Base::clear();
	this->_M_invalidate_all();
      }

      _Base&
      _M_base() _GLIBCXX_NOEXCEPT { return *this; }

      const _Base&
      _M_base() const _GLIBCXX_NOEXCEPT { return *this; }

    private:
      void
      _M_invalidate_after_nth(difference_type __n) _GLIBCXX_NOEXCEPT
      {
	typedef __gnu_debug::_After_nth_from<_Base_const_iterator> _After_nth;
	this->_M_invalidate_if(_After_nth(__n, _Base::begin()));
      }
    };

  template<typename _Tp, typename _Alloc>
    inline bool
    operator==(const vector<_Tp, _Alloc>& __lhs,
	       const vector<_Tp, _Alloc>& __rhs)
    { return __lhs._M_base() == __rhs._M_base(); }

#if __cpp_lib_three_way_comparison
  template<typename _Tp, typename _Alloc>
    constexpr __detail::__synth3way_t<_Tp>
    operator<=>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y)
    { return __x._M_base() <=> __y._M_base(); }
#else
  template<typename _Tp, typename _Alloc>
    inline bool
    operator!=(const vector<_Tp, _Alloc>& __lhs,
	       const vector<_Tp, _Alloc>& __rhs)
    { return __lhs._M_base() != __rhs._M_base(); }

  template<typename _Tp, typename _Alloc>
    inline bool
    operator<(const vector<_Tp, _Alloc>& __lhs,
	      const vector<_Tp, _Alloc>& __rhs)
    { return __lhs._M_base() < __rhs._M_base(); }

  template<typename _Tp, typename _Alloc>
    inline bool
    operator<=(const vector<_Tp, _Alloc>& __lhs,
	       const vector<_Tp, _Alloc>& __rhs)
    { return __lhs._M_base() <= __rhs._M_base(); }

  template<typename _Tp, typename _Alloc>
    inline bool
    operator>=(const vector<_Tp, _Alloc>& __lhs,
	       const vector<_Tp, _Alloc>& __rhs)
    { return __lhs._M_base() >= __rhs._M_base(); }

  template<typename _Tp, typename _Alloc>
    inline bool
    operator>(const vector<_Tp, _Alloc>& __lhs,
	      const vector<_Tp, _Alloc>& __rhs)
    { return __lhs._M_base() > __rhs._M_base(); }
#endif // three-way comparison

  template<typename _Tp, typename _Alloc>
    inline void
    swap(vector<_Tp, _Alloc>& __lhs, vector<_Tp, _Alloc>& __rhs)
    _GLIBCXX_NOEXCEPT_IF(noexcept(__lhs.swap(__rhs)))
    { __lhs.swap(__rhs); }

#if __cpp_deduction_guides >= 201606
  template<typename _InputIterator, typename _ValT
	     = typename iterator_traits<_InputIterator>::value_type,
	   typename _Allocator = allocator<_ValT>,
	   typename = _RequireInputIter<_InputIterator>,
	   typename = _RequireAllocator<_Allocator>>
    vector(_InputIterator, _InputIterator, _Allocator = _Allocator())
      -> vector<_ValT, _Allocator>;

  template<typename _Tp, typename _Allocator = allocator<_Tp>,
	   typename = _RequireAllocator<_Allocator>>
    vector(size_t, _Tp, _Allocator = _Allocator())
      -> vector<_Tp, _Allocator>;
#endif

} // namespace __debug

_GLIBCXX_BEGIN_NAMESPACE_VERSION

#if __cplusplus >= 201103L
  // DR 1182.
  /// std::hash specialization for vector<bool>.
  template<typename _Alloc>
    struct hash<__debug::vector<bool, _Alloc>>
    : public __hash_base<size_t, __debug::vector<bool, _Alloc>>
    {
      size_t
      operator()(const __debug::vector<bool, _Alloc>& __b) const noexcept
      { return std::hash<_GLIBCXX_STD_C::vector<bool, _Alloc>>()(__b); }
    };
#endif

#if __cplusplus >= 201703L
  namespace __detail::__variant
  {
    template<typename> struct _Never_valueless_alt; // see <variant>

    // Provide the strong exception-safety guarantee when emplacing a
    // vector into a variant, but only if move assignment cannot throw.
    template<typename _Tp, typename _Alloc>
      struct _Never_valueless_alt<__debug::vector<_Tp, _Alloc>>
      : std::is_nothrow_move_assignable<__debug::vector<_Tp, _Alloc>>
      { };
  }  // namespace __detail::__variant
#endif // C++17

_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std

namespace __gnu_debug
{
  template<typename _Tp, typename _Alloc>
    struct _Is_contiguous_sequence<std::__debug::vector<_Tp, _Alloc> >
    : std::__true_type
    { };

  template<typename _Alloc>
    struct _Is_contiguous_sequence<std::__debug::vector<bool, _Alloc> >
    : std::__false_type
    { };
}

#endif

// Components for manipulating non-owning sequences of objects -*- C++ -*-

// Copyright (C) 2019-2021 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 span
 *  This is a Standard C++ Library header.
 */

//
// P0122 span library
// Contributed by ThePhD
//

#ifndef _GLIBCXX_SPAN
#define _GLIBCXX_SPAN 1

#pragma GCC system_header

#if __cplusplus > 201703L

#include <array>
#include <cstddef>
#include <bits/stl_iterator.h>
#include <bits/ranges_base.h>

#if __cpp_lib_concepts
namespace std _GLIBCXX_VISIBILITY(default)
{
_GLIBCXX_BEGIN_NAMESPACE_VERSION

#define __cpp_lib_span 202002L

  inline constexpr size_t dynamic_extent = static_cast<size_t>(-1);

  template<typename _Type, size_t _Extent>
    class span;

  namespace __detail
  {
    template<typename _Tp>
      struct __is_std_span : false_type { };

    template<typename _Tp, size_t _Num>
      struct __is_std_span<span<_Tp, _Num>> : true_type { };

    template<typename _Tp>
      struct __is_std_array : false_type { };

    template<typename _Tp, size_t _Num>
      struct __is_std_array<std::array<_Tp, _Num>> : true_type { };

    template<size_t _Extent>
      class __extent_storage
      {
      public:
	constexpr
	__extent_storage(size_t) noexcept
	{ }

	static constexpr size_t
	_M_extent() noexcept
	{ return _Extent; }
      };

    template<>
      class __extent_storage<dynamic_extent>
      {
      public:
	constexpr
	__extent_storage(size_t __extent) noexcept
	: _M_extent_value(__extent)
	{ }

	constexpr size_t
	_M_extent() const noexcept
	{ return this->_M_extent_value; }

      private:
	size_t _M_extent_value;
      };
  } // namespace __detail

  template<typename _Type, size_t _Extent = dynamic_extent>
    class span
    {
      template<size_t _Offset, size_t _Count>
	static constexpr size_t
	_S_subspan_extent()
	{
	  if constexpr (_Count != dynamic_extent)
	    return _Count;
	  else if constexpr (extent != dynamic_extent)
	    return _Extent - _Offset;
	  else
	    return dynamic_extent;
	}

      // _GLIBCXX_RESOLVE_LIB_DEFECTS
      // 3255. span's array constructor is too strict
      template<typename _Tp, size_t _ArrayExtent>
	requires (_Extent == dynamic_extent || _ArrayExtent == _Extent)
	using __is_compatible_array = __is_array_convertible<_Type, _Tp>;

      template<typename _Ref>
	using __is_compatible_ref
	  = __is_array_convertible<_Type, remove_reference_t<_Ref>>;

    public:
      // member types
      using element_type           = _Type;
      using value_type             = remove_cv_t<_Type>;
      using size_type              = size_t;
      using difference_type        = ptrdiff_t;
      using pointer                = _Type*;
      using const_pointer          = const _Type*;
      using reference              = element_type&;
      using const_reference        = const element_type&;
      using iterator = __gnu_cxx::__normal_iterator<pointer, span>;
      using reverse_iterator       = std::reverse_iterator<iterator>;

      // member constants
      static constexpr size_t extent = _Extent;

      // constructors, copy and assignment

      constexpr
      span() noexcept
      requires ((_Extent + 1u) <= 1u)
      : _M_ptr(nullptr), _M_extent(0)
      { }

      template<contiguous_iterator _It>
	requires __is_compatible_ref<iter_reference_t<_It>>::value
	constexpr explicit(extent != dynamic_extent)
	span(_It __first, size_type __count)
	noexcept
	: _M_ptr(std::to_address(__first)), _M_extent(__count)
	{
	  if constexpr (_Extent != dynamic_extent)
	    {
	      __glibcxx_assert(__count == _Extent);
	    }
	  __glibcxx_requires_valid_range(__first, __first + __count);
	}

      template<contiguous_iterator _It, sized_sentinel_for<_It> _End>
	requires __is_compatible_ref<iter_reference_t<_It>>::value
	  && (!is_convertible_v<_End, size_type>)
	constexpr explicit(extent != dynamic_extent)
	span(_It __first, _End __last)
	noexcept(noexcept(__last - __first))
	: _M_ptr(std::to_address(__first)),
	  _M_extent(static_cast<size_type>(__last - __first))
	{
	  if constexpr (_Extent != dynamic_extent)
	    {
	      __glibcxx_assert((__last - __first) == _Extent);
	    }
	  __glibcxx_requires_valid_range(__first, __last);
	}

      template<size_t _ArrayExtent>
	requires (_Extent == dynamic_extent || _ArrayExtent == _Extent)
	constexpr
	span(type_identity_t<element_type> (&__arr)[_ArrayExtent]) noexcept
	: span(static_cast<pointer>(__arr), _ArrayExtent)
	{ }

      template<typename _Tp, size_t _ArrayExtent>
	requires __is_compatible_array<_Tp, _ArrayExtent>::value
	constexpr
	span(array<_Tp, _ArrayExtent>& __arr) noexcept
	: span(static_cast<pointer>(__arr.data()), _ArrayExtent)
	{ }

      template<typename _Tp, size_t _ArrayExtent>
	requires __is_compatible_array<const _Tp, _ArrayExtent>::value
	constexpr
	span(const array<_Tp, _ArrayExtent>& __arr) noexcept
	: span(static_cast<pointer>(__arr.data()), _ArrayExtent)
	{ }

      template<typename _Range>
	requires (!__detail::__is_std_span<remove_cvref_t<_Range>>::value)
	  && (!__detail::__is_std_array<remove_cvref_t<_Range>>::value)
	  && (!is_array_v<remove_cvref_t<_Range>>)
	  && ranges::contiguous_range<_Range> && ranges::sized_range<_Range>
	  && (ranges::borrowed_range<_Range> || is_const_v<element_type>)
	  && __is_compatible_ref<ranges::range_reference_t<_Range>>::value
	constexpr explicit(extent != dynamic_extent)
	span(_Range&& __range)
	noexcept(noexcept(ranges::data(__range))
		  && noexcept(ranges::size(__range)))
	: span(ranges::data(__range), ranges::size(__range))
	{
	  if constexpr (extent != dynamic_extent)
	    {
	      __glibcxx_assert(ranges::size(__range) == extent);
	    }
	}

      constexpr
      span(const span&) noexcept = default;

      template<typename _OType, size_t _OExtent>
	requires (_Extent == dynamic_extent || _OExtent == dynamic_extent
		  || _Extent == _OExtent)
	  && (__is_array_convertible<_Type, _OType>::value)
	constexpr
	explicit(extent != dynamic_extent && _OExtent == dynamic_extent)
	span(const span<_OType, _OExtent>& __s) noexcept
	: _M_extent(__s.size()), _M_ptr(__s.data())
	{
	  if constexpr (extent != dynamic_extent)
	    {
	      __glibcxx_assert(__s.size() == extent);
	    }
	}

      ~span() noexcept = default;

      constexpr span&
      operator=(const span&) noexcept = default;

      // observers

      constexpr size_type
      size() const noexcept
      { return this->_M_extent._M_extent(); }

      constexpr size_type
      size_bytes() const noexcept
      { return this->_M_extent._M_extent() * sizeof(element_type); }

      [[nodiscard]] constexpr bool
      empty() const noexcept
      { return size() == 0; }

      // element access

      constexpr reference
      front() const noexcept
      {
	__glibcxx_assert(!empty());
	return *this->_M_ptr;
      }

      constexpr reference
      back() const noexcept
      {
	__glibcxx_assert(!empty());
	return *(this->_M_ptr + (size() - 1));
      }

      constexpr reference
      operator[](size_type __idx) const noexcept
      {
	__glibcxx_assert(__idx < size());
	return *(this->_M_ptr + __idx);
      }

      constexpr pointer
      data() const noexcept
      { return this->_M_ptr; }

      // iterator support

      constexpr iterator
      begin() const noexcept
      { return iterator(this->_M_ptr); }

      constexpr iterator
      end() const noexcept
      { return iterator(this->_M_ptr + this->size()); }

      constexpr reverse_iterator
      rbegin() const noexcept
      { return reverse_iterator(this->end()); }

      constexpr reverse_iterator
      rend() const noexcept
      { return reverse_iterator(this->begin()); }

      // subviews

      template<size_t _Count>
	constexpr span<element_type, _Count>
	first() const noexcept
	{
	  if constexpr (_Extent == dynamic_extent)
	    __glibcxx_assert(_Count <= size());
	  else
	    static_assert(_Count <= extent);
	  using _Sp = span<element_type, _Count>;
	  return _Sp{ this->data(), _Count };
	}

      constexpr span<element_type, dynamic_extent>
      first(size_type __count) const noexcept
      {
	__glibcxx_assert(__count <= size());
	return { this->data(), __count };
      }

      template<size_t _Count>
	constexpr span<element_type, _Count>
	last() const noexcept
	{
	  if constexpr (_Extent == dynamic_extent)
	    __glibcxx_assert(_Count <= size());
	  else
	    static_assert(_Count <= extent);
	  using _Sp = span<element_type, _Count>;
	  return _Sp{ this->data() + (this->size() - _Count), _Count };
	}

      constexpr span<element_type, dynamic_extent>
      last(size_type __count) const noexcept
      {
	__glibcxx_assert(__count <= size());
	return { this->data() + (this->size() - __count), __count };
      }

      template<size_t _Offset, size_t _Count = dynamic_extent>
	constexpr auto
	subspan() const noexcept
	-> span<element_type, _S_subspan_extent<_Offset, _Count>()>
	{
	  if constexpr (_Extent == dynamic_extent)
	    {
	      __glibcxx_assert(_Offset <= size());
	    }
	  else
	    static_assert(_Offset <= extent);

	  using _Sp = span<element_type, _S_subspan_extent<_Offset, _Count>()>;

	  if constexpr (_Count == dynamic_extent)
	    return _Sp{ this->data() + _Offset, this->size() - _Offset };
	  else
	    {
	      if constexpr (_Extent == dynamic_extent)
		{
		  __glibcxx_assert(_Count <= size());
		  __glibcxx_assert(_Count <= (size() - _Offset));
		}
	      else
		{
		  static_assert(_Count <= extent);
		  static_assert(_Count <= (extent - _Offset));
		}
	      return _Sp{ this->data() + _Offset, _Count };
	    }
	}

      constexpr span<element_type, dynamic_extent>
      subspan(size_type __offset, size_type __count = dynamic_extent) const
      noexcept
      {
	__glibcxx_assert(__offset <= size());
	if (__count == dynamic_extent)
	  __count = this->size() - __offset;
	else
	  {
	    __glibcxx_assert(__count <= size());
	    __glibcxx_assert(__offset + __count <= size());
	  }
	return {this->data() + __offset, __count};
      }

    private:
      pointer _M_ptr;
      [[no_unique_address]] __detail::__extent_storage<extent> _M_extent;
    };

  // deduction guides

  template<typename _Type, size_t _ArrayExtent>
    span(_Type(&)[_ArrayExtent]) -> span<_Type, _ArrayExtent>;

  template<typename _Type, size_t _ArrayExtent>
    span(array<_Type, _ArrayExtent>&) -> span<_Type, _ArrayExtent>;

  template<typename _Type, size_t _ArrayExtent>
    span(const array<_Type, _ArrayExtent>&)
      -> span<const _Type, _ArrayExtent>;

  template<contiguous_iterator _Iter, typename _End>
    span(_Iter, _End)
      -> span<remove_reference_t<iter_reference_t<_Iter>>>;

  template<ranges::contiguous_range _Range>
    span(_Range &&)
      -> span<remove_reference_t<ranges::range_reference_t<_Range&>>>;

  template<typename _Type, size_t _Extent>
    inline
    span<const byte, _Extent == dynamic_extent
	? dynamic_extent : _Extent * sizeof(_Type)>
    as_bytes(span<_Type, _Extent> __sp) noexcept
    {
      auto data = reinterpret_cast<const byte*>(__sp.data());
      auto size = __sp.size_bytes();
      constexpr auto extent = _Extent == dynamic_extent
	? dynamic_extent : _Extent * sizeof(_Type);
      return span<const byte, extent>{data, size};
    }

  template<typename _Type, size_t _Extent>
    requires (!is_const_v<_Type>)
    inline
    span<byte, _Extent == dynamic_extent
       ? dynamic_extent : _Extent * sizeof(_Type)>
    as_writable_bytes(span<_Type, _Extent> __sp) noexcept
    {
      auto data = reinterpret_cast<byte*>(__sp.data());
      auto size = __sp.size_bytes();
      constexpr auto extent = _Extent == dynamic_extent
	? dynamic_extent : _Extent * sizeof(_Type);
      return span<byte, extent>{data, size};
    }

  namespace ranges
  {
    // Opt-in to borrowed_range concept
    template<typename _ElementType, size_t _Extent>
      inline constexpr bool
	enable_borrowed_range<span<_ElementType, _Extent>> = true;

    // Opt-in to view concept
    template<typename _ElementType, size_t _Extent>
      inline constexpr bool
	enable_view<span<_ElementType, _Extent>> = true;
  }
_GLIBCXX_END_NAMESPACE_VERSION
} // namespace std
#endif // concepts
#endif // C++20
#endif // _GLIBCXX_SPAN

// <bit> -*- C++ -*-

// Copyright (C) 2018-2021 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/bit
 *  This is a Standard C++ Library header.
 */

 #ifndef _GLIBCXX_BIT
 #define _GLIBCXX_BIT 1
 
 #pragma GCC system_header
 
 #if __cplusplus >= 201402L
 
 #include <type_traits>
 
 #if _GLIBCXX_HOSTED
 # include <ext/numeric_traits.h>
 #else
 # include <limits>
 /// @cond undocumented
 namespace __gnu_cxx
 {
   template<typename _Tp>
     struct __int_traits
     {
       static constexpr int __digits = std::numeric_limits<_Tp>::digits;
       static constexpr _Tp __max = std::numeric_limits<_Tp>::max();
     };
 }
 /// @endcond
 #endif
 
 namespace std _GLIBCXX_VISIBILITY(default)
 {
 _GLIBCXX_BEGIN_NAMESPACE_VERSION
 
   /**
    * @defgroup bit_manip Bit manipulation
    * @ingroup numerics
    *
    * Utilities for examining and manipulating individual bits.
    *
    * @{
    */
 
 #if __cplusplus > 201703l && __has_builtin(__builtin_bit_cast)
 #define __cpp_lib_bit_cast 201806L
 
   /// Create a value of type `To` from the bits of `from`.
   template<typename _To, typename _From>
     [[nodiscard]]
     constexpr _To
     bit_cast(const _From& __from) noexcept
 #ifdef __cpp_concepts
     requires (sizeof(_To) == sizeof(_From))
       && __is_trivially_copyable(_To) && __is_trivially_copyable(_From)
 #endif
     {
       return __builtin_bit_cast(_To, __from);
     }
 #endif
 
   /// @cond undoc
 
   template<typename _Tp>
     constexpr _Tp
     __rotl(_Tp __x, int __s) noexcept
     {
       constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits;
       if _GLIBCXX17_CONSTEXPR ((_Nd & (_Nd - 1)) == 0)
     {
       // Variant for power of two _Nd which the compiler can
       // easily pattern match.
       constexpr unsigned __uNd = _Nd;
       const unsigned __r = __s;
       return (__x << (__r % __uNd)) | (__x >> ((-__r) % __uNd));
     }
       const int __r = __s % _Nd;
       if (__r == 0)
     return __x;
       else if (__r > 0)
     return (__x << __r) | (__x >> ((_Nd - __r) % _Nd));
       else
     return (__x >> -__r) | (__x << ((_Nd + __r) % _Nd)); // rotr(x, -r)
     }
 
   template<typename _Tp>
     constexpr _Tp
     __rotr(_Tp __x, int __s) noexcept
     {
       constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits;
       if _GLIBCXX17_CONSTEXPR ((_Nd & (_Nd - 1)) == 0)
     {
       // Variant for power of two _Nd which the compiler can
       // easily pattern match.
       constexpr unsigned __uNd = _Nd;
       const unsigned __r = __s;
       return (__x >> (__r % __uNd)) | (__x << ((-__r) % __uNd));
     }
       const int __r = __s % _Nd;
       if (__r == 0)
     return __x;
       else if (__r > 0)
     return (__x >> __r) | (__x << ((_Nd - __r) % _Nd));
       else
     return (__x << -__r) | (__x >> ((_Nd + __r) % _Nd)); // rotl(x, -r)
     }
 
   template<typename _Tp>
     constexpr int
     __countl_zero(_Tp __x) noexcept
     {
       using __gnu_cxx::__int_traits;
       constexpr auto _Nd = __int_traits<_Tp>::__digits;
 
       if (__x == 0)
         return _Nd;
 
       constexpr auto _Nd_ull = __int_traits<unsigned long long>::__digits;
       constexpr auto _Nd_ul = __int_traits<unsigned long>::__digits;
       constexpr auto _Nd_u = __int_traits<unsigned>::__digits;
 
       if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_u)
     {
       constexpr int __diff = _Nd_u - _Nd;
       return __builtin_clz(__x) - __diff;
     }
       else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ul)
     {
       constexpr int __diff = _Nd_ul - _Nd;
       return __builtin_clzl(__x) - __diff;
     }
       else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ull)
     {
       constexpr int __diff = _Nd_ull - _Nd;
       return __builtin_clzll(__x) - __diff;
     }
       else // (_Nd > _Nd_ull)
     {
       static_assert(_Nd <= (2 * _Nd_ull),
             "Maximum supported integer size is 128-bit");
 
       unsigned long long __high = __x >> _Nd_ull;
       if (__high != 0)
         {
           constexpr int __diff = (2 * _Nd_ull) - _Nd;
           return __builtin_clzll(__high) - __diff;
         }
       constexpr auto __max_ull = __int_traits<unsigned long long>::__max;
       unsigned long long __low = __x & __max_ull;
       return (_Nd - _Nd_ull) + __builtin_clzll(__low);
     }
     }
 
   template<typename _Tp>
     constexpr int
     __countl_one(_Tp __x) noexcept
     {
       return std::__countl_zero<_Tp>((_Tp)~__x);
     }
 
   template<typename _Tp>
     constexpr int
     __countr_zero(_Tp __x) noexcept
     {
       using __gnu_cxx::__int_traits;
       constexpr auto _Nd = __int_traits<_Tp>::__digits;
 
       if (__x == 0)
         return _Nd;
 
       constexpr auto _Nd_ull = __int_traits<unsigned long long>::__digits;
       constexpr auto _Nd_ul = __int_traits<unsigned long>::__digits;
       constexpr auto _Nd_u = __int_traits<unsigned>::__digits;
 
       if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_u)
     return __builtin_ctz(__x);
       else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ul)
     return __builtin_ctzl(__x);
       else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ull)
     return __builtin_ctzll(__x);
       else // (_Nd > _Nd_ull)
     {
       static_assert(_Nd <= (2 * _Nd_ull),
             "Maximum supported integer size is 128-bit");
 
       constexpr auto __max_ull = __int_traits<unsigned long long>::__max;
       unsigned long long __low = __x & __max_ull;
       if (__low != 0)
         return __builtin_ctzll(__low);
       unsigned long long __high = __x >> _Nd_ull;
       return __builtin_ctzll(__high) + _Nd_ull;
     }
     }
 
   template<typename _Tp>
     constexpr int
     __countr_one(_Tp __x) noexcept
     {
       return std::__countr_zero((_Tp)~__x);
     }
 
   template<typename _Tp>
     constexpr int
     __popcount(_Tp __x) noexcept
     {
       using __gnu_cxx::__int_traits;
       constexpr auto _Nd = __int_traits<_Tp>::__digits;
 
       constexpr auto _Nd_ull = __int_traits<unsigned long long>::__digits;
       constexpr auto _Nd_ul = __int_traits<unsigned long>::__digits;
       constexpr auto _Nd_u = __int_traits<unsigned>::__digits;
 
       if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_u)
     return __builtin_popcount(__x);
       else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ul)
     return __builtin_popcountl(__x);
       else if _GLIBCXX17_CONSTEXPR (_Nd <= _Nd_ull)
     return __builtin_popcountll(__x);
       else // (_Nd > _Nd_ull)
     {
       static_assert(_Nd <= (2 * _Nd_ull),
             "Maximum supported integer size is 128-bit");
 
       constexpr auto __max_ull = __int_traits<unsigned long long>::__max;
       unsigned long long __low = __x & __max_ull;
       unsigned long long __high = __x >> _Nd_ull;
       return __builtin_popcountll(__low) + __builtin_popcountll(__high);
     }
     }
 
   template<typename _Tp>
     constexpr bool
     __has_single_bit(_Tp __x) noexcept
     { return std::__popcount(__x) == 1; }
 
   template<typename _Tp>
     constexpr _Tp
     __bit_ceil(_Tp __x) noexcept
     {
       using __gnu_cxx::__int_traits;
       constexpr auto _Nd = __int_traits<_Tp>::__digits;
       if (__x == 0 || __x == 1)
         return 1;
       auto __shift_exponent = _Nd - std::__countl_zero((_Tp)(__x - 1u));
       // If the shift exponent equals _Nd then the correct result is not
       // representable as a value of _Tp, and so the result is undefined.
       // Want that undefined behaviour to be detected in constant expressions,
       // by UBSan, and by debug assertions.
 #ifdef _GLIBCXX_HAVE_BUILTIN_IS_CONSTANT_EVALUATED
       if (!__builtin_is_constant_evaluated())
     {
       __glibcxx_assert( __shift_exponent != __int_traits<_Tp>::__digits );
     }
 #endif
       using __promoted_type = decltype(__x << 1);
       if _GLIBCXX17_CONSTEXPR (!is_same<__promoted_type, _Tp>::value)
     {
       // If __x undergoes integral promotion then shifting by _Nd is
       // not undefined. In order to make the shift undefined, so that
       // it is diagnosed in constant expressions and by UBsan, we also
       // need to "promote" the shift exponent to be too large for the
       // promoted type.
       const int __extra_exp = sizeof(__promoted_type) / sizeof(_Tp) / 2;
       __shift_exponent |= (__shift_exponent & _Nd) << __extra_exp;
     }
       return (_Tp)1u << __shift_exponent;
     }
 
   template<typename _Tp>
     constexpr _Tp
     __bit_floor(_Tp __x) noexcept
     {
       constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits;
       if (__x == 0)
         return 0;
       return (_Tp)1u << (_Nd - std::__countl_zero((_Tp)(__x >> 1)));
     }
 
   template<typename _Tp>
     constexpr _Tp
     __bit_width(_Tp __x) noexcept
     {
       constexpr auto _Nd = __gnu_cxx::__int_traits<_Tp>::__digits;
       return _Nd - std::__countl_zero(__x);
     }
 
   /// @endcond
 
 #if __cplusplus > 201703L
 
 #define __cpp_lib_bitops 201907L
 
   /// @cond undoc
   template<typename _Tp, typename _Up = _Tp>
     using _If_is_unsigned_integer
       = enable_if_t<__is_unsigned_integer<_Tp>::value, _Up>;
   /// @endcond
 
   // [bit.rot], rotating
 
   /// Rotate `x` to the left by `s` bits.
   template<typename _Tp>
     [[nodiscard]] constexpr _If_is_unsigned_integer<_Tp>
     rotl(_Tp __x, int __s) noexcept
     { return std::__rotl(__x, __s); }
 
   /// Rotate `x` to the right by `s` bits.
   template<typename _Tp>
     [[nodiscard]] constexpr _If_is_unsigned_integer<_Tp>
     rotr(_Tp __x, int __s) noexcept
     { return std::__rotr(__x, __s); }
 
   // [bit.count], counting
 
   /// The number of contiguous zero bits, starting from the highest bit.
   template<typename _Tp>
     constexpr _If_is_unsigned_integer<_Tp, int>
     countl_zero(_Tp __x) noexcept
     { return std::__countl_zero(__x); }
 
   /// The number of contiguous one bits, starting from the highest bit.
   template<typename _Tp>
     constexpr _If_is_unsigned_integer<_Tp, int>
     countl_one(_Tp __x) noexcept
     { return std::__countl_one(__x); }
 
   /// The number of contiguous zero bits, starting from the lowest bit.
   template<typename _Tp>
     constexpr _If_is_unsigned_integer<_Tp, int>
     countr_zero(_Tp __x) noexcept
     { return std::__countr_zero(__x); }
 
   /// The number of contiguous one bits, starting from the lowest bit.
   template<typename _Tp>
     constexpr _If_is_unsigned_integer<_Tp, int>
     countr_one(_Tp __x) noexcept
     { return std::__countr_one(__x); }
 
   /// The number of bits set in `x`.
   template<typename _Tp>
     constexpr _If_is_unsigned_integer<_Tp, int>
     popcount(_Tp __x) noexcept
     { return std::__popcount(__x); }
 
   // [bit.pow.two], integral powers of 2
 
 #define __cpp_lib_int_pow2 202002L
 
   /// True if `x` is a power of two, false otherwise.
   template<typename _Tp>
     constexpr _If_is_unsigned_integer<_Tp, bool>
     has_single_bit(_Tp __x) noexcept
     { return std::__has_single_bit(__x); }
 
   /// The smallest power-of-two not less than `x`.
   template<typename _Tp>
     constexpr _If_is_unsigned_integer<_Tp>
     bit_ceil(_Tp __x) noexcept
     { return std::__bit_ceil(__x); }
 
   /// The largest power-of-two not greater than `x`.
   template<typename _Tp>
     constexpr _If_is_unsigned_integer<_Tp>
     bit_floor(_Tp __x) noexcept
     { return std::__bit_floor(__x); }
 
   /// The smallest integer greater than the base-2 logarithm of `x`.
   template<typename _Tp>
     constexpr _If_is_unsigned_integer<_Tp>
     bit_width(_Tp __x) noexcept
     { return std::__bit_width(__x); }
 
 #define __cpp_lib_endian 201907L
 
   /// Byte order
   enum class endian
   {
     little = __ORDER_LITTLE_ENDIAN__,
     big    = __ORDER_BIG_ENDIAN__,
     native = __BYTE_ORDER__
   };
 #endif // C++2a
 
   /// @}
 
 _GLIBCXX_END_NAMESPACE_VERSION
 } // namespace std
 
 #endif // C++14
 #endif // _GLIBCXX_BIT
 

using namespace std;
#define int long long
int a, b;

signed main() {
    cin >> a >>b;
    cout << a + b;
    return 0;
}
        • @ 2025-4-12 9:23:41
          已修改
          #include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
  
int main(){
  int a,b;
  std::cin>>a>>b;
  std::cout<<a+b;
}

          3307行，谁跟我比

        • @ 2025-4-5 22:37:33 
          #include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <cmath>
#include <thread>
#include <chrono>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <functional>
#include <memory>
#include <random>
#include <numeric>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <climits>
#include <cfloat>
#include <cstddef>
#include <cstdint>
#include <cassert>
#include <cwchar>
#include <cwctype>
#include <exception>
#include <stdexcept>
#include <typeinfo>
#include <type_traits>
#include <bitset>
#include <complex>
#include <valarray>
#include <array>
#include <forward_list>
#include <list>
#include <deque>
#include <initializer_list>
#include <tuple>
#include <utility>
#include <variant>
#include <optional>
#include <any>
#include <filesystem>
#include <regex>
#include <atomic>
#include <mutex>
#include <condition_variable>
#include <future>
#include <shared_mutex>
#include <execution>
#include <codecvt>
#include <locale>
#include <ciso646>
#include <cerrno>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdarg>
#include <cstdbool>
#include <ctgmath>
#include <cuchar>
#include <limits>
#include <ios>
#include <iosfwd>
#include <istream>
#include <ostream>
#include <streambuf>
#include <sstream>
#include <iomanip>
#include <bits/stdc++.h>
using namespace std;
void do_nothing_1();
void do_nothing_2(int x);
int do_nothing_3(int a, int b);
long long do_nothing_4(long long x);
float do_nothing_5(float a, float b);
double do_nothing_6(double x);
int unused_var_1 = 0;
float unused_var_2 = 3.14;
string unused_var_3 = "Hello, World!";
vector<int> unused_var_4 = {1, 2, 3};
map<string, int> unused_var_5 = {{"A", 1}, {"B", 2}};
class UselessClass1
{
    public:
        UselessClass1() {}
        void useless_method_1() {}
        int useless_method_2(int x)
        {
            return x + 1;
        }
};
class UselessClass2 : public UselessClass1
{
    public:
        UselessClass2() {}
        void useless_method_3() {}
};
template <typename T>
T useless_template(T x)
{
    return x + 1;
}
#define USELESS_MACRO_1(x) (x + 1)
#define USELESS_MACRO_2(x, y) (x + y + 1)
int recursive_nonsense(int x)
{
    if (x <= 0)
        return 0;
    return recursive_nonsense(x - 1) + 1;
}
int add_recursive(int x, int y)
{
    if (y == 0)
        return x;
    return add_recursive(x ^ y, (x & y) << 1);
}
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);
    connect(A,B);
    cut(A,B);
    connect(A,B);
    int answer=query(A,B);
    printf("%d",answer);
    puts("");
    int return_value =answer-answer;
    return return_value;
}
        • @ 2025-4-5 22:27:18 
          #include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <cmath>
#include <thread>
#include <chrono>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <functional>
#include <memory>
#include <random>
#include <numeric>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <climits>
#include <cfloat>
#include <cstddef>
#include <cstdint>
#include <cassert>
#include <cwchar>
#include <cwctype>
#include <exception>
#include <stdexcept>
#include <typeinfo>
#include <type_traits>
#include <bitset>
#include <complex>
#include <valarray>
#include <array>
#include <forward_list>
#include <list>
#include <deque>
#include <initializer_list>
#include <tuple>
#include <utility>
#include <variant>
#include <optional>
#include <any>
#include <filesystem>
#include <regex>
#include <atomic>
#include <mutex>
#include <condition_variable>
#include <future>
#include <shared_mutex>
#include <execution>
#include <codecvt>
#include <locale>
#include <ciso646>
#include <cerrno>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdarg>
#include <cstdbool>
#include <ctgmath>
#include <cuchar>
#include <limits>
#include <ios>
#include <iosfwd>
#include <istream>
#include <ostream>
#include <streambuf>
#include <sstream>
#include <iomanip>
#include <bits/stdc++.h>
using namespace std;
void do_nothing_1();
void do_nothing_2(int x);
int do_nothing_3(int a, int b);
long long do_nothing_4(long long x);
float do_nothing_5(float a, float b);
double do_nothing_6(double x);
int unused_var_1 = 0;
float unused_var_2 = 3.14;
string unused_var_3 = "Hello, World!";
vector<int> unused_var_4 = {1, 2, 3};
map<string, int> unused_var_5 = {{"A", 1}, {"B", 2}};
class UselessClass1
{
public:
    UselessClass1() {}
    void useless_method_1() {}
    int useless_method_2(int x)
    {
        return x + 1;
    }
};
class UselessClass2 : public UselessClass1
{
public:
    UselessClass2() {}
    void useless_method_3() {}
};
template <typename T>
T useless_template(T x)
{
    return x + 1;
}
#define USELESS_MACRO_1(x) (x + 1)
#define USELESS_MACRO_2(x, y) (x + y + 1)
int recursive_nonsense(int x)
{
    if (x <= 0)
        return 0;
    return recursive_nonsense(x - 1) + 1;
}
int add_recursive(int x, int y)
{
    if (y == 0)
        return x;
    return add_recursive(x ^ y, (x & y) << 1);
}
int add_with_stack(int a, int b)
{
    stack<int> s;
    s.push(a);
    s.push(b);
    int sum = 0;
    while (!s.empty())
    {
        sum += s.top();
        s.pop();
    }
    return sum;
}
int main()
{
    int a, b;
    cin >> a >> b;
    cout << add_with_stack(a, b);
    puts("");
    int return_value = USELESS_MACRO_1(add_with_stack(a, b)) - add_with_stack(a, b);
    return 0;
}

          我老爸得了MVP!洗了点阳光tsing~ti↗!

          • @ 2025-4-5 22:25:44

            #include #include #include #include #include #include #include #include #include #include #include #include <unordered_map> #include <unordered_set> #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include <type_traits> #include #include #include #include #include <forward_list> #include #include #include <initializer_list> #include #include #include #include #include #include #include #include #include #include <condition_variable> #include #include <shared_mutex> #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include #include <bits/stdc++.h> using namespace std; void do_nothing_1(); void do_nothing_2(int x); int do_nothing_3(int a, int b); long long do_nothing_4(long long x); float do_nothing_5(float a, float b); double do_nothing_6(double x); int unused_var_1 = 0; float unused_var_2 = 3.14; string unused_var_3 = "Hello, World!"; vector unused_var_4 = {1, 2, 3}; map<string, int> unused_var_5 = {{"A", 1}, {"B", 2}}; class UselessClass1 { public: UselessClass1() {} void useless_method_1() {} int useless_method_2(int x) { return x + 1; } }; class UselessClass2 : public UselessClass1 { public: UselessClass2() {} void useless_method_3() {} }; template T useless_template(T x) { return x + 1; } #define USELESS_MACRO_1(x) (x + 1) #define USELESS_MACRO_2(x, y) (x + y + 1) int recursive_nonsense(int x) { if (x <= 0) return 0; return recursive_nonsense(x - 1) + 1; } int add_recursive(int x, int y) { if (y == 0) return x; return add_recursive(x ^ y, (x & y) << 1); } int add_with_stack(int a, int b) { stack s; s.push(a); s.push(b); int sum = 0; while (!s.empty()) { sum += s.top(); s.pop(); } return sum; } int main() { int a, b; cin >> a >> b; cout << add_with_stack(a, b); puts(""); int return_value = USELESS_MACRO_1(add_with_stack(a, b)) - add_with_stack(a, b); return 0; }

            • @ 2025-4-5 20:38:32

              多来点空格不就得了

              • @ 2025-4-2 17:54:08

                我是MVP

                • @ 2025-4-2 17:40:30
                  已修改
                  #include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <cmath>
#include <thread>
#include <chrono>
#include <queue>
#include <stack>
#include <map>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <functional>
#include <memory>
#include <random>
#include <numeric>
#include <iomanip>
#include <sstream>
#include <fstream>
#include <cstdio>
#include <cstdlib>
#include <ctime>
#include <cstring>
#include <climits>
#include <cfloat>
#include <cstddef>
#include <cstdint>
#include <cassert>
#include <cwchar>
#include <cwctype>
#include <exception>
#include <stdexcept>
#include <typeinfo>
#include <type_traits>
#include <bitset>
#include <complex>
#include <valarray>
#include <array>
#include <forward_list>
#include <list>
#include <deque>
#include <initializer_list>
#include <tuple>
#include <utility>
#include <variant>
#include <optional>
#include <any>
#include <filesystem>
#include <regex>
#include <atomic>
#include <mutex>
#include <condition_variable>
#include <future>
#include <shared_mutex>
#include <execution>
#include <codecvt>
#include <locale>
#include <ciso646>
#include <cerrno>
#include <cfenv>
#include <cinttypes>
#include <cstdalign>
#include <cstdarg>
#include <cstdbool>
#include <ctgmath>
#include <cuchar>
#include <limits>
#include <ios>
#include <iosfwd>
#include <istream>
#include <ostream>
#include <streambuf>
#include <sstream>
#include <iomanip>
#include <bits/stdc++.h>
#include <iostream>
#include <stack>
using namespace std;
void do_nothing_1();
void do_nothing_2(int x);
int do_nothing_3(int a, int b);
long long do_nothing_4(long long x);
float do_nothing_5(float a, float b);
double do_nothing_6(double x);
int unused_var_1 = 0;
float unused_var_2 = 3.14;
string unused_var_3 = "Hello, World!";
vector<int> unused_var_4 = {1, 2, 3};
map<string, int> unused_var_5 = {{"A", 1}, {"B", 2}};
class UselessClass1 {
public:
    UselessClass1() {}
    void useless_method_1() {}
    int useless_method_2(int x) { return x + 1; }
};
class UselessClass2 : public UselessClass1 {
public:
    UselessClass2() {}
    void useless_method_3() {}
};
template<typename T>
T useless_template(T x) {
    return x + 1;
}
#define USELESS_MACRO_1(x) (x + 1)
#define USELESS_MACRO_2(x, y) (x + y + 1)
int recursive_nonsense(int x) {
    if (x <= 0) return 0;
    return recursive_nonsense(x - 1) + 1;
}
int add_recursive(int x, int y) {
    if (y == 0) return x;
    return add_recursive(x ^ y, (x & y) << 1);
}
int add_with_stack(int a, int b) {
    stack<int> s;
    s.push(a);
    s.push(b);
    int sum = 0;
    while (!s.empty()) {
        sum += s.top();
        s.pop();
    }
    return sum;
}
int main() {
    int a, b;
    cin >> a >> b;
    cout << add_with_stack(a, b) << endl;
    return 0;
}

                  132行

                  • @ 2025-4-1 19:25:15 
                    #include <algorithm>
#include <bitset>
#include <cctype>
#include <cerrno>
#include <clocale>
#include <cmath>
#include <complex>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <limits>
#include <list>
#include <map>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <utility>
#include <vector>
#include <cwchar>
#include <cwctype>
using namespace std;
int a,b;
int main()
{
    scanf("%d%d",&a,&b);
    printf("%d",a+b);
    return 0;
}

                    43行

                    • 1
                    1
                    已通过
                    0
                    题解被赞

                    A + B Problem

                    信息

                    ID
                    56
                    时间
                    1000ms
                    内存
                    256MiB
                    难度
                    1
                    标签
                    递交数
                    10362
                    已通过
                    4682
                    上传者
                    1. 关于
                    2. 联系我们
                    3. 隐私
                    4. 服务条款
                    5. 版权申诉
                    6. Language
                    7. 兼容模式
                    8. 主题
                    2. © 2021-2025 Hydro.ac
                    5. Worker 2 in 2222ms
                    6. Hydro v5.0.0-beta.1-401bb50-dirty Professional