@17752802808

短短400多行代码

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

template<typename T> class NumericValue;
template<typename T> class ArithmeticOperation;
class InputHandler;
class OutputHandler;
class CalculationDirector;
class CalculationStrategy;

namespace TypeTraits {
    template<typename T>
    struct is_numeric : std::integral_constant<bool,
        std::is_integral<T>::value || std::is_floating_point<T>::value> {};

    template<typename T>
    constexpr bool is_numeric_v = is_numeric<T>::value;

    template<typename T, typename = std::enable_if_t<is_numeric_v<T>>>
    struct NumericLimits {
        static constexpr T min() { return std::numeric_limits<T>::min(); }
        static constexpr T max() { return std::numeric_limits<T>::max(); }
    };
}

template<typename T>
class NumericInterface {
public:
    virtual ~NumericInterface() = default;
    virtual T getValue() const = 0;
    virtual void setValue(T value) = 0;
    virtual std::unique_ptr<NumericInterface<T>> clone() const = 0;
};

template<typename T>
class NumericValue : public NumericInterface<T> {
    static_assert(TypeTraits::is_numeric_v<T>, "Type must be numeric");
    
private:
    T value_;
    mutable std::mutex mutex_;
    
public:
    NumericValue() : value_(T{}) {}
    explicit NumericValue(T value) : value_(value) {}
    NumericValue(const NumericValue& other) {
        std::lock_guard<std::mutex> lock(other.mutex_);
        value_ = other.value_;
    }
    
    NumericValue& operator=(const NumericValue& other) {
        if (this != &other) {
            std::lock(mutex_, other.mutex_);
            std::lock_guard<std::mutex> lockThis(mutex_, std::adopt_lock);
            std::lock_guard<std::mutex> lockOther(other.mutex_, std::adopt_lock);
            value_ = other.value_;
        }
        return *this;
    }
    
    T getValue() const override {
        std::lock_guard<std::mutex> lock(mutex_);
        return value_;
    }
    
    void setValue(T value) override {
        std::lock_guard<std::mutex> lock(mutex_);
        value_ = value;
    }
    
    std::unique_ptr<NumericInterface<T>> clone() const override {
        return std::make_unique<NumericValue<T>>(*this);
    }
    
    using Observer = std::function<void(T)>;
    void addObserver(Observer observer) {
        std::lock_guard<std::mutex> lock(mutex_);
        observers_.push_back(observer);
    }
    
private:
    std::vector<Observer> observers_;
    
    void notifyObservers() {
        T currentValue;
        {
            std::lock_guard<std::mutex> lock(mutex_);
            currentValue = value_;
        }
        for (const auto& observer : observers_) {
            observer(currentValue);
        }
    }
};

template<typename T>
class OperationInterface {
public:
    virtual ~OperationInterface() = default;
    virtual T execute(const T& a, const T& b) const = 0;
    virtual std::string getName() const = 0;
    virtual std::unique_ptr<OperationInterface<T>> clone() const = 0;
};

template<typename T>
class AdditionOperation : public OperationInterface<T> {
public:
    T execute(const T& a, const T& b) const override {
        if (b >= 0) {
            T result = a;
            for (T i = T{}; i < b; ++i) {
                result += T{1};
            }
            return result;
        } else {
            T result = a;
            for (T i = T{}; i > b; --i) {
                result -= T{1};
            }
            return result;
        }
    }
    
    std::string getName() const override {
        return "addition";
    }
    
    std::unique_ptr<OperationInterface<T>> clone() const override {
        return std::make_unique<AdditionOperation<T>>(*this);
    }
};

class CalculationStrategy {
public:
    virtual ~CalculationStrategy() = default;
    virtual long long calculate(long long a, long long b) const = 0;
    virtual std::string getStrategyName() const = 0;
};

class SequentialCalculation : public CalculationStrategy {
public:
    long long calculate(long long a, long long b) const override {
        AdditionOperation<long long> addOp;
        return addOp.execute(a, b);
    }
    
    std::string getStrategyName() const override {
        return "sequential";
    }
};

class ParallelCalculation : public CalculationStrategy {
public:
    long long calculate(long long a, long long b) const override {
        auto computeA = std::async(std::launch::async, [a]() {
            std::this_thread::sleep_for(std::chrono::microseconds(1));
            return a;
        });
        
        auto computeB = std::async(std::launch::async, [b]() {
            std::this_thread::sleep_for(std::chrono::microseconds(1));
            return b;
        });
        
        AdditionOperation<long long> addOp;
        return addOp.execute(computeA.get(), computeB.get());
    }
    
