666

#include <iostream>
#include <string>
#include <vector>
#include <algorithm>
#include <functional>
#include <memory>
#include <stdexcept>
#include <type_traits>
#include <utility>
#include <tuple>
#include <array>
#include <deque>
#include <list>
#include <forward_list>
#include <set>
#include <map>
#include <unordered_set>
#include <unordered_map>
#include <stack>
#include <queue>
#include <iterator>
#include <numeric>
#include <limits>
#include <cmath>
#include <cctype>
#include <cstdlib>
#include <cstdio>
#include <cstring>
#include <ctime>
#include <climits>
#include <cwchar>
#include <cwctype>
#include <exception>
#include <locale>
#include <fstream>
#include <iomanip>
#include <ios>
#include <iosfwd>
#include <istream>
#include <ostream>
#include <sstream>
#include <streambuf>
#include <bitset>
#include <regex>
#include <random>
#include <chrono>
#include <initializer_list>
#include <system_error>
#include <future>
#include <thread>
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <cfenv>
#include <cinttypes>
#include <cstdint>
#include <cuchar>
#include <new>
#include <typeinfo>
#include <ratio>
#include <scoped_allocator>
#include <ciso646>
#include <clocale>
#include <cstdarg>
#include <cstdbool>
#include <cstddef>
#include <csetjmp>
#include <csignal>
#include <cfloat>
#include <cerrno>

// ============ 第1层：编译时配置和验证 ============
namespace CompileTimeConfig {
    template<int A, int B>
    struct StaticAddition {
        static constexpr long long value = static_cast<long long>(A) + B;
        static_assert(value >= 0, "结果必须非负");
        static_assert(value <= 2000000000LL, "结果必须在范围内");
    };
    
    template<int N>
    struct Fibonacci {
        static constexpr int value = Fibonacci<N-1>::value + Fibonacci<N-2>::value;
    };
    template<> struct Fibonacci<0> { static constexpr int value = 0; };
    template<> struct Fibonacci<1> { static constexpr int value = 1; };
    
    // 编译时验证
    static_assert(StaticAddition<0, 0>::value == 0, "编译时加法验证失败");
    static_assert(StaticAddition<1, 1>::value == 2, "1+1!=2");
    static_assert(StaticAddition<100, 200>::value == 300, "100+200!=300");
    static_assert(Fibonacci<5>::value == 5, "F(5)!=5");
}

// ============ 第2层：异常系统 ============
class AdditionException : public std::exception {
    std::string msg;
public:
    AdditionException(const std::string& m) : msg(m) {}
    const char* what() const noexcept override { return msg.c_str(); }
};

// ============ 第3层：数值表示类 ============
class SafeNumber {
private:
    long long value;
    bool valid;
    
    void validate() {
        valid = (value >= 0 && value <= 1000000000LL);
    }
    
public:
    SafeNumber(long long v = 0) : value(v) { validate(); }
    
    static SafeNumber fromString(const std::string& str) {
        try {
            long long v = std::stoll(str);
            return SafeNumber(v);
        } catch (...) {
            throw AdditionException("无效的数字: " + str);
        }
    }
    
    long long getValue() const {
        if (!valid) throw AdditionException("无效的数值");
        return value;
    }
    
    bool isValid() const { return valid; }
    
    std::string toString() const {
        return std::to_string(value);
    }
    
    SafeNumber add(const SafeNumber& other) const {
        long long result = value + other.value;
        if (result < 0 || result > 2000000000LL) {
            throw AdditionException("加法溢出");
        }
        return SafeNumber(result);
    }
};

// ============ 第4层：算法策略接口 ============
class IAdditionStrategy {
public:
    virtual ~IAdditionStrategy() {}
    virtual std::string add(const std::string& a, const std::string& b) = 0;
    virtual std::string strategyName() const = 0;
};

// ============ 第5层：具体算法实现 ============
class DirectStrategy : public IAdditionStrategy {
public:
    std::string add(const std::string& a, const std::string& b) override {
        SafeNumber num1 = SafeNumber::fromString(a);
        SafeNumber num2 = SafeNumber::fromString(b);
        SafeNumber result = num1.add(num2);
        return result.toString();
    }
    
    std::string strategyName() const override {
        return "直接安全加法策略";
    }
};

class StringBasedStrategy : public IAdditionStrategy {
private:
    std::string addStrings(const std::string& a, const std::string& b) const {
        std::string result;
        int carry = 0;
        int i = a.length() - 1;
        int j = b.length() - 1;
        
        while (i >= 0 || j >= 0 || carry) {
            int sum = carry;
            if (i >= 0) sum += a[i--] - '0';
            if (j >= 0) sum += b[j--] - '0';
            carry = sum / 10;
            result.push_back('0' + (sum % 10));
        }
        
        std::reverse(result.begin(), result.end());
        
        // 移除前导零（保留单个零）
        size_t pos = result.find_first_not_of('0');
        if (pos == std::string::npos) return "0";
        return result.substr(pos);
    }
    
public:
    std::string add(const std::string& a, const std::string& b) override {
        return addStrings(a, b);
    }
    
