use std::io::Read;
fn main() {
    let mut s = String::new();
    std::io::stdin().read_to_string(&mut s).unwrap();
    let mut input = s.split_whitespace().flat_map(str::parse);
    let a: i64 = input.next().unwrap();
    let b: i64 = input.next().unwrap();
    println!("{}", a + b);
}

// basm/src/solution.rs
use basm::platform::io::{Reader, ReaderTrait, Writer, Print};
pub fn main() {
    let mut reader: Reader = Default::default();
    let mut writer: Writer = Default::default();
    let a = reader.i64();
    let b = reader.i64();
    writer.println(a + b);
}

// basm/src/solution.rs
use basm::platform::io::{Reader, ReaderTrait, Writer};
pub fn main() {
    let mut reader = Reader::<128>::new();
    let mut writer = Writer::<128>::new();
    let a = reader.i64();
    let b = reader.i64();
    writer.i64(a + b);
}

use basm::platform::io::{Reader, ReaderTrait, Writer, Print};
use alloc::string::ToString;
use core::str::FromStr;
use dashu::Integer;

pub fn main() {
    let mut reader: Reader = Default::default();
    let mut writer: Writer = Default::default();
    let a = Integer::from_str(&reader.word()).unwrap();
    let b = Integer::from_str(&reader.word()).unwrap();
    let ans = &a + &b;
    writer.println(ans.to_string());
}

use basm::platform::io::{Reader, ReaderTrait, Writer, Print};
use alloc::string::ToString;
use core::str::FromStr;
use dashu::Integer;

use nom::{
    IResult,
    branch::alt,
    bytes::complete::{tag, take_while},
    character::is_digit,
    character::complete::one_of,
    combinator::{all_consuming, map_res},
    multi::many0,
    sequence::{delimited, pair},
};

fn number_literal(input: &str) -> IResult<&str, Integer> {
    map_res(take_while(|x: char| is_digit(x as u8)), |s: &str| Integer::from_str(s))(input)
}
fn op(input: &str) -> IResult<&str, char> {
    one_of("+-*/")(input)
}
fn wrapped(input: &str) -> IResult<&str, Integer> {
    delimited(tag("("), expr, tag(")"))(input)
}
fn number(input: &str) -> IResult<&str, Integer> {
    alt((number_literal, wrapped))(input)
}
fn expr(input: &str) -> IResult<&str, Integer> {
    map_res(
        pair(number, many0(pair(op, number))),
        |x| -> Result<Integer, usize> {
            let (mut a, mut b) = (Integer::ZERO, x.0);
            for p in x.1 {
                match p.0 {
                    '+' => { (a, b) = (a + b, p.1); },
                    '-' => { (a, b) = (a + b, -p.1); },
                    '*' => { b *= p.1; },
                    '/' => if p.1 == Integer::ZERO { return Err(1); } else { b /= p.1; },
                    _ => unreachable!()
                }
            }
            Ok(a + b)
        }
    )(input)
}

pub fn main() {
    let mut reader: Reader = Default::default();
    let mut writer: Writer = Default::default();
    let input = reader.word();
    if let Ok((_, ans)) = all_consuming(expr)(&input) {
        writer.println(ans.to_string());
    } else {
        writer.println("ROCK");
    };
}

use basm::platform::io::{Reader, ReaderTrait, Writer, Print};
use core::cmp::max;
pub fn main() {
    let mut reader: Reader = Default::default();
    let mut writer: Writer = Default::default();
    let mut x = [usize::MAX; 100_001]; // x[i] = minimum end-value of "len >= i" increasing seq.
    while !reader.is_eof_skip_whitespace() {
        let n = reader.usize();
        let mut ans = 0;
        x[0] = 0;
        for i in 0..n {
            x[i + 1] = usize::MAX;
            let v = reader.usize();
            let (mut lo, mut hi) = (0, i);
            while lo < hi {
                let mid = (lo + hi + 1) / 2;
                if x[mid] < v { lo = mid; } else { hi = mid - 1; }
            }
            let ans_new = lo + 1;
            x[ans_new] = v;
            ans = max(ans, ans_new);
        }
        writer.println(ans);
    }
}

