anchor.diff:      
       return pods;
   }
  +
  +List<Pod> swapPods(List<Pod> startPods){
  +    List<Pod> pods = [];
  +    pods.add(startPods[2]);
  +    pods.add(startPods[3]);
  +    pods.add(startPods[0]);
  +    pods.add(startPods[1]);
  +    return pods;
  +}
  +
  +Solution crossover(Solution mother, Solution father){
  +    List<Move> moves0 = [];
  +    List<Move> moves1 = [];    
  +    for(int i = 0; i < mother.moves0.length; i++){
  +        if(rand.nextDouble() < .5){
  +            moves0.add(mother.moves0[i]);
  +        } else {
  +            moves0.add(father.moves0[i]);
  +        }
  +        if(rand.nextDouble() < .5){
  +            moves1.add(mother.moves1[i]);
  +        } else {
  +            moves1.add(father.moves1[i]);
  +        }
  +    }
  +    
  +    //assume that enemy moves are the same in both parents
  +    return new Solution(moves0, moves1, 
  +        mother.moves2,
  +        mother.moves3);
  +}
  
positive.code:     return bestSolution;
  }
  
  Solution genetic(List<Pod> startPods, int length, int timeout, Solution lastSolution){
      int poolSize = 10;
      
      Stopwatch sw = new Stopwatch();
      sw.start();
      Solution naive = naiveSolution(startPods, length);
      
      Map<num, Solution> pool = new SplayTreeMap();
      num naiveEval = naive.score(startPods);
      pool[naiveEval] = naive;
      stderr.writeln("Created naive $naiveEval ${sw.elapsedMilliseconds}");
      
      
      for(int i = 0; i < poolSize; i++){
          Solution randomSolution = new Solution(
              new List.generate(length, (index) => randomMove()),
              new List.generate(length, (index) => randomMove()),
              naive.moves2,
              naive.moves3);
          num randomEval = randomSolution.score(startPods);
          //stderr.writeln("${pool.length} $poolSize Random eval $randomEval");
          pool[randomEval] = randomSolution;
      }
      
      stderr.writeln("Filled pool ${pool.length} ${sw.elapsedMilliseconds}");
      stderr.writeln("Pool first ${pool.keys.first} last ${pool.keys.last}");
      
      while(sw.elapsedMilliseconds < timeout){
          // stderr.writeln("Creating GAs ${sw.elapsedMilliseconds}");
          //TODO generate new solution with mutation and crossover
              
          Solution mutatedSolution = pool[pool.keys.toList()[rand.nextInt(pool.length)]].clone();
          mutatedSolution.mutate();
          
          num geneticEval = mutatedSolution.score(startPods);
          if( geneticEval > pool.keys.first && !pool.containsKey(geneticEval)){
  
negative.code:         // You have to output the target position
          // followed by the power (0 <= thrust <= 100)
          // i.e.: "x y thrust"
          
          if(turn == 0 && pods[0].distance2(checkpoints[1]) > 4000 * 4000){
              print("${checkpoints[1].x} ${checkpoints[1].y} BOOST");
              print("${checkpoints[1].x} ${checkpoints[1].y} BOOST");
              
          } else {
              
              int solLength = 6;
              
              //monte carlo the enemy players for a bit
              List<Pod> enemiesFirst = [pods[2], pods[3], pods[0], pods[1]];
              Solution enemySol = genetic(enemiesFirst, solLength, 15, null, null);
              
  
              Solution gen = genetic(pods, solLength, 95, lastSolution, enemySol);
              lastSolution = gen;
              
              // stderr.writeln("Genetic eval: ${gen.score(pods)}");
              
              pods[0].output(gen.moves0[0]);
              pods[1].output(gen.moves1[0]);
          }
          
          [0, 1, 2, 3].forEach((index) {
              pods[index].timeout -= 1;
  