    std::string strategyName() const override {
        return "字符串基础加法策略";
    }
};

class HybridStrategy : public IAdditionStrategy {
public:
    std::string add(const std::string& a, const std::string& b) override {
        // 如果数字长度小于10，使用快速方法
        if (a.length() <= 10 && b.length() <= 10) {
            try {
                long long x = std::stoll(a);
                long long y = std::stoll(b);
                long long sum = x + y;
                if (sum >= 0 && sum <= 2000000000LL) {
                    return std::to_string(sum);
                }
            } catch (...) {
                // 回退到字符串方法
            }
        }
        
        // 使用字符串方法
        StringBasedStrategy stringStrategy;
        return stringStrategy.add(a, b);
    }
    
    std::string strategyName() const override {
        return "混合加法策略";
    }
};

// ============ 第6层：算法工厂 ============
class StrategyFactory {
public:
    enum StrategyType {
        DIRECT,
        STRING_BASED,
        HYBRID,
        VALIDATED
    };
    
    static std::unique_ptr<IAdditionStrategy> createStrategy(StrategyType type) {
        switch (type) {
            case DIRECT:
                return std::unique_ptr<IAdditionStrategy>(new DirectStrategy());
            case STRING_BASED:
                return std::unique_ptr<IAdditionStrategy>(new StringBasedStrategy());
            case HYBRID:
                return std::unique_ptr<IAdditionStrategy>(new HybridStrategy());
            case VALIDATED:
                return createValidatedStrategy();
            default:
                return std::unique_ptr<IAdditionStrategy>(new HybridStrategy());
        }
    }
    
private:
    static std::unique_ptr<IAdditionStrategy> createValidatedStrategy() {
        class ValidatedStrategy : public IAdditionStrategy {
            std::unique_ptr<IAdditionStrategy> baseStrategy;
            
            bool validateResult(const std::string& a, const std::string& b, 
                               const std::string& result) {
                // 使用两种不同方法验证
                DirectStrategy direct;
                StringBasedStrategy string;
                
                std::string result1 = direct.add(a, b);
                std::string result2 = string.add(a, b);
                
                return (result == result1) && (result == result2);
            }
            
        public:
            ValidatedStrategy() 
                : baseStrategy(std::unique_ptr<IAdditionStrategy>(new HybridStrategy())) {}
            
            std::string add(const std::string& a, const std::string& b) override {
                std::string result = baseStrategy->add(a, b);
                
                if (!validateResult(a, b, result)) {
                    throw AdditionException("结果验证失败");
                }
                
                return result;
            }
            
            std::string strategyName() const override {
                return "验证性" + baseStrategy->strategyName();
            }
        };
        
        return std::unique_ptr<IAdditionStrategy>(new ValidatedStrategy());
    }
};

// ============ 第7层：输入验证器 ============
class InputValidator {
private:
    static bool isAllDigits(const std::string& s) {
        if (s.empty()) return false;
        for (char c : s) {
            if (!std::isdigit(static_cast<unsigned char>(c))) {
                return false;
            }
        }
        return true;
    }
    
    static bool isWithinRange(const std::string& s) {
        try {
            if (s.length() > 10) return false; // 超过10位肯定大于1000000000
            
            long long val = std::stoll(s);
            return val >= 0 && val <= 1000000000LL;
        } catch (...) {
            return false;
        }
    }
    
public:
    static std::pair<std::string, std::string> validateAndParse(const std::string& input) {
        std::istringstream iss(input);
        std::vector<std::string> tokens;
        std::string token;
        
        while (iss >> token) {
            tokens.push_back(token);
        }
        
        if (tokens.size() != 2) {
            throw AdditionException("需要恰好两个数字");
        }
        
        if (!isAllDigits(tokens[0]) || !isAllDigits(tokens[1])) {
            throw AdditionException("输入必须是非负整数");
        }
        
        if (!isWithinRange(tokens[0]) || !isWithinRange(tokens[1])) {
            throw AdditionException("数字超出范围 [0, 1000000000]");
        }
        
        return {tokens[0], tokens[1]};
    }
};

// ============ 第8层：输出格式化器 ============
class OutputFormatter {
public:
    static void formatAndOutput(const std::string& result) {
        std::cout << result;
    }
    
    static void formatAndOutput(long long result) {
        std::cout << result;
    }
};

// ============ 第9层：计算引擎 ============
class CalculationEngine {
private:
    std::unique_ptr<IAdditionStrategy> strategy;
    int operationCount;
    
public:
    CalculationEngine() : operationCount(0) {
        // 根据编译时信息选择策略
        if (CompileTimeConfig::StaticAddition<1, 1>::value == 2) {
            strategy = StrategyFactory::createStrategy(StrategyFactory::VALIDATED);
        } else {
            strategy = StrategyFactory::createStrategy(StrategyFactory::HYBRID);
        }
    }
    
    std::string calculate(const std::string& input) {
        try {
            operationCount++;
            
            // 验证和解析输入
            auto operands = InputValidator::validateAndParse(input);
            
            // 执行计算
            std::string result = strategy->add(operands.first, operands.second);
            
            // 额外验证
            validateResult(operands.first, operands.second, result);
            
            return result;
            
        } catch (const AdditionException& e) {
            // 尝试回退
            return fallbackCalculation(input);
        }
    }
    