use alloc::vec::Vec;
use basm::platform::is_local_env;
use basm::platform::io::{Reader, ReaderTrait, Writer, Print};
use basm_macro::basm_export;

pub fn main() {
    if is_local_env() {
        let mut reader: Reader = Default::default();
        let mut writer: Writer = Default::default();
        let n = reader.usize();
        let mut a = Vec::new();
        for _ in 0..n {
            a.push(reader.i32());
        }
        let ans = sum(&mut a);
        writer.println(ans);
    }
}

#[basm_export]
fn sum(a: &mut Vec::<i32>) -> i64 {
    a.iter().map(|&x| x as i64).sum()
}

use basm::platform::is_local_env;
use basm::platform::io::{Reader, ReaderTrait, Writer, Print};
use basm_macro::basm_export;
use alloc::vec;
use alloc::vec::Vec;

pub fn main() {
    if is_local_env() {
        let mut reader: Reader = Default::default();
        let mut writer: Writer = Default::default();
        let n = reader.i32();
        let m = reader.i32();
        let k = reader.i32();
        let (mut r, mut c) = (vec![], vec![]);
        for _ in 0..n {
            r.push(reader.i32());
            c.push(reader.i32());
        }
        let ans = take_photos(n, m, k, r, c);
        writer.println(ans);
    }
}

fn deduplicate(n: i32, r: Vec::<i32>, c: Vec::<i32>) -> Vec::<(i32, i32)> {
    let mut tmp: Vec<(i32, i32)> = (0..n as usize).map(|i| if r[i] < c[i] { (r[i], c[i]) } else { (c[i], r[i]) }).collect();
    tmp.sort_unstable();
    let mut out: Vec<(i32, i32)> = vec![];
    for (rr, cc) in tmp {
        if !out.is_empty() && out[out.len() - 1].0 == rr {
            out.pop();
        }
        if !out.is_empty() && out[out.len() - 1].1 >= cc {
            continue;
        }
        out.push((rr, cc));
    }
    out
}

/* minimum hull that expects strictly decreasing slopes */
struct ConvexHullTrickLinear {
    v: Vec::<(i64, i64, usize)>,
    last_m: i64
}

impl ConvexHullTrickLinear {
    fn new() -> Self {
        Self { v: vec![], last_m: i64::MAX }
    }
    fn push(&mut self, m: i64, b: i64, user_data: usize) {
        assert!(m < self.last_m);
        while self.v.len() >= 2 {
            let (m1, b1, _) = self.v[self.v.len() - 2];
            let (m2, b2, _) = self.v[self.v.len() - 1];
            if (b2 - b1) * (m2 - m) < (b - b2) * (m1 - m2) {
                break;
            }
            self.v.pop();
        }
        self.v.push((m, b, user_data));
        self.last_m = m;
    }
    fn query(&self, x: i64) -> (i64, usize) {
        assert!(!self.v.is_empty());
        let (mut lo, mut hi) = (0, self.v.len() - 1);
        while lo < hi {
            let mid = (lo + hi) / 2;
            let (m1, b1, _) = self.v[mid];
            let (m2, b2, _) = self.v[mid + 1];
            if m1 * x + b1 < m2 * x + b2 {
                hi = mid;
            } else {
                lo = mid + 1;
            }
        }
        let (m, b, user_data) = self.v[lo];
        (m * x + b, user_data)
    }
}

