import demeter.*;
class Container extends Item {
  private Item_List contents;
  public Item_List get_contents() { return contents; }
  public void set_contents(Item_List new_contents)
    { contents = new_contents; }
  private Capacity capacity;
  public Capacity get_capacity() { return capacity; }
  public void set_capacity(Capacity new_capacity)
    { capacity = new_capacity; }
  Container() { }
  public Container(Item_List contents, Capacity capacity) {
    super();
    set_contents(contents);
    set_capacity(capacity);
  }
  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 Item {
  public Item() {
    super();
  }
  public void allWeights_trv1(CountingVisitor cV, SummingVisitor sV, AverageVisitor aV) {
  }
}

class Simple extends Item {
  private ItemName name;
  public ItemName get_name() { return name; }
  public void set_name(ItemName new_name)
    { name = new_name; }
  private Weight w;
  public Weight get_w() { return w; }
  public void set_w(Weight new_w)
    { w = new_w; }
  Simple() { }
  public Simple(ItemName name, Weight w) {
    super();
    set_name(name);
    set_w(w);
  }
  public static Simple parse(java.io.InputStream in) throws ParseError
    { return new Parser(in).Simple(); }
  public static Simple 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 ItemName {
  private Ident i;
  public Ident get_i() { return i; }
  public void set_i(Ident new_i)
    { i = new_i; }
  ItemName() { }
  public ItemName(Ident i) {
    super();
    set_i(i);
  }
  public static ItemName parse(java.io.InputStream in) throws ParseError
    { return new Parser(in).ItemName(); }
  public static ItemName parse(String str) throws ParseError
    { return parse(new java.io.StringBufferInputStream(str)); }
}

class Capacity {
  private Integer i;
  public Integer get_i() { return i; }
  public void set_i(Integer new_i)
    { i = new_i; }
  Capacity() { }
  public Capacity(Integer i) {
    super();
    set_i(i);
  }
  public static Capacity parse(java.io.InputStream in) throws ParseError
    { return new Parser(in).Capacity(); }
  public static Capacity parse(String str) throws ParseError
    { return parse(new java.io.StringBufferInputStream(str)); }
}

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)); }

  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);
  }
}

class Item_List {
  private Nonempty_Item_List first;
  public Nonempty_Item_List get_first() { return first; }
  public void set_first(Nonempty_Item_List new_first)
    { first = new_first; }
  Item_List() { }
  public Item_List(Nonempty_Item_List first) {
    super();
    set_first(first);
  }
  public static Item_List parse(java.io.InputStream in) throws ParseError
    { return new Parser(in).Item_List(); }
  public static Item_List parse(String str) throws ParseError
    { return parse(new java.io.StringBufferInputStream(str)); }
  public void allWeights_trv1(CountingVisitor cV, SummingVisitor sV, AverageVisitor aV) {
    if (first != null)
      first.allWeights_trv1(cV, sV, aV);
  }
}

class Nonempty_Item_List {
  private Item it;
  public Item get_it() { return it; }
  public void set_it(Item new_it)
    { it = new_it; }
  private Nonempty_Item_List next;
  public Nonempty_Item_List get_next() { return next; }
  public void set_next(Nonempty_Item_List new_next)
    { next = new_next; }
  Nonempty_Item_List() { }
  public Nonempty_Item_List(Item it, Nonempty_Item_List next) {
    super();
    set_it(it);
    set_next(next);
  }
  public static Nonempty_Item_List parse(java.io.InputStream in) throws ParseError
    { return new Parser(in).Nonempty_Item_List(); }
  public static Nonempty_Item_List parse(String str) throws ParseError
    { return parse(new java.io.StringBufferInputStream(str)); }
  public void allWeights_trv1(CountingVisitor cV, SummingVisitor sV, AverageVisitor aV) {
    it.allWeights_trv1(cV, sV, aV);
    if (next != null)
      next.allWeights_trv1(cV, sV, aV);
  }
}