program rpn;

const STACK_SIZE = 255;

type
   TStackType = (NUM, PLUS, MINUS, DIVIDE, MULTIPLY);
   TStackItem = record
                   t : TStackType;
                   i : Double;
                end; 
   TStack     = record
                   stack : array [1..STACK_SIZE] of TStackItem;
                   len   : Integer;
                end;     


var 
   stack : TStack;
   cmd   : String;

procedure pushStack(si : TStackItem);
begin
   stack.stack[stack.len] := si;
   inc(stack.len);
end;

procedure parseCmd(cmd : String);
var 
   i   : Integer;
   si  : TStackItem;
   tmp : String;
begin  
   tmp := '';
   cmd := cmd + ' ';
   for i := 1 to length(cmd) do begin
      if cmd[i] = ' ' then begin 
         case tmp[1] of
           '+'     : si.t := PLUS;
           '-'     : si.t := MINUS;
           '*'     : si.t := MULTIPLY;
           '/'     : si.t := DIVIDE;
           otherwise begin 
              si.t:= NUM;
              val(tmp, si.i);
           end;
         end;        
         pushStack(si);
         tmp := '';
      end else begin
         tmp := tmp + cmd[i];
      end;
   end;
end;

function popStack() : TStackItem;
begin
   if stack.len = 0 then begin 
      WriteLn('Error: pop Stack(): stack empty');
      exit;
   end;
   dec(stack.len);
   popStack := stack.stack[stack.len];
end;
	
procedure opStack();
var
   r          : double;
   s1, s2, s3 : TStackItem;
begin         
   { operator } 
   s1 := popStack();
   if s1.t = NUM then begin 
      WriteLn('Error: opStack(): Operator expected, number found');
      exit;
   end;

   s3 := popStack();
   while s3.t <> NUM do begin
      pushStack(s3);
      opStack();
      s3 := popStack();
   end;
   
   s2 := popStack();
   while s2.t <> NUM do begin
      pushStack(s2);
      opStack();
      s2 := popStack();
   end;

   case s1.t of
     PLUS     : r := s2.i + s3.i;
     MINUS    : r := s2.i - s3.i;
     MULTIPLY : r := s2.i * s3.i;
     DIVIDE   : r := s2.i / s3.i;
     otherwise begin
        WriteLn('Error: opStack(): Unrecognized command');
        exit;
     end;
   end;
   s1.t := NUM;
   s1.i := r;
   pushStack(s1);
end;

var
   i  : Integer;
   s  : String;
   si : TStackItem;

begin 
   stack.len := 0;
   cmd := '';
   ReadLn(cmd);
   while(cmd <> '') do begin
      parseCmd(cmd);
      opStack();
      { SHOOT off stack to detect errors }
      for i := stack.len-1 downto 0 do begin
         si := popStack();
         Str(si.i:9:4, s);
         WriteLn(s);
      end;
      { RESET just in case }
      stack.len := 0;
      cmd := '';
      ReadLn(cmd);
   end;
end.