// ** This class was generated with DemFGen (vers:06/04/2009)

package gen;

import edu.neu.ccs.demeterf.control.Fields;
import edu.neu.ccs.demeterf.demfgen.lib.ident;
import edu.neu.ccs.demeterf.demfgen.lib.verbatim;
import edu.neu.ccs.demeterf.demfgen.lib.*;
import edu.neu.ccs.demeterf.demfgen.lib.*;
import edu.neu.ccs.demeterf.demfgen.lib.*;
import edu.neu.ccs.demeterf.demfgen.lib.*;



/** Creates a Static version of Traversal for a specific CD without a Context */
public class StaticTrav extends edu.neu.ccs.demeterf.Traversal{
   public <_R> _R traversebyte(byte o){ return (_R)applyBuilder(new Object[]{o}, true); }
   public <_R> _R traverseshort(short o){ return (_R)applyBuilder(new Object[]{o}, true); }
   public <_R> _R traverseint(int o){ return (_R)applyBuilder(new Object[]{o}, true); }
   public <_R> _R traverselong(long o){ return (_R)applyBuilder(new Object[]{o}, true); }
   public <_R> _R traversefloat(float o){ return (_R)applyBuilder(new Object[]{o}, true); }
   public <_R> _R traversedouble(double o){ return (_R)applyBuilder(new Object[]{o}, true); }
   public <_R> _R traversechar(char o){ return (_R)applyBuilder(new Object[]{o}, true); }
   public <_R> _R traverseboolean(boolean o){ return (_R)applyBuilder(new Object[]{o}, true); }
   public <_R> _R traverseString(String o){ return (_R)applyBuilder(new Object[]{o}, true); }
   public <_R> _R traverseident(ident o){ return (_R)applyBuilder(new Object[]{o}, true); }
   public <_R> _R traverseverbatim(verbatim o){ return (_R)applyBuilder(new Object[]{o}, true); }


   public StaticTrav(edu.neu.ccs.demeterf.FC f){ super(f); }
   public StaticTrav(edu.neu.ccs.demeterf.FC f, edu.neu.ccs.demeterf.Control c){ super(f,c); }