fn solve_single(pts: &Vec::<(i32, i32)>, p: i64) -> (i64, usize) {
    const FACTOR: i64 = 2;

    let l = |i: usize| -> i64 { pts[i - 1].0 as i64 - 1 };
    let r = |i: usize| -> i64 { pts[i - 1].1 as i64 };

    let n = pts.len();
    let mut dp = vec![(0, 0)];
    let mut cht = ConvexHullTrickLinear::new();
    cht.push(-2 * l(1) * FACTOR, l(1) * l(1) * FACTOR, 0);
    for i in 1..=n {
        /* Query CHT */
        let (val, argmax) = cht.query(r(i));
        let dp_i = val + r(i) * r(i) * FACTOR;
        dp.push((dp_i - p, argmax + 1));

        /* Update CHT */
        if i < n {
            if l(i+1) <= r(i) {
                cht.push(-2 * l(i+1) * FACTOR, dp[i].0 - r(i) * r(i) * FACTOR + 2 * l(i+1) * r(i) * FACTOR, dp[i].1);
            } else {
                cht.push(-2 * l(i+1) * FACTOR, dp[i].0 + l(i+1) * l(i+1) * FACTOR, dp[i].1);
            }
        }
    }
    dp[n]
}

#[basm_export]
fn take_photos(n: i32, _m: i32, k: i32, r: Vec::<i32>, c: Vec::<i32>) -> i64 {
    const RANGE: i64 = 1_000_000_000_001;

    let pts = deduplicate(n, r, c);
    let (mut p_lo, mut p_hi) = (-RANGE, RANGE);
    while p_lo < p_hi {
        let p_mid = (p_lo + p_hi + 1 + 2*RANGE) / 2 - RANGE;
        let p_ans = solve_single(&pts, 2 * p_mid - 1);
        if p_ans.1 <= k as usize {
            p_lo = p_mid;
        } else {
            p_hi = p_mid - 1;
        }
    }
    let mut p_opt = 2 * p_lo - 1;
    let ans = solve_single(&pts, p_opt);
    let mut override_count = false;
    if p_opt > 0 {
        p_opt = 0;
    } else if ans.1 < k as usize {
        p_opt += 1;
        override_count = true;
    }
    let ans = solve_single(&pts, p_opt);
    (ans.0 + if override_count { k as i64 } else { ans.1 as i64 } * p_opt) / 2
}

use alloc::{format, string::String, vec::Vec};
use basm::serialization::Pair;
use basm_macro::{basm_export, basm_import};
pub fn main() {}

basm_import! {
    fn guess(b: String) -> Pair::<i32, i32>;
}

static mut ALL: Vec<i32> = Vec::new();
static mut N: i32 = 0;

#[basm_export]
fn init(_t: i32, n: i32) {
    unsafe {
        (*core::ptr::addr_of_mut!(ALL)).clear();
        N = n;
        let pow10_n = 10i32.pow(n as u32);
        'outer: for i in 0..pow10_n {
            let mut digits = [false; 10];
            let mut j = i;
            for _ in 0..n {
                let d = (j % 10) as usize;
                if digits[d] {
                    continue 'outer;
                }
                digits[d] = true;
                j /= 10;
            }
            (*core::ptr::addr_of_mut!(ALL)).push(i);
        }
    }
}

fn check(mut x: i32, mut y: i32) -> Pair<i32, i32> {
    let mut digits_x = [false; 10];
    let mut digits_y = [false; 10];
    let mut strikes = 0;
    let mut balls = 0;
    unsafe {
        for _ in 0..N {
            let d_x = (x % 10) as usize;
            let d_y = (y % 10) as usize;
            if d_x == d_y {
                strikes += 1;
            }
            if digits_x[d_y] {
                balls += 1;
            }
            if digits_y[d_x] {
                balls += 1;
            }
            digits_x[d_x] = true;
            digits_y[d_y] = true;
            x /= 10;
            y /= 10;
        }
    }
    Pair::<i32, i32>(strikes, balls)
}

#[basm_export]
fn game() {
    let mut all = unsafe { (*core::ptr::addr_of!(ALL)).clone() };
    let n = unsafe { N };
    loop {
        let query = all[0];
        let query_str = if n == 3 {
            format!("{:03}", query)
        } else {
            format!("{:04}", query)
        };
        let out = guess(query_str);
        if out == Pair(n, 0) {
            break;
        }
        let mut all_new = Vec::new();
        for x in all {
            if check(x, query) == out {
                all_new.push(x);
            }
        }
        all = all_new;
    }
}