    int getOperationCount() const {
        return operationCount;
    }
    
private:
    void validateResult(const std::string& a, const std::string& b, 
                       const std::string& result) {
        // 使用不同策略进行交叉验证
        HybridStrategy hybrid;
        StringBasedStrategy string;
        
        std::string result1 = hybrid.add(a, b);
        std::string result2 = string.add(a, b);
        
        if (result != result1 || result != result2) {
            throw AdditionException("交叉验证失败");
        }
    }
    
    std::string fallbackCalculation(const std::string& input) {
        // 终极回退：直接解析并计算
        std::istringstream iss(input);
        long long a, b;
        
        if (iss >> a >> b) {
            if (a >= 0 && a <= 1000000000LL && b >= 0 && b <= 1000000000LL) {
                long long result = a + b;
                if (result >= 0 && result <= 2000000000LL) {
                    return std::to_string(result);
                }
            }
        }
        
        throw AdditionException("所有计算方法都失败了");
    }
};

// ============ 第10层：主控制器 ============
class MainController {
private:
    CalculationEngine engine;
    bool initialized;
    
    void initialize() {
        // 编译时验证
        static_assert(CompileTimeConfig::Fibonacci<6>::value == 8, "斐波那契验证失败");
        static_assert(CompileTimeConfig::StaticAddition<500, 500>::value == 1000, "加法验证失败");
        
        initialized = true;
    }
    
public:
    MainController() : initialized(false) {
        initialize();
    }
    
    void run() {
        try {
            // 读取输入
            std::string input;
            if (!std::getline(std::cin, input)) {
                throw AdditionException("无法读取输入");
            }
            
            // 执行计算
            std::string result = engine.calculate(input);
            
            // 输出结果
            OutputFormatter::formatAndOutput(result);
            
        } catch (const std::exception& e) {
            // 最终回退
            finalFallback();
        }
    }
    
private:
    void finalFallback() {
        // 重新读取输入并直接计算
        std::string line;
        if (std::getline(std::cin, line)) {
            std::istringstream iss(line);
            int a, b;
            if (iss >> a >> b) {
                if (a >= 0 && a <= 1000000000 && b >= 0 && b <= 1000000000) {
                    std::cout << (static_cast<long long>(a) + b);
                    return;
                }
            }
        }
        
        // 如果连这个都失败，输出默认值
        std::cout << "0";
    }
};

// ============ 第11层：入口点 ============
int main() {
    // 编译时验证
    static_assert(CompileTimeConfig::StaticAddition<0, 0>::value == 0, "基本加法失败");
    static_assert(CompileTimeConfig::StaticAddition<999999999, 1>::value == 1000000000, "边界测试失败");
    static_assert(CompileTimeConfig::Fibonacci<0>::value == 0, "F(0)错误");
    static_assert(CompileTimeConfig::Fibonacci<10>::value == 55, "F(10)错误");
    
    try {
        MainController controller;
        controller.run();
        
        // 成功返回
        return EXIT_SUCCESS;
        
    } catch (...) {
        // 任何未捕获的异常
        return EXIT_FAILURE;
    }
}

// ============ 第12层：额外的静态验证 ============
namespace AdditionalValidation {
    // 验证基本算术
    static_assert(CompileTimeConfig::StaticAddition<1, 2>::value == 3, "1+2!=3");
    static_assert(CompileTimeConfig::StaticAddition<100, 200>::value == 300, "100+200!=300");
    static_assert(CompileTimeConfig::StaticAddition<123456789, 987654321>::value == 1111111110LL, "大数加法错误");
    
    // 验证斐波那契数列
    static_assert(CompileTimeConfig::Fibonacci<1>::value == 1, "F(1)!=1");
    static_assert(CompileTimeConfig::Fibonacci<2>::value == 1, "F(2)!=1");
    static_assert(CompileTimeConfig::Fibonacci<3>::value == 2, "F(3)!=2");
    static_assert(CompileTimeConfig::Fibonacci<4>::value == 3, "F(4)!=3");
    static_assert(CompileTimeConfig::Fibonacci<7>::value == 13, "F(7)!=13");
    static_assert(CompileTimeConfig::Fibonacci<8>::value == 21, "F(8)!=21");
    
    // 验证类型特性
    static_assert(std::is_integral<int>::value, "int不是整数类型");
    static_assert(std::is_arithmetic<long long>::value, "long long不是算术类型");
    static_assert(std::is_signed<int>::value, "int不是有符号类型");
    static_assert(std::is_unsigned<unsigned int>::value, "unsigned int不是无符号类型");
    
    // 验证数值限制
    static_assert(std::numeric_limits<int>::is_specialized, "int没有数值限制");
    static_assert(std::numeric_limits<long long>::max() > 1000000000LL, "long long最大值太小");
    static_assert(std::numeric_limits<int>::digits >= 31, "int位数不足");
}

// 文件结束：超过500行的复杂A+B实现
// 这个版本经过优化，应该能在OJ环境中正常运行