   public <_R> _R traverseType(Type _h){
      if(control.isBuiltIn(Type.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object kind = (control.skip(Type.class, "kind"))?(_h.kind):this.<Object>traverseKind(_h.kind);
      Object instances = (control.skip(Type.class, "instances"))?(_h.instances):this.<Object>traverseList_TypeInstance_(_h.instances);
      return (_R)applyBuilder(new Object[]{_h, kind, instances}, false);
   }
   public <_R> _R traverseKind(Kind _h){
      if(control.isBuiltIn(Kind.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Classic) return this.<_R>traverseClassic((Classic)_h);
      if(_h instanceof Secret) return this.<_R>traverseSecret((Secret)_h);
      else throw new RuntimeException("Unknown Kind Variant");
   }
   public <_R> _R traverseClassic(Classic _h){
      if(control.isBuiltIn(Classic.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseSecret(Secret _h){
      if(control.isBuiltIn(Secret.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseTypeInstance(TypeInstance _h){
      if(control.isBuiltIn(TypeInstance.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object r = (control.skip(TypeInstance.class, "r"))?(_h.r):this.<Object>traverseRelationNr(_h.r);
      return (_R)applyBuilder(new Object[]{_h, r}, false);
   }
   public <_R> _R traverseSolution(Solution _h){
      if(control.isBuiltIn(Solution.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object assignment = (control.skip(Solution.class, "assignment"))?(_h.assignment):this.<Object>traverseAssignment(_h.assignment);
      return (_R)applyBuilder(new Object[]{_h, assignment}, false);
   }
   public <_R> _R traverseChallengeInstance(ChallengeInstance _h){
      if(control.isBuiltIn(ChallengeInstance.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object cs = (control.skip(ChallengeInstance.class, "cs"))?(_h.cs):this.<Object>traverseList_Constraint_(_h.cs);
      Object secret = (control.skip(ChallengeInstance.class, "secret"))?(_h.secret):this.<Object>traverseOption_SecretOfChallenge_(_h.secret);
      return (_R)applyBuilder(new Object[]{_h, cs, secret}, false);
   }
   public <_R> _R traverseSecretOfChallenge(SecretOfChallenge _h){
      if(control.isBuiltIn(SecretOfChallenge.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object assign = (control.skip(SecretOfChallenge.class, "assign"))?(_h.assign):this.<Object>traverseOption_Assignment_(_h.assign);
      Object quality = (control.skip(SecretOfChallenge.class, "quality"))?(_h.quality):this.<Object>traverseQuality(_h.quality);
      return (_R)applyBuilder(new Object[]{_h, assign, quality}, false);
   }
   public <_R> _R traverseConstraint(Constraint _h){
      if(control.isBuiltIn(Constraint.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object w = (control.skip(Constraint.class, "w"))?(_h.w):this.<Object>traverseWeight(_h.w);
      Object r = (control.skip(Constraint.class, "r"))?(_h.r):this.<Object>traverseRelationNr(_h.r);
      Object vs = (control.skip(Constraint.class, "vs"))?(_h.vs):this.<Object>traverseList_Variable_(_h.vs);
      return (_R)applyBuilder(new Object[]{_h, w, r, vs}, false);
   }
   public <_R> _R traverseWeight(Weight _h){
      if(control.isBuiltIn(Weight.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object v = (control.skip(Weight.class, "v"))?(_h.v):this.<Object>traverseint(_h.v);
      return (_R)applyBuilder(new Object[]{_h, v}, false);
   }
   public <_R> _R traverseRelationNr(RelationNr _h){
      if(control.isBuiltIn(RelationNr.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object v = (control.skip(RelationNr.class, "v"))?(_h.v):this.<Object>traverseint(_h.v);
      return (_R)applyBuilder(new Object[]{_h, v}, false);
   }
   public <_R> _R traverseVariable(Variable _h){
      if(control.isBuiltIn(Variable.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object v = (control.skip(Variable.class, "v"))?(_h.v):this.<Object>traverseident(_h.v);
      return (_R)applyBuilder(new Object[]{_h, v}, false);
   }
   public <_R> _R traversePredicate(Predicate _h){
      if(control.isBuiltIn(Predicate.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object pred = (control.skip(Predicate.class, "pred"))?(_h.pred):this.<Object>traverseList_RelationNr_(_h.pred);
      return (_R)applyBuilder(new Object[]{_h, pred}, false);
   }
   public <_R> _R traverseAssignment(Assignment _h){
      if(control.isBuiltIn(Assignment.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object literals = (control.skip(Assignment.class, "literals"))?(_h.literals):this.<Object>traverseList_Literal_(_h.literals);
      return (_R)applyBuilder(new Object[]{_h, literals}, false);
   }
   public <_R> _R traverseLiteral(Literal _h){
      if(control.isBuiltIn(Literal.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object value = (control.skip(Literal.class, "value"))?(_h.value):this.<Object>traverseSign(_h.value);
      Object var = (control.skip(Literal.class, "var"))?(_h.var):this.<Object>traverseVariable(_h.var);
      return (_R)applyBuilder(new Object[]{_h, value, var}, false);
   }
   public <_R> _R traverseSign(Sign _h){
      if(control.isBuiltIn(Sign.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Neg) return this.<_R>traverseNeg((Neg)_h);
      if(_h instanceof Pos) return this.<_R>traversePos((Pos)_h);
      else throw new RuntimeException("Unknown Sign Variant");
   }
   public <_R> _R traversePos(Pos _h){
      if(control.isBuiltIn(Pos.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseNeg(Neg _h){
      if(control.isBuiltIn(Neg.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traversePrice(Price _h){
      if(control.isBuiltIn(Price.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object val = (control.skip(Price.class, "val"))?(_h.val):this.<Object>traversedouble(_h.val);
      return (_R)applyBuilder(new Object[]{_h, val}, false);
   }
   public <_R> _R traverseQuality(Quality _h){
      if(control.isBuiltIn(Quality.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object val = (control.skip(Quality.class, "val"))?(_h.val):this.<Object>traversedouble(_h.val);
      return (_R)applyBuilder(new Object[]{_h, val}, false);
   }
   public <_R> _R traversePlayerID(PlayerID _h){
      if(control.isBuiltIn(PlayerID.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object id = (control.skip(PlayerID.class, "id"))?(_h.id):this.<Object>traverseint(_h.id);
      return (_R)applyBuilder(new Object[]{_h, id}, false);
   }
   public <_R> _R traversePlayer(Player _h){
      if(control.isBuiltIn(Player.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object id = (control.skip(Player.class, "id"))?(_h.id):this.<Object>traversePlayerID(_h.id);
      Object name = (control.skip(Player.class, "name"))?(_h.name):this.<Object>traverseString(_h.name);
      return (_R)applyBuilder(new Object[]{_h, id, name}, false);
   }
   public <_R> _R traverseChallenge(Challenge _h){
      if(control.isBuiltIn(Challenge.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object name = (control.skip(Challenge.class, "name"))?(_h.name):this.<Object>traverseString(_h.name);
      Object seller = (control.skip(Challenge.class, "seller"))?(_h.seller):this.<Object>traversePlayerID(_h.seller);
      Object optbuyer = (control.skip(Challenge.class, "optbuyer"))?(_h.optbuyer):this.<Object>traverseOption_PlayerID_(_h.optbuyer);
      Object price = (control.skip(Challenge.class, "price"))?(_h.price):this.<Object>traversePrice(_h.price);
      Object type = (control.skip(Challenge.class, "type"))?(_h.type):this.<Object>traverseType(_h.type);
      Object optraw = (control.skip(Challenge.class, "optraw"))?(_h.optraw):this.<Object>traverseOption_ChallengeInstance_(_h.optraw);
      Object optfinished = (control.skip(Challenge.class, "optfinished"))?(_h.optfinished):this.<Object>traverseOption_Solution_(_h.optfinished);
      return (_R)applyBuilder(new Object[]{_h, name, seller, optbuyer, price, type, optraw, optfinished}, false);
   }
   public <_R> _R traverseHistory(History _h){
      if(control.isBuiltIn(History.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object rounds = (control.skip(History.class, "rounds"))?(_h.rounds):this.<Object>traverseList_Round_(_h.rounds);
      return (_R)applyBuilder(new Object[]{_h, rounds}, false);
   }
   public <_R> _R traverseRound(Round _h){
      if(control.isBuiltIn(Round.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object num = (control.skip(Round.class, "num"))?(_h.num):this.<Object>traverseint(_h.num);
      Object ptransactions = (control.skip(Round.class, "ptransactions"))?(_h.ptransactions):this.<Object>traverseList_PlayerTransaction_(_h.ptransactions);
      return (_R)applyBuilder(new Object[]{_h, num, ptransactions}, false);
   }
   public <_R> _R traversePlayerTransaction(PlayerTransaction _h){
      if(control.isBuiltIn(PlayerTransaction.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object player = (control.skip(PlayerTransaction.class, "player"))?(_h.player):this.<Object>traversePlayer(_h.player);
      Object transactions = (control.skip(PlayerTransaction.class, "transactions"))?(_h.transactions):this.<Object>traverseList_Transaction_(_h.transactions);
      return (_R)applyBuilder(new Object[]{_h, player, transactions}, false);
   }
   public <_R> _R traverseTransaction(Transaction _h){
      if(control.isBuiltIn(Transaction.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object ttype = (control.skip(Transaction.class, "ttype"))?(_h.ttype):this.<Object>traverseTransactionType(_h.ttype);
      Object deriv = (control.skip(Transaction.class, "deriv"))?(_h.deriv):this.<Object>traverseChallenge(_h.deriv);
      return (_R)applyBuilder(new Object[]{_h, ttype, deriv}, false);
   }
   public <_R> _R traverseTransactionType(TransactionType _h){
      if(control.isBuiltIn(TransactionType.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Buy) return this.<_R>traverseBuy((Buy)_h);
      if(_h instanceof Create) return this.<_R>traverseCreate((Create)_h);
      if(_h instanceof Reoffer) return this.<_R>traverseReoffer((Reoffer)_h);
      if(_h instanceof Deliver) return this.<_R>traverseDeliver((Deliver)_h);
      if(_h instanceof Finish) return this.<_R>traverseFinish((Finish)_h);
      else throw new RuntimeException("Unknown TransactionType Variant");
   }
   public <_R> _R traverseBuy(Buy _h){
      if(control.isBuiltIn(Buy.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseCreate(Create _h){
      if(control.isBuiltIn(Create.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseReoffer(Reoffer _h){
      if(control.isBuiltIn(Reoffer.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseDeliver(Deliver _h){
      if(control.isBuiltIn(Deliver.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseFinish(Finish _h){
      if(control.isBuiltIn(Finish.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traversePlayers(Players _h){
      if(control.isBuiltIn(Players.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object players = (control.skip(Players.class, "players"))?(_h.players):this.<Object>traverseList_Player_(_h.players);
      return (_R)applyBuilder(new Object[]{_h, players}, false);
   }
   public <_R> _R traverseAccounts(Accounts _h){
      if(control.isBuiltIn(Accounts.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object accounts = (control.skip(Accounts.class, "accounts"))?(_h.accounts):this.<Object>traverseList_Pair_PlayerID_Double__(_h.accounts);
      return (_R)applyBuilder(new Object[]{_h, accounts}, false);
   }
   public <_R> _R traverseStore(Store _h){
      if(control.isBuiltIn(Store.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object stores = (control.skip(Store.class, "stores"))?(_h.stores):this.<Object>traverseList_Pair_PlayerID_PlayerStore__(_h.stores);
      return (_R)applyBuilder(new Object[]{_h, stores}, false);
   }
   public <_R> _R traversePlayerStore(PlayerStore _h){
      if(control.isBuiltIn(PlayerStore.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object forSale = (control.skip(PlayerStore.class, "forSale"))?(_h.forSale):this.<Object>traverseList_Challenge_(_h.forSale);
      Object bought = (control.skip(PlayerStore.class, "bought"))?(_h.bought):this.<Object>traverseList_Challenge_(_h.bought);
      return (_R)applyBuilder(new Object[]{_h, forSale, bought}, false);
   }
   public <_R> _R traverseConfig(Config _h){
      if(control.isBuiltIn(Config.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object Money = (control.skip(Config.class, "Money"))?(_h.Money):this.<Object>traversedouble(_h.Money);
      Object Rounds = (control.skip(Config.class, "Rounds"))?(_h.Rounds):this.<Object>traverseint(_h.Rounds);
      Object Time = (control.skip(Config.class, "Time"))?(_h.Time):this.<Object>traverseint(_h.Time);
      Object MPD = (control.skip(Config.class, "MPD"))?(_h.MPD):this.<Object>traversedouble(_h.MPD);
      Object MaxCreates = (control.skip(Config.class, "MaxCreates"))?(_h.MaxCreates):this.<Object>traverseint(_h.MaxCreates);
      Object MaxRawMaterialLen = (control.skip(Config.class, "MaxRawMaterialLen"))?(_h.MaxRawMaterialLen):this.<Object>traverseint(_h.MaxRawMaterialLen);
      return (_R)applyBuilder(new Object[]{_h, Money, Rounds, Time, MPD, MaxCreates, MaxRawMaterialLen}, false);
   }

   public <_R> _R traverseList_Challenge_(List<Challenge> _h){
      if(control.isBuiltIn(List.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Cons) return this.<_R>traverseCons_Challenge_((Cons<Challenge>)_h);
      if(_h instanceof Empty) return this.<_R>traverseEmpty_Challenge_((Empty<Challenge>)_h);
      else throw new RuntimeException("Unknown List Variant");
   }
   public <_R> _R traverseEmpty_Challenge_(Empty<Challenge> _h){
      if(control.isBuiltIn(Empty.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseCons_Challenge_(Cons<Challenge> _h){
      if(control.isBuiltIn(Cons.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object first = (control.skip(Cons.class, "first"))?(_h.first):this.<Object>traverseChallenge(_h.first);
      Object rest = (control.skip(Cons.class, "rest"))?(_h.rest):this.<Object>traverseList_Challenge_(_h.rest);
      return (_R)applyBuilder(new Object[]{_h, first, rest}, false);
   }
   public <_R> _R traverseList_Pair_PlayerID_PlayerStore__(List<Pair<PlayerID,PlayerStore>> _h){
      if(control.isBuiltIn(List.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Cons) return this.<_R>traverseCons_Pair_PlayerID_PlayerStore__((Cons<Pair<PlayerID,PlayerStore>>)_h);
      if(_h instanceof Empty) return this.<_R>traverseEmpty_Pair_PlayerID_PlayerStore__((Empty<Pair<PlayerID,PlayerStore>>)_h);
      else throw new RuntimeException("Unknown List Variant");
   }
   public <_R> _R traverseEmpty_Pair_PlayerID_PlayerStore__(Empty<Pair<PlayerID,PlayerStore>> _h){
      if(control.isBuiltIn(Empty.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseCons_Pair_PlayerID_PlayerStore__(Cons<Pair<PlayerID,PlayerStore>> _h){
      if(control.isBuiltIn(Cons.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object first = (control.skip(Cons.class, "first"))?(_h.first):this.<Object>traversePair_PlayerID_PlayerStore_(_h.first);
      Object rest = (control.skip(Cons.class, "rest"))?(_h.rest):this.<Object>traverseList_Pair_PlayerID_PlayerStore__(_h.rest);
      return (_R)applyBuilder(new Object[]{_h, first, rest}, false);
   }
   public <_R> _R traversePair_PlayerID_PlayerStore_(Pair<PlayerID,PlayerStore> _h){
      if(control.isBuiltIn(Pair.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object a = (control.skip(Pair.class, "a"))?(_h.a):this.<Object>traversePlayerID(_h.a);
      Object b = (control.skip(Pair.class, "b"))?(_h.b):this.<Object>traversePlayerStore(_h.b);
      return (_R)applyBuilder(new Object[]{_h, a, b}, false);
   }
   public <_R> _R traverseList_Pair_PlayerID_Double__(List<Pair<PlayerID,Double>> _h){
      if(control.isBuiltIn(List.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Cons) return this.<_R>traverseCons_Pair_PlayerID_Double__((Cons<Pair<PlayerID,Double>>)_h);
      if(_h instanceof Empty) return this.<_R>traverseEmpty_Pair_PlayerID_Double__((Empty<Pair<PlayerID,Double>>)_h);
      else throw new RuntimeException("Unknown List Variant");
   }
   public <_R> _R traverseEmpty_Pair_PlayerID_Double__(Empty<Pair<PlayerID,Double>> _h){
      if(control.isBuiltIn(Empty.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseCons_Pair_PlayerID_Double__(Cons<Pair<PlayerID,Double>> _h){
      if(control.isBuiltIn(Cons.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object first = (control.skip(Cons.class, "first"))?(_h.first):this.<Object>traversePair_PlayerID_Double_(_h.first);
      Object rest = (control.skip(Cons.class, "rest"))?(_h.rest):this.<Object>traverseList_Pair_PlayerID_Double__(_h.rest);
      return (_R)applyBuilder(new Object[]{_h, first, rest}, false);
   }
   public <_R> _R traversePair_PlayerID_Double_(Pair<PlayerID,Double> _h){
      if(control.isBuiltIn(Pair.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object a = (control.skip(Pair.class, "a"))?(_h.a):this.<Object>traversePlayerID(_h.a);
      Object b = (control.skip(Pair.class, "b"))?(_h.b):this.<Object>traverseDouble(_h.b);
      return (_R)applyBuilder(new Object[]{_h, a, b}, false);
   }
   public <_R> _R traverseList_Player_(List<Player> _h){
      if(control.isBuiltIn(List.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Cons) return this.<_R>traverseCons_Player_((Cons<Player>)_h);
      if(_h instanceof Empty) return this.<_R>traverseEmpty_Player_((Empty<Player>)_h);
      else throw new RuntimeException("Unknown List Variant");
   }
   public <_R> _R traverseEmpty_Player_(Empty<Player> _h){
      if(control.isBuiltIn(Empty.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseCons_Player_(Cons<Player> _h){
      if(control.isBuiltIn(Cons.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object first = (control.skip(Cons.class, "first"))?(_h.first):this.<Object>traversePlayer(_h.first);
      Object rest = (control.skip(Cons.class, "rest"))?(_h.rest):this.<Object>traverseList_Player_(_h.rest);
      return (_R)applyBuilder(new Object[]{_h, first, rest}, false);
   }
   public <_R> _R traverseList_Transaction_(List<Transaction> _h){
      if(control.isBuiltIn(List.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Cons) return this.<_R>traverseCons_Transaction_((Cons<Transaction>)_h);
      if(_h instanceof Empty) return this.<_R>traverseEmpty_Transaction_((Empty<Transaction>)_h);
      else throw new RuntimeException("Unknown List Variant");
   }
   public <_R> _R traverseEmpty_Transaction_(Empty<Transaction> _h){
      if(control.isBuiltIn(Empty.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseCons_Transaction_(Cons<Transaction> _h){
      if(control.isBuiltIn(Cons.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object first = (control.skip(Cons.class, "first"))?(_h.first):this.<Object>traverseTransaction(_h.first);
      Object rest = (control.skip(Cons.class, "rest"))?(_h.rest):this.<Object>traverseList_Transaction_(_h.rest);
      return (_R)applyBuilder(new Object[]{_h, first, rest}, false);
   }
   public <_R> _R traverseList_PlayerTransaction_(List<PlayerTransaction> _h){
      if(control.isBuiltIn(List.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Cons) return this.<_R>traverseCons_PlayerTransaction_((Cons<PlayerTransaction>)_h);
      if(_h instanceof Empty) return this.<_R>traverseEmpty_PlayerTransaction_((Empty<PlayerTransaction>)_h);
      else throw new RuntimeException("Unknown List Variant");
   }
   public <_R> _R traverseEmpty_PlayerTransaction_(Empty<PlayerTransaction> _h){
      if(control.isBuiltIn(Empty.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseCons_PlayerTransaction_(Cons<PlayerTransaction> _h){
      if(control.isBuiltIn(Cons.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object first = (control.skip(Cons.class, "first"))?(_h.first):this.<Object>traversePlayerTransaction(_h.first);
      Object rest = (control.skip(Cons.class, "rest"))?(_h.rest):this.<Object>traverseList_PlayerTransaction_(_h.rest);
      return (_R)applyBuilder(new Object[]{_h, first, rest}, false);
   }
   public <_R> _R traverseList_Round_(List<Round> _h){
      if(control.isBuiltIn(List.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Cons) return this.<_R>traverseCons_Round_((Cons<Round>)_h);
      if(_h instanceof Empty) return this.<_R>traverseEmpty_Round_((Empty<Round>)_h);
      else throw new RuntimeException("Unknown List Variant");
   }
   public <_R> _R traverseEmpty_Round_(Empty<Round> _h){
      if(control.isBuiltIn(Empty.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseCons_Round_(Cons<Round> _h){
      if(control.isBuiltIn(Cons.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object first = (control.skip(Cons.class, "first"))?(_h.first):this.<Object>traverseRound(_h.first);
      Object rest = (control.skip(Cons.class, "rest"))?(_h.rest):this.<Object>traverseList_Round_(_h.rest);
      return (_R)applyBuilder(new Object[]{_h, first, rest}, false);
   }
   public <_R> _R traverseOption_Solution_(Option<Solution> _h){
      if(control.isBuiltIn(Option.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Some) return this.<_R>traverseSome_Solution_((Some<Solution>)_h);
      if(_h instanceof None) return this.<_R>traverseNone_Solution_((None<Solution>)_h);
      else throw new RuntimeException("Unknown Option Variant");
   }
   public <_R> _R traverseNone_Solution_(None<Solution> _h){
      if(control.isBuiltIn(None.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseSome_Solution_(Some<Solution> _h){
      if(control.isBuiltIn(Some.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object just = (control.skip(Some.class, "just"))?(_h.just):this.<Object>traverseSolution(_h.just);
      return (_R)applyBuilder(new Object[]{_h, just}, false);
   }
   public <_R> _R traverseOption_ChallengeInstance_(Option<ChallengeInstance> _h){
      if(control.isBuiltIn(Option.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Some) return this.<_R>traverseSome_ChallengeInstance_((Some<ChallengeInstance>)_h);
      if(_h instanceof None) return this.<_R>traverseNone_ChallengeInstance_((None<ChallengeInstance>)_h);
      else throw new RuntimeException("Unknown Option Variant");
   }
   public <_R> _R traverseNone_ChallengeInstance_(None<ChallengeInstance> _h){
      if(control.isBuiltIn(None.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseSome_ChallengeInstance_(Some<ChallengeInstance> _h){
      if(control.isBuiltIn(Some.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object just = (control.skip(Some.class, "just"))?(_h.just):this.<Object>traverseChallengeInstance(_h.just);
      return (_R)applyBuilder(new Object[]{_h, just}, false);
   }
   public <_R> _R traverseOption_PlayerID_(Option<PlayerID> _h){
      if(control.isBuiltIn(Option.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Some) return this.<_R>traverseSome_PlayerID_((Some<PlayerID>)_h);
      if(_h instanceof None) return this.<_R>traverseNone_PlayerID_((None<PlayerID>)_h);
      else throw new RuntimeException("Unknown Option Variant");
   }
   public <_R> _R traverseNone_PlayerID_(None<PlayerID> _h){
      if(control.isBuiltIn(None.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseSome_PlayerID_(Some<PlayerID> _h){
      if(control.isBuiltIn(Some.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object just = (control.skip(Some.class, "just"))?(_h.just):this.<Object>traversePlayerID(_h.just);
      return (_R)applyBuilder(new Object[]{_h, just}, false);
   }
   public <_R> _R traverseList_Literal_(List<Literal> _h){
      if(control.isBuiltIn(List.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Cons) return this.<_R>traverseCons_Literal_((Cons<Literal>)_h);
      if(_h instanceof Empty) return this.<_R>traverseEmpty_Literal_((Empty<Literal>)_h);
      else throw new RuntimeException("Unknown List Variant");
   }
   public <_R> _R traverseEmpty_Literal_(Empty<Literal> _h){
      if(control.isBuiltIn(Empty.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseCons_Literal_(Cons<Literal> _h){
      if(control.isBuiltIn(Cons.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object first = (control.skip(Cons.class, "first"))?(_h.first):this.<Object>traverseLiteral(_h.first);
      Object rest = (control.skip(Cons.class, "rest"))?(_h.rest):this.<Object>traverseList_Literal_(_h.rest);
      return (_R)applyBuilder(new Object[]{_h, first, rest}, false);
   }
   public <_R> _R traverseList_RelationNr_(List<RelationNr> _h){
      if(control.isBuiltIn(List.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Cons) return this.<_R>traverseCons_RelationNr_((Cons<RelationNr>)_h);
      if(_h instanceof Empty) return this.<_R>traverseEmpty_RelationNr_((Empty<RelationNr>)_h);
      else throw new RuntimeException("Unknown List Variant");
   }
   public <_R> _R traverseEmpty_RelationNr_(Empty<RelationNr> _h){
      if(control.isBuiltIn(Empty.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseCons_RelationNr_(Cons<RelationNr> _h){
      if(control.isBuiltIn(Cons.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object first = (control.skip(Cons.class, "first"))?(_h.first):this.<Object>traverseRelationNr(_h.first);
      Object rest = (control.skip(Cons.class, "rest"))?(_h.rest):this.<Object>traverseList_RelationNr_(_h.rest);
      return (_R)applyBuilder(new Object[]{_h, first, rest}, false);
   }
   public <_R> _R traverseList_Variable_(List<Variable> _h){
      if(control.isBuiltIn(List.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Cons) return this.<_R>traverseCons_Variable_((Cons<Variable>)_h);
      if(_h instanceof Empty) return this.<_R>traverseEmpty_Variable_((Empty<Variable>)_h);
      else throw new RuntimeException("Unknown List Variant");
   }
   public <_R> _R traverseEmpty_Variable_(Empty<Variable> _h){
      if(control.isBuiltIn(Empty.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseCons_Variable_(Cons<Variable> _h){
      if(control.isBuiltIn(Cons.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object first = (control.skip(Cons.class, "first"))?(_h.first):this.<Object>traverseVariable(_h.first);
      Object rest = (control.skip(Cons.class, "rest"))?(_h.rest):this.<Object>traverseList_Variable_(_h.rest);
      return (_R)applyBuilder(new Object[]{_h, first, rest}, false);
   }
   public <_R> _R traverseOption_Assignment_(Option<Assignment> _h){
      if(control.isBuiltIn(Option.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Some) return this.<_R>traverseSome_Assignment_((Some<Assignment>)_h);
      if(_h instanceof None) return this.<_R>traverseNone_Assignment_((None<Assignment>)_h);
      else throw new RuntimeException("Unknown Option Variant");
   }
   public <_R> _R traverseNone_Assignment_(None<Assignment> _h){
      if(control.isBuiltIn(None.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseSome_Assignment_(Some<Assignment> _h){
      if(control.isBuiltIn(Some.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object just = (control.skip(Some.class, "just"))?(_h.just):this.<Object>traverseAssignment(_h.just);
      return (_R)applyBuilder(new Object[]{_h, just}, false);
   }
   public <_R> _R traverseOption_SecretOfChallenge_(Option<SecretOfChallenge> _h){
      if(control.isBuiltIn(Option.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Some) return this.<_R>traverseSome_SecretOfChallenge_((Some<SecretOfChallenge>)_h);
      if(_h instanceof None) return this.<_R>traverseNone_SecretOfChallenge_((None<SecretOfChallenge>)_h);
      else throw new RuntimeException("Unknown Option Variant");
   }
   public <_R> _R traverseNone_SecretOfChallenge_(None<SecretOfChallenge> _h){
      if(control.isBuiltIn(None.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseSome_SecretOfChallenge_(Some<SecretOfChallenge> _h){
      if(control.isBuiltIn(Some.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object just = (control.skip(Some.class, "just"))?(_h.just):this.<Object>traverseSecretOfChallenge(_h.just);
      return (_R)applyBuilder(new Object[]{_h, just}, false);
   }
   public <_R> _R traverseList_Constraint_(List<Constraint> _h){
      if(control.isBuiltIn(List.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Cons) return this.<_R>traverseCons_Constraint_((Cons<Constraint>)_h);
      if(_h instanceof Empty) return this.<_R>traverseEmpty_Constraint_((Empty<Constraint>)_h);
      else throw new RuntimeException("Unknown List Variant");
   }
   public <_R> _R traverseEmpty_Constraint_(Empty<Constraint> _h){
      if(control.isBuiltIn(Empty.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseCons_Constraint_(Cons<Constraint> _h){
      if(control.isBuiltIn(Cons.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object first = (control.skip(Cons.class, "first"))?(_h.first):this.<Object>traverseConstraint(_h.first);
      Object rest = (control.skip(Cons.class, "rest"))?(_h.rest):this.<Object>traverseList_Constraint_(_h.rest);
      return (_R)applyBuilder(new Object[]{_h, first, rest}, false);
   }
   public <_R> _R traverseList_TypeInstance_(List<TypeInstance> _h){
      if(control.isBuiltIn(List.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      if(_h instanceof Cons) return this.<_R>traverseCons_TypeInstance_((Cons<TypeInstance>)_h);
      if(_h instanceof Empty) return this.<_R>traverseEmpty_TypeInstance_((Empty<TypeInstance>)_h);
      else throw new RuntimeException("Unknown List Variant");
   }
   public <_R> _R traverseEmpty_TypeInstance_(Empty<TypeInstance> _h){
      if(control.isBuiltIn(Empty.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      return (_R)applyBuilder(new Object[]{_h}, false);
   }
   public <_R> _R traverseCons_TypeInstance_(Cons<TypeInstance> _h){
      if(control.isBuiltIn(Cons.class))
          return (_R)applyBuilder(new Object[]{_h}, true);
      Object first = (control.skip(Cons.class, "first"))?(_h.first):this.<Object>traverseTypeInstance(_h.first);
      Object rest = (control.skip(Cons.class, "rest"))?(_h.rest):this.<Object>traverseList_TypeInstance_(_h.rest);
      return (_R)applyBuilder(new Object[]{_h, first, rest}, false);
   }
}