use std::fs::File;
use std::io::{BufReader, Write};
 
type Result<T> = std::result::Result<T, Box<dyn std::error::Error>>;
 
use io::InputStream;

mod io {
    use std::fmt::Debug;
    use std::io::Read;
    use std::str;
    use std::str::FromStr;
    use super::Result;
 
    pub struct InputStream<T: Read> {
        reader: T,
        byte_buffer: Vec<u8>,
        pos: usize,
        len: usize,
        temp_buffer: Vec<u8>,
    }
 
    fn is_whitespace(c: u8) -> bool {
        match c {
            b' ' | b'\x09'..=b'\x0d' => true,
            _ => false,
        }
    }
 
    impl<T: Read> InputStream<T> {
        const BUFFER_SIZE: usize = 65536;
 
        pub fn new(reader: T) -> Self {
            Self {
                reader,
                byte_buffer: vec![0; Self::BUFFER_SIZE],
                pos: 0,
                len: 0,
                temp_buffer: Vec::new(),
            }
        }
 
        fn current_byte(&self) -> u8 {
            self.byte_buffer[self.pos]
        }
 
        fn advance(&mut self) -> Result<()> {
            if self.len > 0 {
                self.pos += 1;
            }
            if self.pos == self.len {
                self.len = self.reader.read(&mut self.byte_buffer)?;
                self.pos = 0;
            }
            Ok(())
        }
 
        pub fn scan<F: FromStr>(&mut self) -> Result<F>
        where
            <F as FromStr>::Err: Debug + std::error::Error + 'static,
        {
            if self.len == 0 {
                self.advance()?;
            }
 
            while is_whitespace(self.current_byte()) {
                self.advance()?;
            }
            self.temp_buffer.clear();
            while !is_whitespace(self.current_byte()) {
                let b = self.current_byte();
                self.temp_buffer.push(b);
                self.advance()?;
            }
	
            Ok(str::from_utf8(&self.temp_buffer)?
                .parse::<F>()?)
        }
    }
}

fn main() -> Result<()> {
    let mut input = InputStream::new(BufReader::new(File::open("adunare.in")?));
    let mut output = File::create("adunare.out")?;

    let a: i32 = input.scan()?;
    let b: i32 = input.scan()?;
    let sum: i32 = a + b;

    writeln!(output, "{}", sum)?;

    Ok(())
}