use std::io::{BufWriter, Write};
use std::fs::{self, File};

fn main() -> std::io::Result<()>{
    let myexpr = fs::read_to_string("evaluare.in")?;
    let mut writer = BufWriter::new(File::create("evaluare.out")?);
    let mut stack : Vec<char> = vec![];
    let mut poloneza : Vec<String> = vec![];
    let mut chars=myexpr.chars().peekable();
    use std::collections::HashMap;
    let prio=HashMap ::from([('(', 0), ('+', 1), ('-', 2), ('*', 3), ('/', 4)]);
    while let Some(c) = chars.next() {
        match c {
            '(' => {
                stack.push(c);
            }
            ')' => {
                loop {
                    let ch = stack.pop().unwrap();
                    if ch == '(' {
                        break;
                    }
                    else {
                        poloneza.push(String::from(ch));
                    }
                }
            }
            '0'..='9' => {
                let mut nr = String::new();
                nr.push(c);
                while let Some(&ch) = chars.peek()
                    {
                        if !ch.is_ascii_digit() {
                            break;
                        }
                        chars.next();
                        nr.push(ch);
                    }
                poloneza.push(nr);
            }
            _ => {
                loop {
                    if stack.is_empty() {
                        break;
                    }
                    let ch = stack[stack.len() - 1];
                    if ch == '(' || ch == ')' || prio.get(&c).unwrap() > prio.get(&ch).unwrap() {
                        break;
                    }
                    poloneza.push(String::from(stack.pop().unwrap()));   
                }
                stack.push(c);
            }
        }   
    }
    while let Some(c) = stack.pop() {
        poloneza.push(String::from(c));
    }
    let mut variable_stack : Vec <i32> = vec![];
    for c in poloneza {
        match c.chars().nth(0).unwrap() {
            '0'..='9' => {
                variable_stack.push(c.parse::<i32>().unwrap());
            }
            _ => {
                let a = variable_stack.pop().unwrap();
                let b = variable_stack.pop().unwrap();
                eprintln!("{} {} {}",a,b,c);
                match &c[0..1] {
                    "+" => variable_stack.push(a+b),
                    "-" => variable_stack.push(b-a),
                    "*" => variable_stack.push(a*b),
                    "/" => variable_stack.push(b/a),
                    _ =>{}
                }

            }
        }
    }
    write!(writer,"{}",variable_stack.pop().unwrap())?;
    Ok(())
}