    std::string getStrategyName() const override {
        return "parallel";
    }
};

class NumberExpression {
public:
    virtual ~NumberExpression() = default;
    virtual long long interpret() const = 0;
    virtual std::unique_ptr<NumberExpression> clone() const = 0;
};

class ConstantExpression : public NumberExpression {
private:
    long long value_;
    
public:
    explicit ConstantExpression(long long value) : value_(value) {}
    
    long long interpret() const override {
        return value_;
    }
    
    std::unique_ptr<NumberExpression> clone() const override {
        return std::make_unique<ConstantExpression>(*this);
    }
};

class StringNumberExpression : public NumberExpression {
private:
    std::string str_;
    
public:
    explicit StringNumberExpression(std::string str) : str_(std::move(str)) {}
    
    long long interpret() const override {
        bool negative = false;
        size_t pos = 0;
        
        if (str_.empty()) {
            throw std::invalid_argument("Empty string");
        }
        
        if (str_[0] == '-') {
            negative = true;
            pos = 1;
        }
        
        long long result = 0;
        for (; pos < str_.size(); ++pos) {
            if (!std::isdigit(static_cast<unsigned char>(str_[pos]))) {
                throw std::invalid_argument("Invalid character in number string");
            }
            result = result * 10 + (str_[pos] - '0');
        }
        
        return negative ? -result : result;
    }
    
    std::unique_ptr<NumberExpression> clone() const override {
        return std::make_unique<StringNumberExpression>(*this);
    }
};

class InputHandler {
private:
    using Token = std::string;
    std::vector<Token> tokens_;
    
public:
    void readInput() {
        std::string line;
        std::getline(std::cin, line);
        tokenize(line);
    }
    
    std::vector<std::unique_ptr<NumberExpression>> parseNumbers() const {
        std::vector<std::unique_ptr<NumberExpression>> expressions;
        
        for (const auto& token : tokens_) {
            expressions.push_back(std::make_unique<StringNumberExpression>(token));
        }
        
        if (expressions.size() != 2) {
            throw std::runtime_error("Expected exactly two numbers");
        }
        
        return expressions;
    }
    
private:
    void tokenize(const std::string& input) {
        std::istringstream iss(input);
        Token token;
        
        while (iss >> token) {
            tokens_.push_back(token);
        }
    }
};

class OutputHandler {
public:
    template<typename T>
    void printResult(const T& result) const {
        std::cout << result << std::endl;
    }
    
    template<typename T>
    void printDebugInfo(const std::string& message, const T& value) const {
    }
};

class CalculationDirector {
private:
    std::unique_ptr<CalculationStrategy> strategy_;
    OutputHandler outputHandler_;
    
public:
    CalculationDirector() : strategy_(std::make_unique<ParallelCalculation>()) {}
    
    void setStrategy(std::unique_ptr<CalculationStrategy> strategy) {
        strategy_ = std::move(strategy);
    }
    
    long long performCalculation(long long a, long long b) const {
        outputHandler_.printDebugInfo("Using strategy", strategy_->getStrategyName());
        return strategy_->calculate(a, b);
    }
};

class NumericFactory {
public:
    template<typename T>
    static std::unique_ptr<NumericInterface<T>> createNumeric(T value) {
        return std::make_unique<NumericValue<T>>(value);
    }
};

class ApplicationManager {
private:
    InputHandler inputHandler_;
    OutputHandler outputHandler_;
    CalculationDirector calculationDirector_;
    static std::unique_ptr<ApplicationManager> instance_;
    static std::once_flag initFlag_;
    
    ApplicationManager() {
        initialize();
    }
    
    friend std::unique_ptr<ApplicationManager> std::make_unique<ApplicationManager>();
    
    void initialize() {
        std::srand(std::time(nullptr));
        if (std::rand() % 2 == 0) {
            calculationDirector_.setStrategy(std::make_unique<SequentialCalculation>());
        } else {
            calculationDirector_.setStrategy(std::make_unique<ParallelCalculation>());
        }
    }
    
public:
    ApplicationManager(const ApplicationManager&) = delete;
    ApplicationManager& operator=(const ApplicationManager&) = delete;
    
