import demeter.*;
class Container {
  private List contents;
  public List get_contents() { return contents; }
  public void set_contents(List new_contents)
    { contents = new_contents; }
  Container() { }
  public Container(List contents) {
    super();
    set_contents(contents);
  }
  public static Container parse(java.io.InputStream in) throws ParseError
    { return new Parser(in).Container(); }
  public static Container parse(String str) throws ParseError
    { return parse(new java.io.StringBufferInputStream(str)); }

// traverse while counting and summing
  float statistics() throws Exception {
    // adaptive specification of objects using parsing
    CountingVisitor cV = CountingVisitor.parse("0");
    SummingVisitor sV = SummingVisitor.parse("0");
    AverageVisitor aV = new AverageVisitor(cV,sV,new Float(0.0));
    this.allWeights(cV,sV,aV);
    // better this.allWeights(aV);
    return aV.get_current().floatValue();
  }
    public void allWeights(CountingVisitor cV, SummingVisitor sV, AverageVisitor aV)
    { allWeights_trv1(cV, sV, aV); }
  public void allWeights_trv1(CountingVisitor cV, SummingVisitor sV, AverageVisitor aV) {
    contents.allWeights_trv1(cV, sV, aV);
  }
}

abstract class List {
  public List() {
    super();
  }
  public void allWeights_trv1(CountingVisitor cV, SummingVisitor sV, AverageVisitor aV) {
  }
}

class E extends List {
  public E() {
    super();
  }
  public static E parse(java.io.InputStream in) throws ParseError
    { return new Parser(in).E(); }
  public static E parse(String str) throws ParseError
    { return parse(new java.io.StringBufferInputStream(str)); }
}

class N extends List {
  private Item first;
  public Item get_first() { return first; }
  public void set_first(Item new_first)
    { first = new_first; }
  private List rest;
  public List get_rest() { return rest; }
  public void set_rest(List new_rest)
    { rest = new_rest; }
  N() { }
  public N(Item first, List rest) {
    super();
    set_first(first);
    set_rest(rest);
  }
  public static N parse(java.io.InputStream in) throws ParseError
    { return new Parser(in).N(); }
  public static N parse(String str) throws ParseError
    { return parse(new java.io.StringBufferInputStream(str)); }
  public void allWeights_trv1(CountingVisitor cV, SummingVisitor sV, AverageVisitor aV) {
    first.allWeights_trv1(cV, sV, aV);
    rest.allWeights_trv1(cV, sV, aV);
  }
}

class Item {
  private Ident name;
  public Ident get_name() { return name; }
  public void set_name(Ident new_name)
    { name = new_name; }
  private Weight w;
  public Weight get_w() { return w; }
  public void set_w(Weight new_w)
    { w = new_w; }
  Item() { }
  public Item(Ident name, Weight w) {
    super();
    set_name(name);
    set_w(w);
  }
  public static Item parse(java.io.InputStream in) throws ParseError
    { return new Parser(in).Item(); }
  public static Item parse(String str) throws ParseError
    { return parse(new java.io.StringBufferInputStream(str)); }
  public void allWeights_trv1(CountingVisitor cV, SummingVisitor sV, AverageVisitor aV) {
    w.allWeights_trv1(cV, sV, aV);
  }
}

class Weight {
  private Integer i;
  public Integer get_i() { return i; }
  public void set_i(Integer new_i)
    { i = new_i; }
  Weight() { }
  public Weight(Integer i) {
    super();
    set_i(i);
  }
  public static Weight parse(java.io.InputStream in) throws ParseError
    { return new Parser(in).Weight(); }
  public static Weight parse(String str) throws ParseError
    { return parse(new java.io.StringBufferInputStream(str)); }
  public void allWeights_trv1(CountingVisitor cV, SummingVisitor sV, AverageVisitor aV) {
    cV.before(this);
    sV.before(this);
    aV.before(this);
  }
}

class SummingVisitor {
  private Integer total;
  public Integer get_total() { return total; }
  public void set_total(Integer new_total)
    { total = new_total; }
  SummingVisitor() { }
  public SummingVisitor(Integer total) {
    super();
    set_total(total);
  }
  public static SummingVisitor parse(java.io.InputStream in) throws ParseError
    { return new Parser(in).SummingVisitor(); }
  public static SummingVisitor parse(String str) throws ParseError
    { return parse(new java.io.StringBufferInputStream(str)); }
  public void before(Weight host) { System.out.println("sum"); total = new 
    Integer(total.intValue() + host.get_i().intValue()); }
}

class CountingVisitor {
  private Integer total;
  public Integer get_total() { return total; }
  public void set_total(Integer new_total)
    { total = new_total; }
  CountingVisitor() { }
  public CountingVisitor(Integer total) {
    super();
    set_total(total);
  }
  public static CountingVisitor parse(java.io.InputStream in) throws ParseError
    { return new Parser(in).CountingVisitor(); }
  public static CountingVisitor parse(String str) throws ParseError
    { return parse(new java.io.StringBufferInputStream(str)); }
  public void before(Weight host) { System.out.println("count");
	      total = new Integer(total.intValue() + 1); }
}

class AverageVisitor {
  private CountingVisitor cV;
  public CountingVisitor get_cV() { return cV; }
  public void set_cV(CountingVisitor new_cV)
    { cV = new_cV; }
  private SummingVisitor sV;
  public SummingVisitor get_sV() { return sV; }
  public void set_sV(SummingVisitor new_sV)
    { sV = new_sV; }
  private Float current;
  public Float get_current() { return current; }
  public void set_current(Float new_current)
    { current = new_current; }
  AverageVisitor() { }
  public AverageVisitor(CountingVisitor cV, SummingVisitor sV, Float current) {
    super();
    set_cV(cV);
    set_sV(sV);
    set_current(current);
  }
  public static AverageVisitor parse(java.io.InputStream in) throws ParseError
    { return new Parser(in).AverageVisitor(); }
  public static AverageVisitor parse(String str) throws ParseError
    { return parse(new java.io.StringBufferInputStream(str)); }

    void update() { current = new Float(
      (float) this.get_sV().get_total().intValue()/
         (float) this.get_cV().get_total().intValue());
      System.out.println(current.floatValue() + " = partial result");
	 } ;
    public void before(Weight host) { update(); }
}

class Main {
  public Main() {
    super();
  }
  public static Main parse(java.io.InputStream in) throws ParseError
    { return new Parser(in).Main(); }
  public static Main parse(String str) throws ParseError
    { return parse(new java.io.StringBufferInputStream(str)); }

//  import java.lang.*;

  static public void main(String args[]) throws Exception {

    Runtime rt = Runtime.getRuntime();
    rt.traceMethodCalls(true);

    Container a = Container.parse(System.in);

    float r = a.statistics();

    System.out.println("done " + r);
  }
}