#!java

  public Vec log() {
    double[] newElem = new double[element.length];
    for (int i = 0; i < element.length; i++) {
      newElem[i] = Math.log(element[i]);
    }
    return new Vec(newElem);
  }

  public double[] toArray() {
    double[] newElem = new double[element.length];
    for (int i = 0; i < element.length; i++) {
      newElem[i] = element[i];
    }
    return newElem;
  }

public static Vec[] transpose(final Vec[] vecs) {
  final List<Vec> result = new ArrayList<Vec>();
  for (int i = 0; i < vecs[0].length(); i++) {
    final double[] xs = new double[vecs.length];
    for (int j = 0; j < vecs.length; j++) {
      xs[j] = vecs[j].get(i);
    }
    result.add(new Vec(xs));
  }
  final Vec[] vecst = new Vec[result.size()];
  result.toArray(vecst);
  return vecst;
}

class Pair<A,B> {
  final private A a;
  final private B b;
  Pair(final A a, final B b) {
    this.a = a;
    this.b = b;
  }
  public A getA() {
    return a;
  }
  public B getB() {
    return b;
  }
  @Override
  public boolean equals(final Object o) {
    if (o == this) {
      return true;
    }
    if (o == null || !(o isinstanceof Pair<A,B>)) {
      return false;
    }
    Pair<A,B> p = (Pair<A,B>)o;
    return
      p.getA().equals(this.getA()) &&
      p.getB().equals(this.getB());
  }
  @Override
  public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((a == null) ? 0 : a.hashCode());
    result = prime * result + ((b == null) ? 0 : b.hashCode());
    return result;
  }
}

class Anticor {

  class Stat {
    Stat(final Vec[] vecs) {
      covMemo = new HashMap<Integer, Double>();
      corMemo = new HashMap<Pair<Integer,Integer>,Double>();
      vecst = transpose(vecs);
    }
    private final Map<Integer, Double> covMemo;
    private final Map<Pair<Integer, Integer>, Double> corMemo;
    private final Vec[] vecst;

    public double cov(int i, int j) {
    }
    public double cor(int i, int j) {
    }
  }

  public static Vec step(
    final int w,
    final Vec[] histPrvs,
    final Vec curPort) {

    final Vec[] lx1 = new Vec[histPrvs.length];
    for (int i = 0; i < histPrvs.length; i++) {
      lx1[i] = histPrvs[i].log();
    }

    final Vec[] lx2 = new Vec[histPrvs.length];
    for (int i = 0; i < histPrvs.length; i++) {
      lx2[i] = histPrvs[i].log();
    }

    final int stockSize = curPort.length();
    final int[][] claim = new int[stockSize][stockSize];

    for (int i = 0; i < stockSize; i++) {
      for (int j = 0; j < stockSize; j++) {
        if (mu.get(i) >= mu.get(j) && MCor(i, j) > 0) {
          claim[i][j] += MCor(i, j) + Math.max(-MCor(i,i),0) + Math.max(-MCor(j,j),0);
        } else if (mu.get(i) >= mu.get(j) && MCor(i, j) <= 0) {
          claim[i][j] += -MCor(i, j) + Math.max(MCor(i,i),0) + Math.max(MCor(j,j),0);
        }
      }
    }

    final double[][] transfer = new double[stockSize][stockSize];
    for (int i = 0; i < stockSize; i++) {
      double denominator = 0.0;
      for (int j = 0; j < stockSize; j++) {
        denominator += claim[i][j];
      }
      for (int j = 0; j < stockSize; j++) {
        transfer[i][j] = curPort.get(i) * claim[i][j] / denominator;
      }
    }

    final double[] nextPort = curPort.toArray();
    for (int i = 0; i < stockSize; i++) {
      double acc = 0.0;
      for (int j = 0; j < stockSize; j++) {
        acc += transfer[i][j];
        acc -= transfer[j][i];
      }
      nextPort[i] += acc;
    }

    return new Vec(nextPort);
  }
}