    static ApplicationManager& getInstance() {
        std::call_once(initFlag_, []() {
            instance_ = std::make_unique<ApplicationManager>();
        });
        return *instance_;
    }
    
    int run() {
        try {
            outputHandler_.printDebugInfo("Application started", "");
            
            inputHandler_.readInput();
            auto expressions = inputHandler_.parseNumbers();
            
            long long a = expressions[0]->interpret();
            long long b = expressions[1]->interpret();
            
            auto numA = NumericFactory::createNumeric(a);
            auto numB = NumericFactory::createNumeric(b);
            
            long long result = calculationDirector_.performCalculation(
                numA->getValue(), numB->getValue()
            );
            
            outputHandler_.printResult(result);
            
            outputHandler_.printDebugInfo("Application finished successfully", "");
            return 0;
        } catch (const std::exception& e) {
            outputHandler_.printDebugInfo("Error occurred", e.what());
            return 1;
        }
    }
};

std::unique_ptr<ApplicationManager> ApplicationManager::instance_ = nullptr;
std::once_flag ApplicationManager::initFlag_;

int main() {
    return ApplicationManager::getInstance().run();
}

很简单，先写一个“可持久化非确定状态AC自动分块维护线段平衡仙人掌优化最小费用最大流预处理混合图上莫比乌斯反演莫队带花舞蹈链并查集树状数组套主席树预处理动态DP分治FFT求多项式逆元对数函数的指数函数用可持久化并查集合并最小费用循环流上插头DP”算法的模板，然后套进 A+B，前面加一个

#include <bits/stdc++.h>

然后用 g++ -E /path/to/file -o a.cpp编译，其中 /path/to/file 表示刚才我们写的那个套进 A+B 的“可持久化非确定状态AC自动分块维护线段平衡仙人掌优化最小费用最大流预处理混合图上莫比乌斯反演莫队带花舞蹈链并查集树状数组套主席树预处理动态DP分治FFT求多项式逆元对数函数的指数函数用可持久化并查集合并最小费用循环流上插头DP”算法的模板，然后得到的那一堆文件加上一堆注释，如果注释不算在代码长度内的话，那就用：

#if 0
efdahcfsdeamhcfskuhdrvsa uhjgussrchauvdaygrkeurgvntaekufcgueag
#endif

中间两行添加任意的不为任何 # 开头的东西即可。如果不知道填啥可以把 https://www.luogu.com.cn/article/puwfj0g6 的内容填进来。

Hydro新人

/*
#pragma GCC diagnostic error "-std=c++11"
#pragma GCC target("avx")
#pragma GCC optimize(3)
#pragma GCC optimize("Ofast")
#pragma GCC optimize("inline")
#pragma GCC optimize("-fgcse")
#pragma GCC optimize("-fgcse-lm")
#pragma GCC optimize("-fipa-sra")
#pragma GCC optimize("-ftree-pre")
#pragma GCC optimize("-ftree-vrp")
#pragma GCC optimize("-fpeephole2")
#pragma GCC optimize("-ffast-math")
#pragma GCC optimize("-fsched-spec")
#pragma GCC optimize("unroll-loops")
#pragma GCC optimize("-falign-jumps")
#pragma GCC optimize("-falign-loops")
#pragma GCC optimize("-falign-labels")
#pragma GCC optimize("-fdevirtualize")
#pragma GCC optimize("-fcaller-saves")
#pragma GCC optimize("-fcrossjumping")
#pragma GCC optimize("-fthread-jumps")
#pragma GCC optimize("-funroll-loops")
#pragma GCC optimize("-fwhole-program")
#pragma GCC optimize("-freorder-blocks")
#pragma GCC optimize("-fschedule-insns")
#pragma GCC optimize("inline-functions")
#pragma GCC optimize("-ftree-tail-merge")
#pragma GCC optimize("-fschedule-insns2")
#pragma GCC optimize("-fstrict-aliasing")
#pragma GCC optimize("-fstrict-overflow")
#pragma GCC optimize("-falign-functions")
#pragma GCC optimize("-fcse-skip-blocks")
#pragma GCC optimize("-fcse-follow-jumps")
#pragma GCC optimize("-fsched-interblock")
#pragma GCC optimize("-fpartial-inlining")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("-freorder-functions")
#pragma GCC optimize("-findirect-inlining")
#pragma GCC optimize("-fhoist-adjacent-loads")
#pragma GCC optimize("-frerun-cse-after-loop")
#pragma GCC optimize("inline-small-functions")
#pragma GCC optimize("-finline-small-functions")
#pragma GCC optimize("-ftree-switch-conversion")
#pragma GCC optimize("-foptimize-sibling-calls")
#pragma GCC optimize("-fexpensive-optimizations")
#pragma GCC optimize("-funsafe-loop-optimizations")
#pragma GCC optimize("inline-functions-called-once")
#pragma GCC optimize("-fdelete-null-pointer-checks")
/*
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <exception>
#include <fstream>
#include <functional>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <iostream>
#include <istream>
#include <iterator>
#include <limits>
#include <list>
#include <locale>
#include <map>
#include <memory>
#include <new>
#include <numeric>
#include <ostream>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <stdexcept>
#include <streambuf>
#include <string>
#include <typeinfo>
#include <utility>
#include <valarray>
#include <vector> 
#include <array>
#include <atomic>
#include <chrono>
#include <condition_variable>
#include <forward_list>
#include <future>
#include <initializer_list>
#include <mutex>
#include <random>
#include <ratio>
#include <regex>
#include <scoped_allocator>
#include <system_error>
#include <thread>
#include <tuple>
#include <typeindex>
#include <type_traits>
#include <unordered_map>
#include <unordered_set>
*/
#include<bits/stdc++.h>
#define ls u<<1
#define rs u<<1|1
using namespace std;
int a[10], w[40], tag[40];
void pushup(int u){
	w[u] = w[ls]+w[rs];
}
void build(int u, int l, int r){
	if(l == r){
		w[u] = a[l];
		return;
	}
	int mid = l+r >> 1;
	build(ls, l, mid);
	build(rs, mid+1, r);
	pushup(u);
}
void maketag(int u, int l, int r, int x){
	int len = r-l+1;
	tag[u] += x;
	w[u] += len*x;
}
void pushdown(int u, int l, int r){
	int mid = l+r >> 1;
	maketag(ls, l, mid, tag[u]);
	maketag(rs, mid+1, r, tag[u]);
	tag[u] = 0;
}
bool inrange(int L, int R, int l, int r){
	return (l <= L) && (R <= r);
}
bool outofrange(int L, int R, int l, int r){
	return (L > r) || (R < l);
}
int query(int u, int L, int R, int l, int r){
	if(inrange(L, R, l, r)){
		return w[u];
	}else if(!outofrange(L, R, l, r)){
		int mid = L+R >> 1;
		pushdown(u, L, R);
		return query(ls, L, mid, l, r)+query(rs, mid+1, R, l, r);
	}else return 0;
}
void update(int u, int L, int R, int l, int r, int x){
	if(inrange(L, R, l, r)){
		maketag(u, L, R, x);
	}else if(!outofrange(L, R, l, r)){
		int mid = L+R >> 1;
		pushdown(u, L, R);
		update(ls, L, mid, l, r, x);
		update(rs, mid+1, R, l, r, x);
		pushup(u);
	}
}
int main(){
	cin >> a[1] >> a[2];
	build(1, 1, 2);
	//update(1, 1, 2, 1, 1, a[1]);update(1, 1, 2, 2, 2, a[2]);
	cout << query(1, 1, 2, 1, 2); 
	return 0;
}

嗯，注释、无用的头文件和变量、瞎搞的函数、还有那些玄学优化，都可以浪费很多空间

你直接写一个两个线段树一个普通一个动态开点其中普通的那个既要求和又要最大值再弄一个dijkstra、SPFA、Bellman-ford最好加个分层图，再弄一个LCA和01背包完全背包多重背包恰好装满背包二维背包多维背包一堆背包，顺便来个ST表、并查集、单调栈，再把一维差分二维差分、动态规划（线性二维图上树形换根状压……）全写一遍、还可以加一些离散化、拓扑排序、最小生成树……每个算法写一个函数（都不执行）再加上它们所需要的什么变量数组向量映射什么的包有1000行了。要是嫌不够再来一堆STL把每个容器a到z全开一遍，一个一行。还想挣扎是吗那你加法用高精度套一个深搜每次加一遍减一遍，在弄个注释复制一篇小说一句一行完美。

这没有意义，完全可以打一堆无用注释增加长度。

从前有一个东西叫做洛谷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;
}

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

#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;
}

// 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;
}

#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#include<iostream>
#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行，谁跟我比

#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;
}

#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↗!

#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; }

多来点空格不就得了

我是MVP

#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行

#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行