// ===========================================================================
// This file has been generated by
// xtc Factory Factory, version 1.14.3,
// (C) 2004-2009 Robert Grimm,
// on Sunday, September 27, 2009 at 6:57:48 PM.
// Edit at your own risk.
// ===========================================================================

package xtc.typical;

import java.util.List;

import xtc.tree.Node;
import xtc.tree.GNode;

/**
 * Node factory <code>xtc.typical.TreeFactory</code>.
 *
 * <p />This class has been generated by
 * the xtc Factory Factory, version 1.14.3,
 * (C) 2004-2009 Robert Grimm.
 */
public class TreeFactory {

  /** Create a new node factory. */
  public TreeFactory() {
    // Nothing to do.
  }

  /**
   * Create a call expression.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node addInt(Node argument1, Node argument2) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "addInt");
    Node v$3 = GNode.create("Arguments", argument1, argument2);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create a call expression.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node addFloat64(Node argument1, Node argument2) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "addFloat64");
    Node v$3 = GNode.create("Arguments", argument1, argument2);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create an expression statement.
   *
   * @param arg The arg.
   * @return The generic node.
   */
  public Node addScopeNode(Node arg) {
    Node v$1 = GNode.create("PrimaryIdentifier", "processScopeNodes");
    Node v$2 = GNode.create("Arguments", arg);
    Node v$3 = GNode.create("CallExpression", v$1, null, "add", v$2);
    Node v$4 = GNode.create("ExpressionStatement", v$3);
    return v$4;
  }

  /**
   * Create a new class expression.
   *
   * @param statement The statement.
   * @return The generic node.
   */
  public Node ancestorExpression(Node statement) {
    Node v$1 = GNode.create("QualifiedIdentifier", "Analyzer", "NodeMatch");
    Node v$2 = GNode.create("Arguments", false);
    Node v$3 = GNode.create("Modifier", "public");
    Node v$4 = GNode.create("Modifiers", v$3);
    Node v$5 = GNode.create("QualifiedIdentifier", "Boolean");
    Node v$6 = GNode.create("Type", v$5, null);
    Node v$7 = GNode.create("Modifiers", false);
    Node v$8 = GNode.create("QualifiedIdentifier", "Node");
    Node v$9 = GNode.create("Type", v$8, null);
    Node v$10 = GNode.create("FormalParameter", v$7, v$9, null, "m", null);
    Node v$11 = GNode.create("FormalParameters", v$10);
    Node v$12 = GNode.create("Block", statement);
    Node v$13 = GNode.create("MethodDeclaration", v$4, null, v$6, "apply", 
      v$11, null, null, v$12);
    Node v$14 = GNode.create("ClassBody", v$13);
    Node v$15 = GNode.create("NewClassExpression", null, null, v$1, v$2, 
      v$14);
    return v$15;
  }

  /**
   * Create a call expression.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node and(Node argument1, Node argument2) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "and");
    Node v$3 = GNode.create("Arguments", argument1, argument2);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create a conditional statement.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node annotateType(Node argument1, Node argument2) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", v$1, "!=", argument1);
    Node v$3 = GNode.create("StringLiteral", "\"__type\"");
    Node v$4 = GNode.create("Arguments", v$3, argument2);
    Node v$5 = GNode.create("CallExpression", argument1, null, "setProperty", 
      v$4);
    Node v$6 = GNode.create("ExpressionStatement", v$5);
    Node v$7 = GNode.create("Block", v$6);
    Node v$8 = GNode.create("ConditionalStatement", v$2, v$7, null);
    return v$8;
  }

  /**
   * Create a call expression.
   *
   * @param name The name.
   * @param argument The argument.
   * @return The generic node.
   */
  public Node appendPair(Node name, Node argument) {
    Node v$1 = GNode.create("Arguments", argument);
    Node v$2 = GNode.create("CallExpression", name, null, "append", v$1);
    return v$2;
  }

  /**
   * Create a call expression.
   *
   * @param first The first.
   * @param second The second.
   * @return The generic node.
   */
  public Node appendWrapper(Node first, Node second) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("Arguments", first, second);
    Node v$3 = GNode.create("CallExpression", v$1, null, "wrapAppend", v$2);
    return v$3;
  }

  /**
   * Create a call expression.
   *
   * @param name The name.
   * @param arguments The arguments.
   * @return The generic node.
   */
  public Node apply(Node name, List<Node> arguments) {
    Node v$1 = GNode.create("Arguments", arguments.size()).
      addAll(arguments);
    Node v$2 = GNode.create("CallExpression", name, null, "apply", v$1);
    return v$2;
  }

  /**
   * Create a call expression.
   *
   * @param name The name.
   * @return The generic node.
   */
  public Node apply2(Node name) {
    Node v$1 = GNode.create("Arguments", false);
    Node v$2 = GNode.create("CallExpression", name, null, "apply", v$1);
    return v$2;
  }

  /**
   * Create a call expression.
   *
   * @param name The name.
   * @param arguments The arguments.
   * @return The generic node.
   */
  public Node applyPrimitive(String name, List<Node> arguments) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, name);
    Node v$3 = GNode.create("Arguments", arguments.size()).
      addAll(arguments);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create an expression statement.
   *
   * @param name The name.
   * @param value The value.
   * @return The generic node.
   */
  public Node assign(Node name, Node value) {
    Node v$1 = GNode.create("Expression", name, "=", value);
    Node v$2 = GNode.create("ExpressionStatement", v$1);
    return v$2;
  }

  /**
   * Create an expression statement.
   *
   * @param name The name.
   * @param expression The expression.
   * @return The generic node.
   */
  public Node assignField(Node name, Node expression) {
    Node v$1 = GNode.create("Arguments", expression);
    Node v$2 = GNode.create("CallExpression", null, null, "cast", v$1);
    Node v$3 = GNode.create("Expression", name, "=", v$2);
    Node v$4 = GNode.create("ExpressionStatement", v$3);
    return v$4;
  }

  /**
   * Create a field declaration.
   *
   * @param name The name.
   * @param value The value.
   * @return The generic node.
   */
  public Node boolVar(String name, Node value) {
    Node v$1 = GNode.create("Modifier", "final");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("QualifiedIdentifier", "Boolean");
    Node v$4 = GNode.create("Type", v$3, null);
    Node v$5 = GNode.create("Declarator", name, null, value);
    Node v$6 = GNode.create("Declarators", v$5);
    Node v$7 = GNode.create("FieldDeclaration", v$2, v$4, v$6);
    return v$7;
  }

  /**
   * Create a block.
   *
   * @param statments The statments.
   * @return The generic node.
   */
  public Node block(List<Node> statments) {
    Node v$1 = GNode.create("Block", statments.size()).
      addAll(statments);
    return v$1;
  }

  /**
   * Create a break statement.
   *
   * @return The generic node.
   */
  public Node breakStmnt() {
    Node v$1 = GNode.create("BreakStatement", null);
    return v$1;
  }

  /**
   * Create a call expression.
   *
   * @param expression The expression.
   * @return The generic node.
   */
  public Node cast(Node expression) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Analyzer");
    Node v$2 = GNode.create("Arguments", expression);
    Node v$3 = GNode.create("CallExpression", v$1, null, "cast", v$2);
    return v$3;
  }

  /**
   * Create a call expression.
   *
   * @param name The name.
   * @param function The function.
   * @param arguments The arguments.
   * @return The generic node.
   */
  public Node castInvocation(Node name, String function, List<Node> arguments) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Analyzer");
    Node v$2 = GNode.create("Arguments", arguments.size()).
      addAll(arguments);
    Node v$3 = GNode.create("CallExpression", name, null, function, v$2);
    Node v$4 = GNode.create("Arguments", v$3);
    Node v$5 = GNode.create("CallExpression", v$1, null, "cast", v$4);
    return v$5;
  }

  /**
   * Create a return statement.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node castReturn(Node argument) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Analyzer");
    Node v$2 = GNode.create("Arguments", argument);
    Node v$3 = GNode.create("CallExpression", v$1, null, "cast", v$2);
    Node v$4 = GNode.create("ReturnStatement", v$3);
    return v$4;
  }

  /**
   * Create an expression statement.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node checkEnterScope(Node argument) {
    Node v$1 = GNode.create("Arguments", argument);
    Node v$2 = GNode.create("CallExpression", null, null, "checkEnterScope", 
      v$1);
    Node v$3 = GNode.create("ExpressionStatement", v$2);
    return v$3;
  }

  /**
   * Create an expression statement.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node checkExitScope(Node argument) {
    Node v$1 = GNode.create("Arguments", argument);
    Node v$2 = GNode.create("CallExpression", null, null, "checkExitScope", 
      v$1);
    Node v$3 = GNode.create("ExpressionStatement", v$2);
    return v$3;
  }

  /**
   * Create a class declaration.
   *
   * @param name The name.
   * @return The generic node.
   */
  public Node classDecl2(String name) {
    Node v$1 = GNode.create("Modifier", "public");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("ClassBody", false);
    Node v$4 = GNode.create("ClassDeclaration", v$2, name, null, null, null, 
      v$3);
    return v$4;
  }

  /**
   * Create a class declaration.
   *
   * @param name The name.
   * @return The generic node.
   */
  public Node classDecl3(String name) {
    Node v$1 = GNode.create("Modifier", "protected");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("ClassBody", false);
    Node v$4 = GNode.create("ClassDeclaration", v$2, name, null, null, null, 
      v$3);
    return v$4;
  }

  /**
   * Create an expression statement.
   *
   * @return The generic node.
   */
  public Node compareTypes() {
    Node v$1 = GNode.create("PrimaryIdentifier", "res");
    Node v$2 = GNode.create("PrimaryIdentifier", "res");
    Node v$3 = GNode.create("PrimaryIdentifier", "type");
    Node v$4 = GNode.create("PrimaryIdentifier", "other");
    Node v$5 = GNode.create("SelectionExpression", v$4, "type");
    Node v$6 = GNode.create("Arguments", v$5);
    Node v$7 = GNode.create("CallExpression", v$3, null, "equals", v$6);
    Node v$8 = GNode.create("LogicalAndExpression", v$2, v$7);
    Node v$9 = GNode.create("Expression", v$1, "=", v$8);
    Node v$10 = GNode.create("ExpressionStatement", v$9);
    return v$10;
  }

  /**
   * Create an expression statement.
   *
   * @param arg The arg.
   * @return The generic node.
   */
  public Node compareAttributes(Object arg) {
    Node v$1 = GNode.create("PrimaryIdentifier", "res");
    Node v$2 = GNode.create("PrimaryIdentifier", "res");
    Node v$3 = GNode.create("PrimaryIdentifier", "other");
    Node v$4 = GNode.create("SelectionExpression", v$3, arg);
    Node v$5 = GNode.create("Arguments", v$4);
    Node v$6 = GNode.create("CallExpression", arg, null, "equals", v$5);
    Node v$7 = GNode.create("LogicalAndExpression", v$2, v$6);
    Node v$8 = GNode.create("Expression", v$1, "=", v$7);
    Node v$9 = GNode.create("ExpressionStatement", v$8);
    return v$9;
  }

  /**
   * Create an expression statement.
   *
   * @param arg The arg.
   * @return The generic node.
   */
  public Node compareMembers(String arg) {
    Node v$1 = GNode.create("PrimaryIdentifier", "res");
    Node v$2 = GNode.create("PrimaryIdentifier", "res");
    Node v$3 = GNode.create("PrimaryIdentifier", "Analyzer");
    Node v$4 = GNode.create("ThisExpression", null);
    Node v$5 = GNode.create("SelectionExpression", v$4, arg);
    Node v$6 = GNode.create("PrimaryIdentifier", "other");
    Node v$7 = GNode.create("SelectionExpression", v$6, arg);
    Node v$8 = GNode.create("Arguments", v$5, v$7);
    Node v$9 = GNode.create("CallExpression", v$3, null, "equal", v$8);
    Node v$10 = GNode.create("LogicalAndExpression", v$2, v$9);
    Node v$11 = GNode.create("Expression", v$1, "=", v$10);
    Node v$12 = GNode.create("ExpressionStatement", v$11);
    return v$12;
  }

  /**
   * Create a call expression.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node concatStrings(Node argument1, Node argument2) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "concat");
    Node v$3 = GNode.create("Arguments", argument1, argument2);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create a call expression.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node concatLists(Node argument1, Node argument2) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "concatList");
    Node v$3 = GNode.create("Arguments", argument1, argument2);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create a call expression.
   *
   * @param head The head.
   * @param tail The tail.
   * @return The generic node.
   */
  public Node consWrapper(Node head, Node tail) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("Arguments", head, tail);
    Node v$3 = GNode.create("CallExpression", v$1, null, "wrapCons", v$2);
    return v$3;
  }

  /**
   * Create a constructor declaration.
   *
   * @param name The name.
   * @return The generic node.
   */
  public Node makeConstructor(String name) {
    Node v$1 = GNode.create("Modifier", "public");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("Modifiers", false);
    Node v$4 = GNode.create("QualifiedIdentifier", "Runtime");
    Node v$5 = GNode.create("Type", v$4, null);
    Node v$6 = GNode.create("FormalParameter", v$3, v$5, null, "runt", null);
    Node v$7 = GNode.create("Modifiers", false);
    Node v$8 = GNode.create("QualifiedIdentifier", "String");
    Node v$9 = GNode.create("Type", v$8, null);
    Node v$10 = GNode.create("FormalParameter", v$7, v$9, null, "nodeType", 
      null);
    Node v$11 = GNode.create("FormalParameters", v$6, v$10);
    Node v$12 = GNode.create("PrimaryIdentifier", "runt");
    Node v$13 = GNode.create("Arguments", v$12);
    Node v$14 = GNode.create("CallExpression", null, null, "super", v$13);
    Node v$15 = GNode.create("ExpressionStatement", v$14);
    Node v$16 = GNode.create("PrimaryIdentifier", "analyzer");
    Node v$17 = GNode.create("PrimaryIdentifier", "analyze");
    Node v$18 = GNode.create("Expression", v$16, "=", v$17);
    Node v$19 = GNode.create("ExpressionStatement", v$18);
    Node v$20 = GNode.create("ThisExpression", null);
    Node v$21 = GNode.create("SelectionExpression", v$20, "nodeType");
    Node v$22 = GNode.create("PrimaryIdentifier", "nodeType");
    Node v$23 = GNode.create("Expression", v$21, "=", v$22);
    Node v$24 = GNode.create("ExpressionStatement", v$23);
    Node v$25 = GNode.create("Block", v$15, v$19, v$24);
    Node v$26 = GNode.create("ConstructorDeclaration", v$2, null, name, v$11, 
      null, v$25);
    return v$26;
  }

  /**
   * Create a constructor declaration.
   *
   * @param name The name.
   * @return The generic node.
   */
  public Node makeConstructor2(String name) {
    Node v$1 = GNode.create("Modifier", "public");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("Modifiers", false);
    Node v$4 = GNode.create("QualifiedIdentifier", "Runtime");
    Node v$5 = GNode.create("Type", v$4, null);
    Node v$6 = GNode.create("FormalParameter", v$3, v$5, null, "runt", null);
    Node v$7 = GNode.create("FormalParameters", v$6);
    Node v$8 = GNode.create("PrimaryIdentifier", "runt");
    Node v$9 = GNode.create("Arguments", v$8);
    Node v$10 = GNode.create("CallExpression", null, null, "super", v$9);
    Node v$11 = GNode.create("ExpressionStatement", v$10);
    Node v$12 = GNode.create("PrimaryIdentifier", "analyzer");
    Node v$13 = GNode.create("PrimaryIdentifier", "analyze");
    Node v$14 = GNode.create("Expression", v$12, "=", v$13);
    Node v$15 = GNode.create("ExpressionStatement", v$14);
    Node v$16 = GNode.create("Block", v$11, v$15);
    Node v$17 = GNode.create("ConstructorDeclaration", v$2, null, name, v$7, 
      null, v$16);
    return v$17;
  }

  /**
   * Create a call expression.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node modInt(Node argument1, Node argument2) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "modInt");
    Node v$3 = GNode.create("Arguments", argument1, argument2);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create a constructor declaration.
   *
   * @param name The name.
   * @return The generic node.
   */
  public Node typesConstr(String name) {
    Node v$1 = GNode.create("Modifier", "private");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("FormalParameters", false);
    Node v$4 = GNode.create("Block", false);
    Node v$5 = GNode.create("ConstructorDeclaration", v$2, null, name, v$3, 
      null, v$4);
    return v$5;
  }

  /**
   * Create a call expression.
   *
   * @param literal The literal.
   * @return The generic node.
   */
  public Node createInteger(Node literal) {
    Node v$1 = GNode.create("PrimaryIdentifier", "BigInteger");
    Node v$2 = GNode.create("Arguments", literal);
    Node v$3 = GNode.create("CallExpression", v$1, null, "valueOf", v$2);
    return v$3;
  }

  /**
   * Create a new class expression.
   *
   * @param text The text.
   * @return The generic node.
   */
  public Node createFloat(Node text) {
    Node v$1 = GNode.create("QualifiedIdentifier", "Double");
    Node v$2 = GNode.create("Arguments", text);
    Node v$3 = GNode.create("NewClassExpression", null, null, v$1, v$2, null);
    return v$3;
  }

  /**
   * Create a new class expression.
   *
   * @param arg1 The arg1.
   * @param arg2 The arg2.
   * @return The generic node.
   */
  public Node curryingPut(Object arg1, Node arg2) {
    Node v$1 = GNode.create("TypeInstantiation", "Function", null);
    Node v$2 = GNode.create("QualifiedIdentifier", "Void");
    Node v$3 = GNode.create("Type", v$2, null);
    Node v$4 = GNode.create("QualifiedIdentifier", "Object");
    Node v$5 = GNode.create("Type", v$4, null);
    Node v$6 = GNode.create("QualifiedIdentifier", "Object");
    Node v$7 = GNode.create("Type", v$6, null);
    Node v$8 = GNode.create("QualifiedIdentifier", "Object");
    Node v$9 = GNode.create("Type", v$8, null);
    Node v$10 = GNode.create("TypeArguments", v$7, v$9);
    Node v$11 = GNode.create("TypeInstantiation", "Hashtable", v$10);
    Node v$12 = GNode.create("InstantiatedType", v$11);
    Node v$13 = GNode.create("Type", v$12, null);
    Node v$14 = GNode.create("TypeArguments", v$3, v$5, v$13);
    Node v$15 = GNode.create("TypeInstantiation", "F2", v$14);
    Node v$16 = GNode.create("InstantiatedType", v$1, v$15);
    Node v$17 = GNode.create("Arguments", false);
    Node v$18 = GNode.create("Modifier", "public");
    Node v$19 = GNode.create("Modifiers", v$18);
    Node v$20 = GNode.create("QualifiedIdentifier", "Void");
    Node v$21 = GNode.create("Type", v$20, null);
    Node v$22 = GNode.create("Modifiers", false);
    Node v$23 = GNode.create("QualifiedIdentifier", "Object");
    Node v$24 = GNode.create("Type", v$23, null);
    Node v$25 = GNode.create("FormalParameter", v$22, v$24, null, "o", null);
    Node v$26 = GNode.create("Modifiers", false);
    Node v$27 = GNode.create("QualifiedIdentifier", "Hashtable");
    Node v$28 = GNode.create("Type", v$27, null);
    Node v$29 = GNode.create("FormalParameter", v$26, v$28, null, "table", 
      null);
    Node v$30 = GNode.create("FormalParameters", v$25, v$29);
    Node v$31 = GNode.create("Modifier", "final");
    Node v$32 = GNode.create("Modifiers", v$31);
    Node v$33 = GNode.create("QualifiedIdentifier", "Object");
    Node v$34 = GNode.create("Type", v$33, null);
    Node v$35 = GNode.create("Declarator", arg1, null, arg2);
    Node v$36 = GNode.create("Declarators", v$35);
    Node v$37 = GNode.create("FieldDeclaration", v$32, v$34, v$36);
    Node v$38 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$39 = GNode.create("PrimaryIdentifier", "o");
    Node v$40 = GNode.create("PrimaryIdentifier", "table");
    Node v$41 = GNode.create("Arguments", arg1, v$39, v$40);
    Node v$42 = GNode.create("CallExpression", v$38, null, "put", v$41);
    Node v$43 = GNode.create("ReturnStatement", v$42);
    Node v$44 = GNode.create("Block", v$37, v$43);
    Node v$45 = GNode.create("MethodDeclaration", v$19, null, v$21, "apply", 
      v$30, null, null, v$44);
    Node v$46 = GNode.create("ClassBody", v$45);
    Node v$47 = GNode.create("NewClassExpression", null, null, v$16, v$17, 
      v$46);
    return v$47;
  }

  /**
   * Create a constructor declaration.
   *
   * @param name The name.
   * @return The generic node.
   */
  public Node defaultConstr(String name) {
    Node v$1 = GNode.create("Modifier", "protected");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("FormalParameters", false);
    Node v$4 = GNode.create("Block", false);
    Node v$5 = GNode.create("ConstructorDeclaration", v$2, null, name, v$3, 
      null, v$4);
    return v$5;
  }

  /**
   * Create an expression statement.
   *
   * @param expression The expression.
   * @return The generic node.
   */
  public Node discard(Node expression) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Analyzer");
    Node v$2 = GNode.create("Arguments", expression);
    Node v$3 = GNode.create("CallExpression", v$1, null, "discard", v$2);
    Node v$4 = GNode.create("ExpressionStatement", v$3);
    return v$4;
  }

  /**
   * Create a call expression.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node divideInt(Node argument1, Node argument2) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "divideInt");
    Node v$3 = GNode.create("Arguments", argument1, argument2);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create a call expression.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node divideFloat64(Node argument1, Node argument2) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "divideFloat64");
    Node v$3 = GNode.create("Arguments", argument1, argument2);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create a call expression.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node equal(Node argument1, Node argument2) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "equal");
    Node v$3 = GNode.create("Arguments", argument1, argument2);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create an equality expression.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node equality(Node argument1, Node argument2) {
    Node v$1 = GNode.create("EqualityExpression", argument1, "==", argument2);
    return v$1;
  }

  /**
   * Create a method declaration.
   *
   * @return The generic node.
   */
  public Node equalsMethod() {
    Node v$1 = GNode.create("Modifier", "public");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("PrimitiveType", "boolean");
    Node v$4 = GNode.create("Type", v$3, null);
    Node v$5 = GNode.create("Modifiers", false);
    Node v$6 = GNode.create("QualifiedIdentifier", "Object");
    Node v$7 = GNode.create("Type", v$6, null);
    Node v$8 = GNode.create("FormalParameter", v$5, v$7, null, "o", null);
    Node v$9 = GNode.create("FormalParameters", v$8);
    Node v$10 = GNode.create("Block", false);
    Node v$11 = GNode.create("MethodDeclaration", v$2, null, v$4, "equals", 
      v$9, null, null, v$10);
    return v$11;
  }

  /**
   * Create an equality expression.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node equalsBottom(Node argument) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", v$1, "==", argument);
    return v$2;
  }

  /**
   * Create a call expression.
   *
   * @param name The name.
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node errorClause(String name, Node argument1, Node argument2) {
    Node v$1 = GNode.create("Arguments", argument1, argument2);
    Node v$2 = GNode.create("CallExpression", null, null, name, v$1);
    return v$2;
  }

  /**
   * Create an expression statement.
   *
   * @param expr The expr.
   * @return The generic node.
   */
  public Node expressionStmnt(Node expr) {
    Node v$1 = GNode.create("ExpressionStatement", expr);
    return v$1;
  }

  /**
   * Create a class declaration.
   *
   * @return The generic node.
   */
  public Node extendsDecl() {
    Node v$1 = GNode.create("Modifier", "public");
    Node v$2 = GNode.create("Modifier", "static");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("QualifiedIdentifier", "Type");
    Node v$5 = GNode.create("Type", v$4, null);
    Node v$6 = GNode.create("Extension", v$5);
    Node v$7 = GNode.create("ClassBody", false);
    Node v$8 = GNode.create("ClassDeclaration", v$3, "Name", null, v$6, null, 
      v$7);
    return v$8;
  }

  /**
   * Create a class declaration.
   *
   * @return The generic node.
   */
  public Node extendsDecl2() {
    Node v$1 = GNode.create("Modifier", "public");
    Node v$2 = GNode.create("Modifier", "static");
    Node v$3 = GNode.create("Modifier", "abstract");
    Node v$4 = GNode.create("Modifiers", v$1, v$2, v$3);
    Node v$5 = GNode.create("QualifiedIdentifier", "Type");
    Node v$6 = GNode.create("Type", v$5, null);
    Node v$7 = GNode.create("Extension", v$6);
    Node v$8 = GNode.create("ClassBody", false);
    Node v$9 = GNode.create("ClassDeclaration", v$4, "Name", null, v$7, null, 
      v$8);
    return v$9;
  }

  /**
   * Create a field declaration.
   *
   * @param type The type.
   * @param value The value.
   * @return The generic node.
   */
  public Node fieldDecl(Node type, Node value) {
    Node v$1 = GNode.create("Modifier", "final");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("Type", type, null);
    Node v$4 = GNode.create("Declarator", "name", null, value);
    Node v$5 = GNode.create("Declarators", v$4);
    Node v$6 = GNode.create("FieldDeclaration", v$2, v$3, v$5);
    return v$6;
  }

  /**
   * Create a field declaration.
   *
   * @param type The type.
   * @param value The value.
   * @return The generic node.
   */
  public Node fieldDecl1(Node type, Node value) {
    Node v$1 = GNode.create("Modifiers", false);
    Node v$2 = GNode.create("Type", type, null);
    Node v$3 = GNode.create("Declarator", "name", null, value);
    Node v$4 = GNode.create("Declarators", v$3);
    Node v$5 = GNode.create("FieldDeclaration", v$1, v$2, v$4);
    return v$5;
  }

  /**
   * Create a field declaration.
   *
   * @param type The type.
   * @param name The name.
   * @param value The value.
   * @return The generic node.
   */
  public Node fieldDecl2(Node type, String name, Node value) {
    Node v$1 = GNode.create("Modifier", "final");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("Type", type, null);
    Node v$4 = GNode.create("Declarator", name, null, value);
    Node v$5 = GNode.create("Declarators", v$4);
    Node v$6 = GNode.create("FieldDeclaration", v$2, v$3, v$5);
    return v$6;
  }

  /**
   * Create a field declaration.
   *
   * @param name The name.
   * @return The generic node.
   */
  public Node fieldDecl3(String name) {
    Node v$1 = GNode.create("Modifiers", false);
    Node v$2 = GNode.create("QualifiedIdentifier", "Object");
    Node v$3 = GNode.create("Type", v$2, null);
    Node v$4 = GNode.create("NullLiteral", false);
    Node v$5 = GNode.create("Declarator", name, null, v$4);
    Node v$6 = GNode.create("Declarators", v$5);
    Node v$7 = GNode.create("FieldDeclaration", v$1, v$3, v$6);
    return v$7;
  }

  /**
   * Create a conditional expression.
   *
   * @param argument The argument.
   * @param tail The tail.
   * @return The generic node.
   */
  public Node fieldExpression(Node argument, String tail) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", v$1, "==", argument);
    Node v$3 = GNode.create("NullLiteral", false);
    Node v$4 = GNode.create("SelectionExpression", argument, tail);
    Node v$5 = GNode.create("ConditionalExpression", v$2, v$3, v$4);
    return v$5;
  }

  /**
   * Create a new class expression.
   *
   * @param arg1 The arg1.
   * @param arg2 The arg2.
   * @param arg3 The arg3.
   * @return The generic node.
   */
  public Node functionExpression(Node arg1, Node arg2, Node arg3) {
    Node v$1 = GNode.create("TypeInstantiation", "Function", null);
    Node v$2 = GNode.create("Type", arg1, null);
    Node v$3 = GNode.create("Type", arg2, null);
    Node v$4 = GNode.create("TypeArguments", v$2, v$3);
    Node v$5 = GNode.create("TypeInstantiation", "F1", v$4);
    Node v$6 = GNode.create("InstantiatedType", v$1, v$5);
    Node v$7 = GNode.create("Arguments", false);
    Node v$8 = GNode.create("Modifier", "public");
    Node v$9 = GNode.create("Modifiers", v$8);
    Node v$10 = GNode.create("Type", arg1, null);
    Node v$11 = GNode.create("Modifier", "final");
    Node v$12 = GNode.create("Modifiers", v$11);
    Node v$13 = GNode.create("Type", arg2, null);
    Node v$14 = GNode.create("FormalParameter", v$12, v$13, null, "var", 
      null);
    Node v$15 = GNode.create("FormalParameters", v$14);
    Node v$16 = GNode.create("ReturnStatement", arg3);
    Node v$17 = GNode.create("Block", v$16);
    Node v$18 = GNode.create("MethodDeclaration", v$9, null, v$10, "apply", 
      v$15, null, null, v$17);
    Node v$19 = GNode.create("ClassBody", v$18);
    Node v$20 = GNode.create("NewClassExpression", null, null, v$6, v$7, 
      v$19);
    return v$20;
  }

  /**
   * Create a conditional expression.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node getName(Node argument) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", v$1, "==", argument);
    Node v$3 = GNode.create("NullLiteral", false);
    Node v$4 = GNode.create("Arguments", false);
    Node v$5 = GNode.create("CallExpression", argument, null, "getName", v$4);
    Node v$6 = GNode.create("ConditionalExpression", v$2, v$3, v$5);
    return v$6;
  }

  /**
   * Create a method declaration.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node getNameMethod(Node argument) {
    Node v$1 = GNode.create("Modifier", "public");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("QualifiedIdentifier", "String");
    Node v$4 = GNode.create("Type", v$3, null);
    Node v$5 = GNode.create("FormalParameters", false);
    Node v$6 = GNode.create("ReturnStatement", argument);
    Node v$7 = GNode.create("Block", v$6);
    Node v$8 = GNode.create("MethodDeclaration", v$2, null, v$4, "getName", 
      v$5, null, null, v$7);
    return v$8;
  }

  /**
   * Create a method declaration.
   *
   * @return The generic node.
   */
  public Node getScopeNodesMethod() {
    Node v$1 = GNode.create("Modifier", "public");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("VoidType", false);
    Node v$4 = GNode.create("FormalParameters", false);
    Node v$5 = GNode.create("Block", false);
    Node v$6 = GNode.create("MethodDeclaration", v$2, null, v$3, 
      "getScopeNodes", v$4, null, null, v$5);
    return v$6;
  }

  /**
   * Create a class declaration.
   *
   * @return The generic node.
   */
  public Node getScopeClass() {
    Node v$1 = GNode.create("Modifiers", false);
    Node v$2 = GNode.create("Modifier", "public");
    Node v$3 = GNode.create("Modifiers", v$2);
    Node v$4 = GNode.create("QualifiedIdentifier", "Scope");
    Node v$5 = GNode.create("Type", v$4, null);
    Node v$6 = GNode.create("Modifiers", false);
    Node v$7 = GNode.create("QualifiedIdentifier", "GNode");
    Node v$8 = GNode.create("Type", v$7, null);
    Node v$9 = GNode.create("FormalParameter", v$6, v$8, null, "n", null);
    Node v$10 = GNode.create("FormalParameters", v$9);
    Node v$11 = GNode.create("NullLiteral", false);
    Node v$12 = GNode.create("ReturnStatement", v$11);
    Node v$13 = GNode.create("Block", v$12);
    Node v$14 = GNode.create("MethodDeclaration", v$3, null, v$5, "apply", 
      v$10, null, null, v$13);
    Node v$15 = GNode.create("ClassBody", v$14);
    Node v$16 = GNode.create("ClassDeclaration", v$1, "getScope", null, null, 
      null, v$15);
    return v$16;
  }

  /**
   * Create a field declaration.
   *
   * @return The generic node.
   */
  public Node getScopeObject() {
    Node v$1 = GNode.create("Modifier", "final");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("QualifiedIdentifier", "getScope");
    Node v$4 = GNode.create("Type", v$3, null);
    Node v$5 = GNode.create("QualifiedIdentifier", "getScope");
    Node v$6 = GNode.create("Arguments", false);
    Node v$7 = GNode.create("NewClassExpression", null, null, v$5, v$6, null);
    Node v$8 = GNode.create("Declarator", "getScope", null, v$7);
    Node v$9 = GNode.create("Declarators", v$8);
    Node v$10 = GNode.create("FieldDeclaration", v$2, v$4, v$9);
    return v$10;
  }

  /**
   * Create a method declaration.
   *
   * @return The generic node.
   */
  public Node getTagAbstract() {
    Node v$1 = GNode.create("Modifier", "public");
    Node v$2 = GNode.create("Modifier", "abstract");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("QualifiedIdentifier", "Tag");
    Node v$5 = GNode.create("Type", v$4, null);
    Node v$6 = GNode.create("FormalParameters", false);
    Node v$7 = GNode.create("MethodDeclaration", v$3, null, v$5, "tag", v$6, 
      null, null, null);
    return v$7;
  }

  /**
   * Create a method declaration.
   *
   * @param tag The tag.
   * @return The generic node.
   */
  public Node getTag(String tag) {
    Node v$1 = GNode.create("Modifier", "public");
    Node v$2 = GNode.create("Modifier", "final");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("QualifiedIdentifier", "Tag");
    Node v$5 = GNode.create("Type", v$4, null);
    Node v$6 = GNode.create("FormalParameters", false);
    Node v$7 = GNode.create("PrimaryIdentifier", "Tag");
    Node v$8 = GNode.create("SelectionExpression", v$7, tag);
    Node v$9 = GNode.create("ReturnStatement", v$8);
    Node v$10 = GNode.create("Block", v$9);
    Node v$11 = GNode.create("MethodDeclaration", v$3, null, v$5, "tag", v$6, 
      null, null, v$10);
    return v$11;
  }

  /**
   * Create a call expression.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node gnodeCast(Node argument) {
    Node v$1 = GNode.create("PrimaryIdentifier", "GNode");
    Node v$2 = GNode.create("Arguments", argument);
    Node v$3 = GNode.create("CallExpression", v$1, null, "cast", v$2);
    return v$3;
  }

  /**
   * Create a call expression.
   *
   * @param arguments The arguments.
   * @return The generic node.
   */
  public Node gnodeCreate(List<Node> arguments) {
    Node v$1 = GNode.create("PrimaryIdentifier", "GNode");
    Node v$2 = GNode.create("Arguments", arguments.size()).
      addAll(arguments);
    Node v$3 = GNode.create("CallExpression", v$1, null, "create", v$2);
    return v$3;
  }

  /**
   * Create a call expression.
   *
   * @param type The type.
   * @param statements The statements.
   * @return The generic node.
   */
  public Node guardExpression(Node type, List<Node> statements) {
    Node v$1 = GNode.create("Type", type, null);
    Node v$2 = GNode.create("TypeArguments", v$1);
    Node v$3 = GNode.create("TypeInstantiation", "Guard", v$2);
    Node v$4 = GNode.create("InstantiatedType", v$3);
    Node v$5 = GNode.create("Arguments", false);
    Node v$6 = GNode.create("Modifier", "public");
    Node v$7 = GNode.create("Modifiers", v$6);
    Node v$8 = GNode.create("Type", type, null);
    Node v$9 = GNode.create("FormalParameters", false);
    Node v$10 = GNode.create("Block", statements.size()).
      addAll(statements);
    Node v$11 = GNode.create("MethodDeclaration", v$7, null, v$8, "apply", 
      v$9, null, null, v$10);
    Node v$12 = GNode.create("ClassBody", v$11);
    Node v$13 = GNode.create("NewClassExpression", null, null, v$4, v$5, 
      v$12);
    Node v$14 = GNode.create("Arguments", false);
    Node v$15 = GNode.create("CallExpression", v$13, null, "apply", v$14);
    return v$15;
  }

  /**
   * Create a logical and expression.
   *
   * @param node The node.
   * @param name The name.
   * @return The generic node.
   */
  public Node hasNameCall(Node node, Node name) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", v$1, "!=", node);
    Node v$3 = GNode.create("Arguments", name);
    Node v$4 = GNode.create("CallExpression", node, null, "hasName", v$3);
    Node v$5 = GNode.create("LogicalAndExpression", v$2, v$4);
    return v$5;
  }

  /**
   * Create a call expression.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node head(Node argument) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "head");
    Node v$3 = GNode.create("Arguments", argument);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create a call expression.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node headWrapper(Node argument) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("Arguments", argument);
    Node v$3 = GNode.create("CallExpression", v$1, null, "wrapHead", v$2);
    return v$3;
  }

  /**
   * Create a conditional statement.
   *
   * @param condition The condition.
   * @param action The action.
   * @return The generic node.
   */
  public Node ifStatement(Node condition, Node action) {
    Node v$1 = GNode.create("Block", action);
    Node v$2 = GNode.create("ConditionalStatement", condition, v$1, null);
    return v$2;
  }

  /**
   * Create a conditional statement.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node ifStatement1(Node argument) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", argument, "==", v$1);
    Node v$3 = GNode.create("BooleanLiteral", "false");
    Node v$4 = GNode.create("ReturnStatement", v$3);
    Node v$5 = GNode.create("Block", v$4);
    Node v$6 = GNode.create("ConditionalStatement", v$2, v$5, null);
    return v$6;
  }

  /**
   * Create a conditional statement.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node ifStatement2(Node argument) {
    Node v$1 = GNode.create("QualifiedIdentifier", "Type");
    Node v$2 = GNode.create("Type", v$1, null);
    Node v$3 = GNode.create("InstanceOfExpression", argument, v$2);
    Node v$4 = GNode.create("LogicalNegationExpression", v$3);
    Node v$5 = GNode.create("BooleanLiteral", "false");
    Node v$6 = GNode.create("ReturnStatement", v$5);
    Node v$7 = GNode.create("Block", v$6);
    Node v$8 = GNode.create("ConditionalStatement", v$4, v$7, null);
    return v$8;
  }

  /**
   * Create a conditional statement.
   *
   * @param arg1 The arg1.
   * @param arg2 The arg2.
   * @param arg3 The arg3.
   * @param arg4 The arg4.
   * @return The generic node.
   */
  public Node ifStatement3(Node arg1, Node arg2, Node arg3, Node arg4) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", v$1, "!=", arg1);
    Node v$3 = GNode.create("LogicalNegationExpression", arg1);
    Node v$4 = GNode.create("LogicalAndExpression", v$2, v$3);
    Node v$5 = GNode.create("Arguments", arg2, arg3, arg4);
    Node v$6 = GNode.create("CallExpression", null, null, "showMessage", v$5);
    Node v$7 = GNode.create("ExpressionStatement", v$6);
    Node v$8 = GNode.create("Block", v$7);
    Node v$9 = GNode.create("ConditionalStatement", v$4, v$8, null);
    return v$9;
  }

  /**
   * Create a conditional statement.
   *
   * @param arg The arg.
   * @return The generic node.
   */
  public Node ifStatement4(Node arg) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", v$1, "==", arg);
    Node v$3 = GNode.create("NullLiteral", false);
    Node v$4 = GNode.create("ReturnStatement", v$3);
    Node v$5 = GNode.create("Block", v$4);
    Node v$6 = GNode.create("ConditionalStatement", v$2, v$5, null);
    return v$6;
  }

  /**
   * Create a conditional statement.
   *
   * @param arg The arg.
   * @return The generic node.
   */
  public Node ifStatement5(Node arg) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("ReturnStatement", v$1);
    Node v$3 = GNode.create("Block", v$2);
    Node v$4 = GNode.create("ConditionalStatement", arg, v$3, null);
    return v$4;
  }

  /**
   * Create a conditional expression.
   *
   * @param condition The condition.
   * @param expression The expression.
   * @return The generic node.
   */
  public Node ifExpression(Node condition, Node expression) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", v$1, "==", condition);
    Node v$3 = GNode.create("LogicalNegationExpression", condition);
    Node v$4 = GNode.create("LogicalOrExpression", v$2, v$3);
    Node v$5 = GNode.create("NullLiteral", false);
    Node v$6 = GNode.create("ConditionalExpression", v$4, v$5, expression);
    return v$6;
  }

  /**
   * Create a conditional expression.
   *
   * @param condition The condition.
   * @param expr1 The expr1.
   * @param expr2 The expr2.
   * @return The generic node.
   */
  public Node ifElseExpression(Node condition, Node expr1, Node expr2) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", v$1, "==", condition);
    Node v$3 = GNode.create("NullLiteral", false);
    Node v$4 = GNode.create("ConditionalExpression", condition, expr1, expr2);
    Node v$5 = GNode.create("ConditionalExpression", v$2, v$3, v$4);
    return v$5;
  }

  /**
   * Create a class declaration.
   *
   * @return The generic node.
   */
  public Node implementsDecl() {
    Node v$1 = GNode.create("Modifier", "public");
    Node v$2 = GNode.create("Modifier", "static");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("QualifiedIdentifier", "Type");
    Node v$5 = GNode.create("Type", v$4, null);
    Node v$6 = GNode.create("Implementation", v$5);
    Node v$7 = GNode.create("ClassBody", false);
    Node v$8 = GNode.create("ClassDeclaration", v$3, "Name", null, null, v$6, 
      v$7);
    return v$8;
  }

  /**
   * Create a call expression.
   *
   * @param name The name.
   * @param function The function.
   * @param arguments The arguments.
   * @return The generic node.
   */
  public Node invocation(Node name, String function, List<Node> arguments) {
    Node v$1 = GNode.create("Arguments", arguments.size()).
      addAll(arguments);
    Node v$2 = GNode.create("CallExpression", name, null, function, v$1);
    return v$2;
  }

  /**
   * Create a field declaration.
   *
   * @param type1 The type1.
   * @param name The name.
   * @param type2 The type2.
   * @return The generic node.
   */
  public Node instanceDecl(Node type1, String name, Node type2) {
    Node v$1 = GNode.create("Modifier", "final");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("Type", type1, null);
    Node v$4 = GNode.create("Arguments", false);
    Node v$5 = GNode.create("NewClassExpression", null, null, type2, v$4, 
      null);
    Node v$6 = GNode.create("Declarator", name, null, v$5);
    Node v$7 = GNode.create("Declarators", v$6);
    Node v$8 = GNode.create("FieldDeclaration", v$2, v$3, v$7);
    return v$8;
  }

  /**
   * Create a call expression.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node isBottom(Node argument) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "isBottom");
    Node v$3 = GNode.create("Arguments", argument);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create a logical and expression.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node isEmptyCall(Node argument) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", v$1, "!=", argument);
    Node v$3 = GNode.create("QualifiedIdentifier", "Pair");
    Node v$4 = GNode.create("Type", v$3, null);
    Node v$5 = GNode.create("CastExpression", v$4, argument);
    Node v$6 = GNode.create("Arguments", false);
    Node v$7 = GNode.create("CallExpression", v$5, null, "isEmpty", v$6);
    Node v$8 = GNode.create("LogicalAndExpression", v$2, v$7);
    return v$8;
  }

  /**
   * Create a logical and expression.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node isNotEmptyCall(Node argument) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", v$1, "!=", argument);
    Node v$3 = GNode.create("QualifiedIdentifier", "Pair");
    Node v$4 = GNode.create("Type", v$3, null);
    Node v$5 = GNode.create("CastExpression", v$4, argument);
    Node v$6 = GNode.create("Arguments", false);
    Node v$7 = GNode.create("CallExpression", v$5, null, "isEmpty", v$6);
    Node v$8 = GNode.create("LogicalNegationExpression", v$7);
    Node v$9 = GNode.create("LogicalAndExpression", v$2, v$8);
    return v$9;
  }

  /**
   * Create a method declaration.
   *
   * @return The generic node.
   */
  public Node isMethod() {
    Node v$1 = GNode.create("Modifier", "public");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("PrimitiveType", "boolean");
    Node v$4 = GNode.create("Type", v$3, null);
    Node v$5 = GNode.create("FormalParameters", false);
    Node v$6 = GNode.create("BooleanLiteral", "false");
    Node v$7 = GNode.create("ReturnStatement", v$6);
    Node v$8 = GNode.create("Block", v$7);
    Node v$9 = GNode.create("MethodDeclaration", v$2, null, v$4, "isName", 
      v$5, null, null, v$8);
    return v$9;
  }

  /**
   * Create a logical and expression.
   *
   * @param argument The argument.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node isMethodCall(Node argument, String argument2) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", v$1, "!=", argument);
    Node v$3 = GNode.create("Arguments", false);
    Node v$4 = GNode.create("CallExpression", argument, null, argument2, v$3);
    Node v$5 = GNode.create("LogicalAndExpression", v$2, v$4);
    return v$5;
  }

  /**
   * Create a logical and expression.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node jand(Node argument1, Node argument2) {
    Node v$1 = GNode.create("LogicalAndExpression", argument1, argument2);
    return v$1;
  }

  /**
   * Create a logical and expression.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node jequals(Node argument1, Node argument2) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", v$1, "!=", argument1);
    Node v$3 = GNode.create("Arguments", argument2);
    Node v$4 = GNode.create("CallExpression", argument1, null, "equals", v$3);
    Node v$5 = GNode.create("LogicalAndExpression", v$2, v$4);
    return v$5;
  }

  /**
   * Create a call expression.
   *
   * @param argument The argument.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node jequals2(Node argument, Node argument2) {
    Node v$1 = GNode.create("Arguments", argument2);
    Node v$2 = GNode.create("CallExpression", argument, null, "equals", v$1);
    return v$2;
  }

  /**
   * Create a logical negation expression.
   *
   * @param condition The condition.
   * @return The generic node.
   */
  public Node jnot(Node condition) {
    Node v$1 = GNode.create("LogicalNegationExpression", condition);
    return v$1;
  }

  /**
   * Create a logical or expression.
   *
   * @param condition1 The condition1.
   * @param condition2 The condition2.
   * @return The generic node.
   */
  public Node jor(Node condition1, Node condition2) {
    Node v$1 = GNode.create("LogicalOrExpression", condition1, condition2);
    return v$1;
  }

  /**
   * Create an equality expression.
   *
   * @param arg The arg.
   * @return The generic node.
   */
  public Node isNull(Node arg) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", v$1, "==", arg);
    return v$2;
  }

  /**
   * Create a call expression.
   *
   * @param type The type.
   * @return The generic node.
   */
  public Node letExpression(Node type) {
    Node v$1 = GNode.create("Type", type, null);
    Node v$2 = GNode.create("TypeArguments", v$1);
    Node v$3 = GNode.create("TypeInstantiation", "Let", v$2);
    Node v$4 = GNode.create("InstantiatedType", v$3);
    Node v$5 = GNode.create("Arguments", false);
    Node v$6 = GNode.create("ClassBody", false);
    Node v$7 = GNode.create("NewClassExpression", null, null, v$4, v$5, v$6);
    Node v$8 = GNode.create("Arguments", false);
    Node v$9 = GNode.create("CallExpression", v$7, null, "apply", v$8);
    return v$9;
  }

  /**
   * Create a field declaration.
   *
   * @param name The name.
   * @param node The node.
   * @param size The size.
   * @return The generic node.
   */
  public Node makeNodeBinding(String name, Node node, Node size) {
    Node v$1 = GNode.create("Modifier", "final");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("QualifiedIdentifier", "Node");
    Node v$4 = GNode.create("Type", v$3, null);
    Node v$5 = GNode.create("Arguments", false);
    Node v$6 = GNode.create("CallExpression", node, null, "size", v$5);
    Node v$7 = GNode.create("RelationalExpression", v$6, ">", size);
    Node v$8 = GNode.create("Arguments", size);
    Node v$9 = GNode.create("CallExpression", node, null, "getGeneric", v$8);
    Node v$10 = GNode.create("NullLiteral", false);
    Node v$11 = GNode.create("ConditionalExpression", v$7, v$9, v$10);
    Node v$12 = GNode.create("Declarator", name, null, v$11);
    Node v$13 = GNode.create("Declarators", v$12);
    Node v$14 = GNode.create("FieldDeclaration", v$2, v$4, v$13);
    return v$14;
  }

  /**
   * Create a field declaration.
   *
   * @param name The name.
   * @param node The node.
   * @param size The size.
   * @return The generic node.
   */
  public Node makeNodeBinding2(String name, Node node, Node size) {
    Node v$1 = GNode.create("Modifier", "final");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("QualifiedIdentifier", "String");
    Node v$4 = GNode.create("Type", v$3, null);
    Node v$5 = GNode.create("Arguments", false);
    Node v$6 = GNode.create("CallExpression", node, null, "size", v$5);
    Node v$7 = GNode.create("RelationalExpression", v$6, ">", size);
    Node v$8 = GNode.create("Arguments", size);
    Node v$9 = GNode.create("CallExpression", node, null, "getString", v$8);
    Node v$10 = GNode.create("NullLiteral", false);
    Node v$11 = GNode.create("ConditionalExpression", v$7, v$9, v$10);
    Node v$12 = GNode.create("Declarator", name, null, v$11);
    Node v$13 = GNode.create("Declarators", v$12);
    Node v$14 = GNode.create("FieldDeclaration", v$2, v$4, v$13);
    return v$14;
  }

  /**
   * Create a call expression.
   *
   * @param qualifier The qualifier.
   * @param match The match.
   * @param argument The argument.
   * @return The generic node.
   */
  public Node matchCall(Node qualifier, String match, Node argument) {
    Node v$1 = GNode.create("Arguments", argument);
    Node v$2 = GNode.create("CallExpression", qualifier, null, match, v$1);
    return v$2;
  }

  /**
   * Create a call expression.
   *
   * @param type The type.
   * @param statements The statements.
   * @return The generic node.
   */
  public Node matchExpression(Node type, List<Node> statements) {
    Node v$1 = GNode.create("Type", type, null);
    Node v$2 = GNode.create("TypeArguments", v$1);
    Node v$3 = GNode.create("TypeInstantiation", "Match", v$2);
    Node v$4 = GNode.create("InstantiatedType", v$3);
    Node v$5 = GNode.create("Arguments", false);
    Node v$6 = GNode.create("Modifier", "public");
    Node v$7 = GNode.create("Modifiers", v$6);
    Node v$8 = GNode.create("Type", type, null);
    Node v$9 = GNode.create("FormalParameters", false);
    Node v$10 = GNode.create("Block", statements.size()).
      addAll(statements);
    Node v$11 = GNode.create("MethodDeclaration", v$7, null, v$8, "apply", 
      v$9, null, null, v$10);
    Node v$12 = GNode.create("ClassBody", v$11);
    Node v$13 = GNode.create("NewClassExpression", null, null, v$4, v$5, 
      v$12);
    Node v$14 = GNode.create("Arguments", false);
    Node v$15 = GNode.create("CallExpression", v$13, null, "apply", v$14);
    return v$15;
  }

  /**
   * Create a method declaration.
   *
   * @param match The match.
   * @param type The type.
   * @param condition The condition.
   * @return The generic node.
   */
  public Node matchFunction(String match, Node type, Node condition) {
    Node v$1 = GNode.create("Modifier", "static");
    Node v$2 = GNode.create("Modifier", "final");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("PrimitiveType", "boolean");
    Node v$5 = GNode.create("Type", v$4, null);
    Node v$6 = GNode.create("Modifiers", false);
    Node v$7 = GNode.create("Type", type, null);
    Node v$8 = GNode.create("FormalParameter", v$6, v$7, null, "argument", 
      null);
    Node v$9 = GNode.create("FormalParameters", v$8);
    Node v$10 = GNode.create("ReturnStatement", condition);
    Node v$11 = GNode.create("Block", v$10);
    Node v$12 = GNode.create("MethodDeclaration", v$3, null, v$5, match, v$9, 
      null, null, v$11);
    return v$12;
  }

  /**
   * Create an expression statement.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node matchingNodesAdd(Node argument) {
    Node v$1 = GNode.create("PrimaryIdentifier", "matching_nodes");
    Node v$2 = GNode.create("Arguments", argument);
    Node v$3 = GNode.create("CallExpression", v$1, null, "add", v$2);
    Node v$4 = GNode.create("ExpressionStatement", v$3);
    return v$4;
  }

  /**
   * Create an expression statement.
   *
   * @return The generic node.
   */
  public Node matchingNodesRemove() {
    Node v$1 = GNode.create("PrimaryIdentifier", "matching_nodes");
    Node v$2 = GNode.create("PrimaryIdentifier", "matching_nodes");
    Node v$3 = GNode.create("Arguments", false);
    Node v$4 = GNode.create("CallExpression", v$2, null, "size", v$3);
    Node v$5 = GNode.create("IntegerLiteral", "1");
    Node v$6 = GNode.create("AdditiveExpression", v$4, "-", v$5);
    Node v$7 = GNode.create("Arguments", v$6);
    Node v$8 = GNode.create("CallExpression", v$1, null, "remove", v$7);
    Node v$9 = GNode.create("ExpressionStatement", v$8);
    return v$9;
  }

  /**
   * Create a call expression.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node multiplyInt(Node argument1, Node argument2) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "multiplyInt");
    Node v$3 = GNode.create("Arguments", argument1, argument2);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create a call expression.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node multiplyFloat64(Node argument1, Node argument2) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "multiplyFloat64");
    Node v$3 = GNode.create("Arguments", argument1, argument2);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create a new class expression.
   *
   * @param type The type.
   * @param args The args.
   * @return The generic node.
   */
  public Node newExpr(Node type, List<Node> args) {
    Node v$1 = GNode.create("Arguments", args.size()).
      addAll(args);
    Node v$2 = GNode.create("NewClassExpression", null, null, type, v$1, 
      null);
    return v$2;
  }

  /**
   * Create a new class expression.
   *
   * @param type The type.
   * @param argument The argument.
   * @return The generic node.
   */
  public Node newPair(Node type, Node argument) {
    Node v$1 = GNode.create("Arguments", argument);
    Node v$2 = GNode.create("NewClassExpression", null, null, type, v$1, 
      null);
    return v$2;
  }

  /**
   * Create a field declaration.
   *
   * @param type The type.
   * @param name The name.
   * @return The generic node.
   */
  public Node newCons(Node type, String name) {
    Node v$1 = GNode.create("Modifier", "static");
    Node v$2 = GNode.create("Modifier", "final");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$5 = GNode.create("Type", type, null);
    Node v$6 = GNode.create("TypeArguments", v$5);
    Node v$7 = GNode.create("TypeInstantiation", "Cons", v$6);
    Node v$8 = GNode.create("InstantiatedType", v$4, v$7);
    Node v$9 = GNode.create("Type", v$8, null);
    Node v$10 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$11 = GNode.create("Type", type, null);
    Node v$12 = GNode.create("TypeArguments", v$11);
    Node v$13 = GNode.create("TypeInstantiation", "Cons", v$12);
    Node v$14 = GNode.create("InstantiatedType", v$10, v$13);
    Node v$15 = GNode.create("Arguments", false);
    Node v$16 = GNode.create("NewClassExpression", null, null, v$14, v$15, 
      null);
    Node v$17 = GNode.create("Declarator", name, null, v$16);
    Node v$18 = GNode.create("Declarators", v$17);
    Node v$19 = GNode.create("FieldDeclaration", v$3, v$9, v$18);
    return v$19;
  }

  /**
   * Create a call expression.
   *
   * @param type The type.
   * @param agrs The agrs.
   * @return The generic node.
   */
  public Node newApplyCons(Node type, List<Node> agrs) {
    Node v$1 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$2 = GNode.create("Type", type, null);
    Node v$3 = GNode.create("TypeArguments", v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Cons", v$3);
    Node v$5 = GNode.create("InstantiatedType", v$1, v$4);
    Node v$6 = GNode.create("Arguments", false);
    Node v$7 = GNode.create("NewClassExpression", null, null, v$5, v$6, null);
    Node v$8 = GNode.create("Arguments", agrs.size()).
      addAll(agrs);
    Node v$9 = GNode.create("CallExpression", v$7, null, "apply", v$8);
    return v$9;
  }

  /**
   * Create a field declaration.
   *
   * @param type The type.
   * @param name The name.
   * @return The generic node.
   */
  public Node newHead(Node type, String name) {
    Node v$1 = GNode.create("Modifier", "static");
    Node v$2 = GNode.create("Modifier", "final");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$5 = GNode.create("Type", type, null);
    Node v$6 = GNode.create("TypeArguments", v$5);
    Node v$7 = GNode.create("TypeInstantiation", "Head", v$6);
    Node v$8 = GNode.create("InstantiatedType", v$4, v$7);
    Node v$9 = GNode.create("Type", v$8, null);
    Node v$10 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$11 = GNode.create("Type", type, null);
    Node v$12 = GNode.create("TypeArguments", v$11);
    Node v$13 = GNode.create("TypeInstantiation", "Head", v$12);
    Node v$14 = GNode.create("InstantiatedType", v$10, v$13);
    Node v$15 = GNode.create("Arguments", false);
    Node v$16 = GNode.create("NewClassExpression", null, null, v$14, v$15, 
      null);
    Node v$17 = GNode.create("Declarator", name, null, v$16);
    Node v$18 = GNode.create("Declarators", v$17);
    Node v$19 = GNode.create("FieldDeclaration", v$3, v$9, v$18);
    return v$19;
  }

  /**
   * Create a call expression.
   *
   * @param type The type.
   * @param args The args.
   * @return The generic node.
   */
  public Node newApplyHead(Node type, List<Node> args) {
    Node v$1 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$2 = GNode.create("Type", type, null);
    Node v$3 = GNode.create("TypeArguments", v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Head", v$3);
    Node v$5 = GNode.create("InstantiatedType", v$1, v$4);
    Node v$6 = GNode.create("Arguments", false);
    Node v$7 = GNode.create("NewClassExpression", null, null, v$5, v$6, null);
    Node v$8 = GNode.create("Arguments", args.size()).
      addAll(args);
    Node v$9 = GNode.create("CallExpression", v$7, null, "apply", v$8);
    return v$9;
  }

  /**
   * Create a field declaration.
   *
   * @param type The type.
   * @param name The name.
   * @return The generic node.
   */
  public Node newTail(Node type, String name) {
    Node v$1 = GNode.create("Modifier", "static");
    Node v$2 = GNode.create("Modifier", "final");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$5 = GNode.create("Type", type, null);
    Node v$6 = GNode.create("TypeArguments", v$5);
    Node v$7 = GNode.create("TypeInstantiation", "Tail", v$6);
    Node v$8 = GNode.create("InstantiatedType", v$4, v$7);
    Node v$9 = GNode.create("Type", v$8, null);
    Node v$10 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$11 = GNode.create("Type", type, null);
    Node v$12 = GNode.create("TypeArguments", v$11);
    Node v$13 = GNode.create("TypeInstantiation", "Tail", v$12);
    Node v$14 = GNode.create("InstantiatedType", v$10, v$13);
    Node v$15 = GNode.create("Arguments", false);
    Node v$16 = GNode.create("NewClassExpression", null, null, v$14, v$15, 
      null);
    Node v$17 = GNode.create("Declarator", name, null, v$16);
    Node v$18 = GNode.create("Declarators", v$17);
    Node v$19 = GNode.create("FieldDeclaration", v$3, v$9, v$18);
    return v$19;
  }

  /**
   * Create a call expression.
   *
   * @param type The type.
   * @param args The args.
   * @return The generic node.
   */
  public Node newApplyTail(Node type, List<Node> args) {
    Node v$1 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$2 = GNode.create("Type", type, null);
    Node v$3 = GNode.create("TypeArguments", v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Tail", v$3);
    Node v$5 = GNode.create("InstantiatedType", v$1, v$4);
    Node v$6 = GNode.create("Arguments", false);
    Node v$7 = GNode.create("NewClassExpression", null, null, v$5, v$6, null);
    Node v$8 = GNode.create("Arguments", args.size()).
      addAll(args);
    Node v$9 = GNode.create("CallExpression", v$7, null, "apply", v$8);
    return v$9;
  }

  /**
   * Create a field declaration.
   *
   * @param type The type.
   * @param name The name.
   * @return The generic node.
   */
  public Node newFlatten(Node type, String name) {
    Node v$1 = GNode.create("Modifier", "static");
    Node v$2 = GNode.create("Modifier", "final");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$5 = GNode.create("Type", type, null);
    Node v$6 = GNode.create("TypeArguments", v$5);
    Node v$7 = GNode.create("TypeInstantiation", "Flatten", v$6);
    Node v$8 = GNode.create("InstantiatedType", v$4, v$7);
    Node v$9 = GNode.create("Type", v$8, null);
    Node v$10 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$11 = GNode.create("Type", type, null);
    Node v$12 = GNode.create("TypeArguments", v$11);
    Node v$13 = GNode.create("TypeInstantiation", "Flatten", v$12);
    Node v$14 = GNode.create("InstantiatedType", v$10, v$13);
    Node v$15 = GNode.create("Arguments", false);
    Node v$16 = GNode.create("NewClassExpression", null, null, v$14, v$15, 
      null);
    Node v$17 = GNode.create("Declarator", name, null, v$16);
    Node v$18 = GNode.create("Declarators", v$17);
    Node v$19 = GNode.create("FieldDeclaration", v$3, v$9, v$18);
    return v$19;
  }

  /**
   * Create a call expression.
   *
   * @param type The type.
   * @param args The args.
   * @return The generic node.
   */
  public Node newApplyFlatten(Node type, List<Node> args) {
    Node v$1 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$2 = GNode.create("Type", type, null);
    Node v$3 = GNode.create("TypeArguments", v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Flatten", v$3);
    Node v$5 = GNode.create("InstantiatedType", v$1, v$4);
    Node v$6 = GNode.create("Arguments", false);
    Node v$7 = GNode.create("NewClassExpression", null, null, v$5, v$6, null);
    Node v$8 = GNode.create("Arguments", args.size()).
      addAll(args);
    Node v$9 = GNode.create("CallExpression", v$7, null, "apply", v$8);
    return v$9;
  }

  /**
   * Create a field declaration.
   *
   * @param type The type.
   * @param name The name.
   * @return The generic node.
   */
  public Node newNth(Node type, String name) {
    Node v$1 = GNode.create("Modifier", "static");
    Node v$2 = GNode.create("Modifier", "final");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$5 = GNode.create("Type", type, null);
    Node v$6 = GNode.create("TypeArguments", v$5);
    Node v$7 = GNode.create("TypeInstantiation", "Nth", v$6);
    Node v$8 = GNode.create("InstantiatedType", v$4, v$7);
    Node v$9 = GNode.create("Type", v$8, null);
    Node v$10 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$11 = GNode.create("Type", type, null);
    Node v$12 = GNode.create("TypeArguments", v$11);
    Node v$13 = GNode.create("TypeInstantiation", "Nth", v$12);
    Node v$14 = GNode.create("InstantiatedType", v$10, v$13);
    Node v$15 = GNode.create("Arguments", false);
    Node v$16 = GNode.create("NewClassExpression", null, null, v$14, v$15, 
      null);
    Node v$17 = GNode.create("Declarator", name, null, v$16);
    Node v$18 = GNode.create("Declarators", v$17);
    Node v$19 = GNode.create("FieldDeclaration", v$3, v$9, v$18);
    return v$19;
  }

  /**
   * Create a call expression.
   *
   * @param type The type.
   * @param args The args.
   * @return The generic node.
   */
  public Node newApplyNth(Node type, List<Node> args) {
    Node v$1 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$2 = GNode.create("Type", type, null);
    Node v$3 = GNode.create("TypeArguments", v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Nth", v$3);
    Node v$5 = GNode.create("InstantiatedType", v$1, v$4);
    Node v$6 = GNode.create("Arguments", false);
    Node v$7 = GNode.create("NewClassExpression", null, null, v$5, v$6, null);
    Node v$8 = GNode.create("Arguments", args.size()).
      addAll(args);
    Node v$9 = GNode.create("CallExpression", v$7, null, "apply", v$8);
    return v$9;
  }

  /**
   * Create a field declaration.
   *
   * @param type The type.
   * @param name The name.
   * @return The generic node.
   */
  public Node newExists(Node type, String name) {
    Node v$1 = GNode.create("Modifier", "static");
    Node v$2 = GNode.create("Modifier", "final");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$5 = GNode.create("Type", type, null);
    Node v$6 = GNode.create("TypeArguments", v$5);
    Node v$7 = GNode.create("TypeInstantiation", "Exists", v$6);
    Node v$8 = GNode.create("InstantiatedType", v$4, v$7);
    Node v$9 = GNode.create("Type", v$8, null);
    Node v$10 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$11 = GNode.create("Type", type, null);
    Node v$12 = GNode.create("TypeArguments", v$11);
    Node v$13 = GNode.create("TypeInstantiation", "Exists", v$12);
    Node v$14 = GNode.create("InstantiatedType", v$10, v$13);
    Node v$15 = GNode.create("Arguments", false);
    Node v$16 = GNode.create("NewClassExpression", null, null, v$14, v$15, 
      null);
    Node v$17 = GNode.create("Declarator", name, null, v$16);
    Node v$18 = GNode.create("Declarators", v$17);
    Node v$19 = GNode.create("FieldDeclaration", v$3, v$9, v$18);
    return v$19;
  }

  /**
   * Create a call expression.
   *
   * @param type The type.
   * @param args The args.
   * @return The generic node.
   */
  public Node newApplyExists(Node type, List<Node> args) {
    Node v$1 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$2 = GNode.create("Type", type, null);
    Node v$3 = GNode.create("TypeArguments", v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Exists", v$3);
    Node v$5 = GNode.create("InstantiatedType", v$1, v$4);
    Node v$6 = GNode.create("Arguments", false);
    Node v$7 = GNode.create("NewClassExpression", null, null, v$5, v$6, null);
    Node v$8 = GNode.create("Arguments", args.size()).
      addAll(args);
    Node v$9 = GNode.create("CallExpression", v$7, null, "apply", v$8);
    return v$9;
  }

  /**
   * Create a field declaration.
   *
   * @param type1 The type1.
   * @param type2 The type2.
   * @param name The name.
   * @return The generic node.
   */
  public Node newIter(Node type1, Node type2, String name) {
    Node v$1 = GNode.create("Modifier", "static");
    Node v$2 = GNode.create("Modifier", "final");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$5 = GNode.create("Type", type1, null);
    Node v$6 = GNode.create("Type", type2, null);
    Node v$7 = GNode.create("TypeArguments", v$5, v$6);
    Node v$8 = GNode.create("TypeInstantiation", "Iter", v$7);
    Node v$9 = GNode.create("InstantiatedType", v$4, v$8);
    Node v$10 = GNode.create("Type", v$9, null);
    Node v$11 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$12 = GNode.create("Type", type1, null);
    Node v$13 = GNode.create("Type", type2, null);
    Node v$14 = GNode.create("TypeArguments", v$12, v$13);
    Node v$15 = GNode.create("TypeInstantiation", "Iter", v$14);
    Node v$16 = GNode.create("InstantiatedType", v$11, v$15);
    Node v$17 = GNode.create("Arguments", false);
    Node v$18 = GNode.create("NewClassExpression", null, null, v$16, v$17, 
      null);
    Node v$19 = GNode.create("Declarator", name, null, v$18);
    Node v$20 = GNode.create("Declarators", v$19);
    Node v$21 = GNode.create("FieldDeclaration", v$3, v$10, v$20);
    return v$21;
  }

  /**
   * Create a call expression.
   *
   * @param type1 The type1.
   * @param type2 The type2.
   * @param args The args.
   * @return The generic node.
   */
  public Node newApplyIter(Node type1, Node type2, List<Node> args) {
    Node v$1 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$2 = GNode.create("Type", type1, null);
    Node v$3 = GNode.create("Type", type2, null);
    Node v$4 = GNode.create("TypeArguments", v$2, v$3);
    Node v$5 = GNode.create("TypeInstantiation", "Iter", v$4);
    Node v$6 = GNode.create("InstantiatedType", v$1, v$5);
    Node v$7 = GNode.create("Arguments", false);
    Node v$8 = GNode.create("NewClassExpression", null, null, v$6, v$7, null);
    Node v$9 = GNode.create("Arguments", args.size()).
      addAll(args);
    Node v$10 = GNode.create("CallExpression", v$8, null, "apply", v$9);
    return v$10;
  }

  /**
   * Create a field declaration.
   *
   * @param type1 The type1.
   * @param type2 The type2.
   * @param name The name.
   * @return The generic node.
   */
  public Node newMap(Node type1, Node type2, String name) {
    Node v$1 = GNode.create("Modifier", "static");
    Node v$2 = GNode.create("Modifier", "final");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$5 = GNode.create("Type", type1, null);
    Node v$6 = GNode.create("Type", type2, null);
    Node v$7 = GNode.create("TypeArguments", v$5, v$6);
    Node v$8 = GNode.create("TypeInstantiation", "Map", v$7);
    Node v$9 = GNode.create("InstantiatedType", v$4, v$8);
    Node v$10 = GNode.create("Type", v$9, null);
    Node v$11 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$12 = GNode.create("Type", type1, null);
    Node v$13 = GNode.create("Type", type2, null);
    Node v$14 = GNode.create("TypeArguments", v$12, v$13);
    Node v$15 = GNode.create("TypeInstantiation", "Map", v$14);
    Node v$16 = GNode.create("InstantiatedType", v$11, v$15);
    Node v$17 = GNode.create("Arguments", false);
    Node v$18 = GNode.create("NewClassExpression", null, null, v$16, v$17, 
      null);
    Node v$19 = GNode.create("Declarator", name, null, v$18);
    Node v$20 = GNode.create("Declarators", v$19);
    Node v$21 = GNode.create("FieldDeclaration", v$3, v$10, v$20);
    return v$21;
  }

  /**
   * Create a call expression.
   *
   * @param type1 The type1.
   * @param type2 The type2.
   * @param args The args.
   * @return The generic node.
   */
  public Node newApplyMap(Node type1, Node type2, List<Node> args) {
    Node v$1 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$2 = GNode.create("Type", type1, null);
    Node v$3 = GNode.create("Type", type2, null);
    Node v$4 = GNode.create("TypeArguments", v$2, v$3);
    Node v$5 = GNode.create("TypeInstantiation", "Map", v$4);
    Node v$6 = GNode.create("InstantiatedType", v$1, v$5);
    Node v$7 = GNode.create("Arguments", false);
    Node v$8 = GNode.create("NewClassExpression", null, null, v$6, v$7, null);
    Node v$9 = GNode.create("Arguments", args.size()).
      addAll(args);
    Node v$10 = GNode.create("CallExpression", v$8, null, "apply", v$9);
    return v$10;
  }

  /**
   * Create a field declaration.
   *
   * @param type1 The type1.
   * @param type2 The type2.
   * @param name The name.
   * @return The generic node.
   */
  public Node newFoldl(Node type1, Node type2, String name) {
    Node v$1 = GNode.create("Modifier", "static");
    Node v$2 = GNode.create("Modifier", "final");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$5 = GNode.create("Type", type1, null);
    Node v$6 = GNode.create("Type", type2, null);
    Node v$7 = GNode.create("TypeArguments", v$5, v$6);
    Node v$8 = GNode.create("TypeInstantiation", "FoldLeft", v$7);
    Node v$9 = GNode.create("InstantiatedType", v$4, v$8);
    Node v$10 = GNode.create("Type", v$9, null);
    Node v$11 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$12 = GNode.create("Type", type1, null);
    Node v$13 = GNode.create("Type", type2, null);
    Node v$14 = GNode.create("TypeArguments", v$12, v$13);
    Node v$15 = GNode.create("TypeInstantiation", "FoldLeft", v$14);
    Node v$16 = GNode.create("InstantiatedType", v$11, v$15);
    Node v$17 = GNode.create("Arguments", false);
    Node v$18 = GNode.create("NewClassExpression", null, null, v$16, v$17, 
      null);
    Node v$19 = GNode.create("Declarator", name, null, v$18);
    Node v$20 = GNode.create("Declarators", v$19);
    Node v$21 = GNode.create("FieldDeclaration", v$3, v$10, v$20);
    return v$21;
  }

  /**
   * Create a call expression.
   *
   * @param type1 The type1.
   * @param type2 The type2.
   * @param args The args.
   * @return The generic node.
   */
  public Node newApplyFoldl(Node type1, Node type2, List<Node> args) {
    Node v$1 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$2 = GNode.create("Type", type1, null);
    Node v$3 = GNode.create("Type", type2, null);
    Node v$4 = GNode.create("TypeArguments", v$2, v$3);
    Node v$5 = GNode.create("TypeInstantiation", "FoldLeft", v$4);
    Node v$6 = GNode.create("InstantiatedType", v$1, v$5);
    Node v$7 = GNode.create("Arguments", false);
    Node v$8 = GNode.create("NewClassExpression", null, null, v$6, v$7, null);
    Node v$9 = GNode.create("Arguments", args.size()).
      addAll(args);
    Node v$10 = GNode.create("CallExpression", v$8, null, "apply", v$9);
    return v$10;
  }

  /**
   * Create a field declaration.
   *
   * @param type The type.
   * @param name The name.
   * @return The generic node.
   */
  public Node newAppend(Node type, String name) {
    Node v$1 = GNode.create("Modifier", "static");
    Node v$2 = GNode.create("Modifier", "final");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$5 = GNode.create("Type", type, null);
    Node v$6 = GNode.create("TypeArguments", v$5);
    Node v$7 = GNode.create("TypeInstantiation", "Append", v$6);
    Node v$8 = GNode.create("InstantiatedType", v$4, v$7);
    Node v$9 = GNode.create("Type", v$8, null);
    Node v$10 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$11 = GNode.create("Type", type, null);
    Node v$12 = GNode.create("TypeArguments", v$11);
    Node v$13 = GNode.create("TypeInstantiation", "Append", v$12);
    Node v$14 = GNode.create("InstantiatedType", v$10, v$13);
    Node v$15 = GNode.create("Arguments", false);
    Node v$16 = GNode.create("NewClassExpression", null, null, v$14, v$15, 
      null);
    Node v$17 = GNode.create("Declarator", name, null, v$16);
    Node v$18 = GNode.create("Declarators", v$17);
    Node v$19 = GNode.create("FieldDeclaration", v$3, v$9, v$18);
    return v$19;
  }

  /**
   * Create a call expression.
   *
   * @param type The type.
   * @param args The args.
   * @return The generic node.
   */
  public Node newApplyAppend(Node type, List<Node> args) {
    Node v$1 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$2 = GNode.create("Type", type, null);
    Node v$3 = GNode.create("TypeArguments", v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Append", v$3);
    Node v$5 = GNode.create("InstantiatedType", v$1, v$4);
    Node v$6 = GNode.create("Arguments", false);
    Node v$7 = GNode.create("NewClassExpression", null, null, v$5, v$6, null);
    Node v$8 = GNode.create("Arguments", args.size()).
      addAll(args);
    Node v$9 = GNode.create("CallExpression", v$7, null, "apply", v$8);
    return v$9;
  }

  /**
   * Create a field declaration.
   *
   * @param type The type.
   * @param name The name.
   * @return The generic node.
   */
  public Node newUnion(Node type, String name) {
    Node v$1 = GNode.create("Modifier", "static");
    Node v$2 = GNode.create("Modifier", "final");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$5 = GNode.create("Type", type, null);
    Node v$6 = GNode.create("TypeArguments", v$5);
    Node v$7 = GNode.create("TypeInstantiation", "Union", v$6);
    Node v$8 = GNode.create("InstantiatedType", v$4, v$7);
    Node v$9 = GNode.create("Type", v$8, null);
    Node v$10 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$11 = GNode.create("Type", type, null);
    Node v$12 = GNode.create("TypeArguments", v$11);
    Node v$13 = GNode.create("TypeInstantiation", "Union", v$12);
    Node v$14 = GNode.create("InstantiatedType", v$10, v$13);
    Node v$15 = GNode.create("Arguments", false);
    Node v$16 = GNode.create("NewClassExpression", null, null, v$14, v$15, 
      null);
    Node v$17 = GNode.create("Declarator", name, null, v$16);
    Node v$18 = GNode.create("Declarators", v$17);
    Node v$19 = GNode.create("FieldDeclaration", v$3, v$9, v$18);
    return v$19;
  }

  /**
   * Create a call expression.
   *
   * @param type The type.
   * @param args The args.
   * @return The generic node.
   */
  public Node newApplyUnion(Node type, List<Node> args) {
    Node v$1 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$2 = GNode.create("Type", type, null);
    Node v$3 = GNode.create("TypeArguments", v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Union", v$3);
    Node v$5 = GNode.create("InstantiatedType", v$1, v$4);
    Node v$6 = GNode.create("Arguments", false);
    Node v$7 = GNode.create("NewClassExpression", null, null, v$5, v$6, null);
    Node v$8 = GNode.create("Arguments", args.size()).
      addAll(args);
    Node v$9 = GNode.create("CallExpression", v$7, null, "apply", v$8);
    return v$9;
  }

  /**
   * Create a field declaration.
   *
   * @param type The type.
   * @param name The name.
   * @return The generic node.
   */
  public Node newIntersection(Node type, String name) {
    Node v$1 = GNode.create("Modifier", "static");
    Node v$2 = GNode.create("Modifier", "final");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$5 = GNode.create("Type", type, null);
    Node v$6 = GNode.create("TypeArguments", v$5);
    Node v$7 = GNode.create("TypeInstantiation", "Intersection", v$6);
    Node v$8 = GNode.create("InstantiatedType", v$4, v$7);
    Node v$9 = GNode.create("Type", v$8, null);
    Node v$10 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$11 = GNode.create("Type", type, null);
    Node v$12 = GNode.create("TypeArguments", v$11);
    Node v$13 = GNode.create("TypeInstantiation", "Intersection", v$12);
    Node v$14 = GNode.create("InstantiatedType", v$10, v$13);
    Node v$15 = GNode.create("Arguments", false);
    Node v$16 = GNode.create("NewClassExpression", null, null, v$14, v$15, 
      null);
    Node v$17 = GNode.create("Declarator", name, null, v$16);
    Node v$18 = GNode.create("Declarators", v$17);
    Node v$19 = GNode.create("FieldDeclaration", v$3, v$9, v$18);
    return v$19;
  }

  /**
   * Create a call expression.
   *
   * @param type The type.
   * @param args The args.
   * @return The generic node.
   */
  public Node newApplyIntersection(Node type, List<Node> args) {
    Node v$1 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$2 = GNode.create("Type", type, null);
    Node v$3 = GNode.create("TypeArguments", v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Intersection", v$3);
    Node v$5 = GNode.create("InstantiatedType", v$1, v$4);
    Node v$6 = GNode.create("Arguments", false);
    Node v$7 = GNode.create("NewClassExpression", null, null, v$5, v$6, null);
    Node v$8 = GNode.create("Arguments", args.size()).
      addAll(args);
    Node v$9 = GNode.create("CallExpression", v$7, null, "apply", v$8);
    return v$9;
  }

  /**
   * Create a field declaration.
   *
   * @param type The type.
   * @param name The name.
   * @return The generic node.
   */
  public Node newSubtraction(Node type, String name) {
    Node v$1 = GNode.create("Modifier", "static");
    Node v$2 = GNode.create("Modifier", "final");
    Node v$3 = GNode.create("Modifiers", v$1, v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$5 = GNode.create("Type", type, null);
    Node v$6 = GNode.create("TypeArguments", v$5);
    Node v$7 = GNode.create("TypeInstantiation", "Subtraction", v$6);
    Node v$8 = GNode.create("InstantiatedType", v$4, v$7);
    Node v$9 = GNode.create("Type", v$8, null);
    Node v$10 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$11 = GNode.create("Type", type, null);
    Node v$12 = GNode.create("TypeArguments", v$11);
    Node v$13 = GNode.create("TypeInstantiation", "Subtraction", v$12);
    Node v$14 = GNode.create("InstantiatedType", v$10, v$13);
    Node v$15 = GNode.create("Arguments", false);
    Node v$16 = GNode.create("NewClassExpression", null, null, v$14, v$15, 
      null);
    Node v$17 = GNode.create("Declarator", name, null, v$16);
    Node v$18 = GNode.create("Declarators", v$17);
    Node v$19 = GNode.create("FieldDeclaration", v$3, v$9, v$18);
    return v$19;
  }

  /**
   * Create a call expression.
   *
   * @param type The type.
   * @param args The args.
   * @return The generic node.
   */
  public Node newApplySubtraction(Node type, List<Node> args) {
    Node v$1 = GNode.create("TypeInstantiation", "Primitives", null);
    Node v$2 = GNode.create("Type", type, null);
    Node v$3 = GNode.create("TypeArguments", v$2);
    Node v$4 = GNode.create("TypeInstantiation", "Subtraction", v$3);
    Node v$5 = GNode.create("InstantiatedType", v$1, v$4);
    Node v$6 = GNode.create("Arguments", false);
    Node v$7 = GNode.create("NewClassExpression", null, null, v$5, v$6, null);
    Node v$8 = GNode.create("Arguments", args.size()).
      addAll(args);
    Node v$9 = GNode.create("CallExpression", v$7, null, "apply", v$8);
    return v$9;
  }

  /**
   * Create a call expression.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node nextCall(Node argument) {
    Node v$1 = GNode.create("Arguments", false);
    Node v$2 = GNode.create("CallExpression", argument, null, "next", v$1);
    return v$2;
  }

  /**
   * Create a field declaration.
   *
   * @return The generic node.
   */
  public Node nodeTypeDecl() {
    Node v$1 = GNode.create("Modifier", "protected");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("QualifiedIdentifier", "String");
    Node v$4 = GNode.create("Type", v$3, null);
    Node v$5 = GNode.create("NullLiteral", false);
    Node v$6 = GNode.create("Declarator", "nodeType", null, v$5);
    Node v$7 = GNode.create("Declarators", v$6);
    Node v$8 = GNode.create("FieldDeclaration", v$2, v$4, v$7);
    return v$8;
  }

  /**
   * Create a call expression.
   *
   * @param argument1 The argument1.
   * @return The generic node.
   */
  public Node not(Node argument1) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "not");
    Node v$3 = GNode.create("Arguments", argument1);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create an equality expression.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node notEqualsBottom(Node argument) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", v$1, "!=", argument);
    return v$2;
  }

  /**
   * Create a call expression.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node or(Node argument1, Node argument2) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "or");
    Node v$3 = GNode.create("Arguments", argument1, argument2);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create a call expression.
   *
   * @param type The type.
   * @return The generic node.
   */
  public Node pairEmpty(Node type) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Pair");
    Node v$2 = GNode.create("Type", type, null);
    Node v$3 = GNode.create("TypeArguments", v$2);
    Node v$4 = GNode.create("Arguments", false);
    Node v$5 = GNode.create("CallExpression", v$1, v$3, "empty", v$4);
    return v$5;
  }

  /**
   * Create a conditional statement.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node processScope(Node argument) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", v$1, "!=", argument);
    Node v$3 = GNode.create("PrimaryIdentifier", "processScopeNodes");
    Node v$4 = GNode.create("Arguments", false);
    Node v$5 = GNode.create("CallExpression", argument, null, "getName", v$4);
    Node v$6 = GNode.create("Arguments", v$5);
    Node v$7 = GNode.create("CallExpression", v$3, null, "contains", v$6);
    Node v$8 = GNode.create("LogicalAndExpression", v$2, v$7);
    Node v$9 = GNode.create("PrimaryIdentifier", "getScope");
    Node v$10 = GNode.create("Arguments", argument, v$9);
    Node v$11 = GNode.create("CallExpression", null, null, "processScope", 
      v$10);
    Node v$12 = GNode.create("ExpressionStatement", v$11);
    Node v$13 = GNode.create("Block", v$12);
    Node v$14 = GNode.create("ConditionalStatement", v$8, v$13, null);
    return v$14;
  }

  /**
   * Create a field declaration.
   *
   * @param type The type.
   * @param name The name.
   * @return The generic node.
   */
  public Node publicFieldDecl(Node type, String name) {
    Node v$1 = GNode.create("Modifier", "public");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("Type", type, null);
    Node v$4 = GNode.create("Declarator", name, null, null);
    Node v$5 = GNode.create("Declarators", v$4);
    Node v$6 = GNode.create("FieldDeclaration", v$2, v$3, v$5);
    return v$6;
  }

  /**
   * Create a field declaration.
   *
   * @return The generic node.
   */
  public Node recordFieldEqual() {
    Node v$1 = GNode.create("Modifiers", false);
    Node v$2 = GNode.create("QualifiedIdentifier", "type");
    Node v$3 = GNode.create("Type", v$2, null);
    Node v$4 = GNode.create("QualifiedIdentifier", "type");
    Node v$5 = GNode.create("Type", v$4, null);
    Node v$6 = GNode.create("PrimaryIdentifier", "o");
    Node v$7 = GNode.create("CastExpression", v$5, v$6);
    Node v$8 = GNode.create("Declarator", "other", null, v$7);
    Node v$9 = GNode.create("Declarators", v$8);
    Node v$10 = GNode.create("FieldDeclaration", v$1, v$3, v$9);
    return v$10;
  }

  /**
   * Create a field declaration.
   *
   * @return The generic node.
   */
  public Node recordEqualReturn() {
    Node v$1 = GNode.create("Modifiers", false);
    Node v$2 = GNode.create("PrimitiveType", "boolean");
    Node v$3 = GNode.create("Type", v$2, null);
    Node v$4 = GNode.create("BooleanLiteral", "true");
    Node v$5 = GNode.create("Declarator", "res", null, v$4);
    Node v$6 = GNode.create("Declarators", v$5);
    Node v$7 = GNode.create("FieldDeclaration", v$1, v$3, v$6);
    return v$7;
  }

  /**
   * Create a call expression.
   *
   * @param arg1 The arg1.
   * @param arg2 The arg2.
   * @param initStatements The initStatements.
   * @return The generic node.
   */
  public Node reduceExpression(Node arg1, Node arg2, List<Node> initStatements) {
    Node v$1 = GNode.create("QualifiedIdentifier", "Reduction");
    Node v$2 = GNode.create("PrimaryIdentifier", "matching_nodes");
    Node v$3 = GNode.create("PrimaryIdentifier", "matching_nodes");
    Node v$4 = GNode.create("Arguments", false);
    Node v$5 = GNode.create("CallExpression", v$3, null, "size", v$4);
    Node v$6 = GNode.create("IntegerLiteral", "1");
    Node v$7 = GNode.create("AdditiveExpression", v$5, "-", v$6);
    Node v$8 = GNode.create("Arguments", v$7);
    Node v$9 = GNode.create("CallExpression", v$2, null, "get", v$8);
    Node v$10 = GNode.create("Arguments", arg1, arg2, v$9);
    Node v$11 = GNode.create("Block", initStatements.size()).
      addAll(initStatements);
    Node v$12 = GNode.create("BlockDeclaration", null, v$11);
    Node v$13 = GNode.create("ClassBody", v$12);
    Node v$14 = GNode.create("NewClassExpression", null, null, v$1, v$10, 
      v$13);
    Node v$15 = GNode.create("Arguments", false);
    Node v$16 = GNode.create("CallExpression", v$14, null, "apply", v$15);
    return v$16;
  }

  /**
   * Create an expression statement.
   *
   * @return The generic node.
   */
  public Node reduceReq() {
    Node v$1 = GNode.create("Arguments", false);
    Node v$2 = GNode.create("CallExpression", null, null, "setReq", v$1);
    Node v$3 = GNode.create("ExpressionStatement", v$2);
    return v$3;
  }

  /**
   * Create an expression statement.
   *
   * @return The generic node.
   */
  public Node reduceSing() {
    Node v$1 = GNode.create("Arguments", false);
    Node v$2 = GNode.create("CallExpression", null, null, "setSing", v$1);
    Node v$3 = GNode.create("ExpressionStatement", v$2);
    return v$3;
  }

  /**
   * Create an expression statement.
   *
   * @return The generic node.
   */
  public Node reduceOpt() {
    Node v$1 = GNode.create("Arguments", false);
    Node v$2 = GNode.create("CallExpression", null, null, "setOpt", v$1);
    Node v$3 = GNode.create("ExpressionStatement", v$2);
    return v$3;
  }

  /**
   * Create an expression statement.
   *
   * @return The generic node.
   */
  public Node reduceList() {
    Node v$1 = GNode.create("Arguments", false);
    Node v$2 = GNode.create("CallExpression", null, null, "setList", v$1);
    Node v$3 = GNode.create("ExpressionStatement", v$2);
    return v$3;
  }

  /**
   * Create an expression statement.
   *
   * @return The generic node.
   */
  public Node reduceSet() {
    Node v$1 = GNode.create("Arguments", false);
    Node v$2 = GNode.create("CallExpression", null, null, "setSet", v$1);
    Node v$3 = GNode.create("ExpressionStatement", v$2);
    return v$3;
  }

  /**
   * Create an expression statement.
   *
   * @return The generic node.
   */
  public Node reduceDup() {
    Node v$1 = GNode.create("Arguments", false);
    Node v$2 = GNode.create("CallExpression", null, null, "setDup", v$1);
    Node v$3 = GNode.create("ExpressionStatement", v$2);
    return v$3;
  }

  /**
   * Create an expression statement.
   *
   * @return The generic node.
   */
  public Node reduceNodup() {
    Node v$1 = GNode.create("Arguments", false);
    Node v$2 = GNode.create("CallExpression", null, null, "setNodup", v$1);
    Node v$3 = GNode.create("ExpressionStatement", v$2);
    return v$3;
  }

  /**
   * Create an expression statement.
   *
   * @param arg The arg.
   * @return The generic node.
   */
  public Node reduceTag(Node arg) {
    Node v$1 = GNode.create("Arguments", arg);
    Node v$2 = GNode.create("CallExpression", null, null, "setTag", v$1);
    Node v$3 = GNode.create("ExpressionStatement", v$2);
    return v$3;
  }

  /**
   * Create an expression statement.
   *
   * @param set The set.
   * @return The generic node.
   */
  public Node reduceSet(Node set) {
    Node v$1 = GNode.create("Arguments", set);
    Node v$2 = GNode.create("CallExpression", null, null, "setSet", v$1);
    Node v$3 = GNode.create("ExpressionStatement", v$2);
    return v$3;
  }

  /**
   * Create an expression statement.
   *
   * @param patterns The patterns.
   * @return The generic node.
   */
  public Node reduceAddPatterns(List<Node> patterns) {
    Node v$1 = GNode.create("Arguments", patterns.size()).
      addAll(patterns);
    Node v$2 = GNode.create("CallExpression", null, null, "addPattern", v$1);
    Node v$3 = GNode.create("ExpressionStatement", v$2);
    return v$3;
  }

  /**
   * Create a field declaration.
   *
   * @param name The name.
   * @param arg The arg.
   * @return The generic node.
   */
  public Node reduceGetMatch(String name, Node arg) {
    Node v$1 = GNode.create("Modifiers", false);
    Node v$2 = GNode.create("QualifiedIdentifier", "Node");
    Node v$3 = GNode.create("Type", v$2, null);
    Node v$4 = GNode.create("Arguments", arg);
    Node v$5 = GNode.create("CallExpression", null, null, "getMatch", v$4);
    Node v$6 = GNode.create("Declarator", name, null, v$5);
    Node v$7 = GNode.create("Declarators", v$6);
    Node v$8 = GNode.create("FieldDeclaration", v$1, v$3, v$7);
    return v$8;
  }

  /**
   * Create a call expression.
   *
   * @param name The name.
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node relationalExpr(Node name, Node argument1, Node argument2) {
    Node v$1 = GNode.create("Arguments", argument1, argument2);
    Node v$2 = GNode.create("CallExpression", name, null, "apply", v$1);
    return v$2;
  }

  /**
   * Create a call expression.
   *
   * @param type The type.
   * @param instructions The instructions.
   * @return The generic node.
   */
  public Node requireExpression(Node type, List<Node> instructions) {
    Node v$1 = GNode.create("Type", type, null);
    Node v$2 = GNode.create("TypeArguments", v$1);
    Node v$3 = GNode.create("TypeInstantiation", "Require", v$2);
    Node v$4 = GNode.create("InstantiatedType", v$3);
    Node v$5 = GNode.create("Arguments", false);
    Node v$6 = GNode.create("Modifier", "public");
    Node v$7 = GNode.create("Modifiers", v$6);
    Node v$8 = GNode.create("Type", type, null);
    Node v$9 = GNode.create("FormalParameters", false);
    Node v$10 = GNode.create("Block", instructions.size()).
      addAll(instructions);
    Node v$11 = GNode.create("MethodDeclaration", v$7, null, v$8, "apply", 
      v$9, null, null, v$10);
    Node v$12 = GNode.create("ClassBody", v$11);
    Node v$13 = GNode.create("NewClassExpression", null, null, v$4, v$5, 
      v$12);
    Node v$14 = GNode.create("Arguments", false);
    Node v$15 = GNode.create("CallExpression", v$13, null, "apply", v$14);
    return v$15;
  }

  /**
   * Create a return statement.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node ret(Node argument) {
    Node v$1 = GNode.create("ReturnStatement", argument);
    return v$1;
  }

  /**
   * Create a return statement.
   *
   * @return The generic node.
   */
  public Node returnBottom() {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("ReturnStatement", v$1);
    return v$2;
  }

  /**
   * Create a method declaration.
   *
   * @param statments The statments.
   * @return The generic node.
   */
  public Node setMethod(List<Node> statments) {
    Node v$1 = GNode.create("Modifiers", false);
    Node v$2 = GNode.create("VoidType", false);
    Node v$3 = GNode.create("FormalParameters", false);
    Node v$4 = GNode.create("Block", statments.size()).
      addAll(statments);
    Node v$5 = GNode.create("MethodDeclaration", v$1, null, v$2, "set", v$3, 
      null, null, v$4);
    return v$5;
  }

  /**
   * Create a method declaration.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node sizeMethod(Node argument) {
    Node v$1 = GNode.create("Modifier", "public");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("PrimitiveType", "int");
    Node v$4 = GNode.create("Type", v$3, null);
    Node v$5 = GNode.create("FormalParameters", false);
    Node v$6 = GNode.create("ReturnStatement", argument);
    Node v$7 = GNode.create("Block", v$6);
    Node v$8 = GNode.create("MethodDeclaration", v$2, null, v$4, "size", v$5, 
      null, null, v$7);
    return v$8;
  }

  /**
   * Create a relational expression.
   *
   * @param argument The argument.
   * @param value The value.
   * @return The generic node.
   */
  public Node sizeGreater(Node argument, Node value) {
    Node v$1 = GNode.create("Arguments", false);
    Node v$2 = GNode.create("CallExpression", argument, null, "size", v$1);
    Node v$3 = GNode.create("RelationalExpression", v$2, ">", value);
    return v$3;
  }

  /**
   * Create a relational expression.
   *
   * @param argument The argument.
   * @param value The value.
   * @return The generic node.
   */
  public Node sizeGreaterEqual(Node argument, Node value) {
    Node v$1 = GNode.create("Arguments", false);
    Node v$2 = GNode.create("CallExpression", argument, null, "size", v$1);
    Node v$3 = GNode.create("RelationalExpression", v$2, ">=", value);
    return v$3;
  }

  /**
   * Create a relational expression.
   *
   * @param argument The argument.
   * @param value The value.
   * @return The generic node.
   */
  public Node sizeLess(Node argument, Node value) {
    Node v$1 = GNode.create("Arguments", false);
    Node v$2 = GNode.create("CallExpression", argument, null, "size", v$1);
    Node v$3 = GNode.create("RelationalExpression", v$2, "<", value);
    return v$3;
  }

  /**
   * Create an equality expression.
   *
   * @param argument The argument.
   * @param value The value.
   * @return The generic node.
   */
  public Node sizeEqual(Node argument, Node value) {
    Node v$1 = GNode.create("Arguments", false);
    Node v$2 = GNode.create("CallExpression", argument, null, "size", v$1);
    Node v$3 = GNode.create("EqualityExpression", v$2, "==", value);
    return v$3;
  }

  /**
   * Create a field declaration.
   *
   * @param listName The listName.
   * @return The generic node.
   */
  public Node spOffspringList(String listName) {
    Node v$1 = GNode.create("Modifiers", false);
    Node v$2 = GNode.create("QualifiedIdentifier", "Node");
    Node v$3 = GNode.create("Type", v$2, null);
    Node v$4 = GNode.create("TypeArguments", v$3);
    Node v$5 = GNode.create("TypeInstantiation", "List", v$4);
    Node v$6 = GNode.create("InstantiatedType", v$5);
    Node v$7 = GNode.create("Type", v$6, null);
    Node v$8 = GNode.create("QualifiedIdentifier", "Node");
    Node v$9 = GNode.create("Type", v$8, null);
    Node v$10 = GNode.create("TypeArguments", v$9);
    Node v$11 = GNode.create("TypeInstantiation", "ArrayList", v$10);
    Node v$12 = GNode.create("InstantiatedType", v$11);
    Node v$13 = GNode.create("Arguments", false);
    Node v$14 = GNode.create("NewClassExpression", null, null, v$12, v$13, 
      null);
    Node v$15 = GNode.create("Declarator", listName, null, v$14);
    Node v$16 = GNode.create("Declarators", v$15);
    Node v$17 = GNode.create("FieldDeclaration", v$1, v$7, v$16);
    return v$17;
  }

  /**
   * Create a field declaration.
   *
   * @param nodeName The nodeName.
   * @param param The param.
   * @return The generic node.
   */
  public Node spRunNode(String nodeName, Node param) {
    Node v$1 = GNode.create("Modifiers", false);
    Node v$2 = GNode.create("QualifiedIdentifier", "Node");
    Node v$3 = GNode.create("Type", v$2, null);
    Node v$4 = GNode.create("Declarator", nodeName, null, param);
    Node v$5 = GNode.create("Declarators", v$4);
    Node v$6 = GNode.create("FieldDeclaration", v$1, v$3, v$5);
    return v$6;
  }

  /**
   * Create an expression statement.
   *
   * @param nodeName The nodeName.
   * @param index The index.
   * @return The generic node.
   */
  public Node spGetGeneric(Node nodeName, Node index) {
    Node v$1 = GNode.create("Arguments", index);
    Node v$2 = GNode.create("CallExpression", nodeName, null, "getGeneric", 
      v$1);
    Node v$3 = GNode.create("Expression", nodeName, "=", v$2);
    Node v$4 = GNode.create("ExpressionStatement", v$3);
    return v$4;
  }

  /**
   * Create an expression statement.
   *
   * @param listName The listName.
   * @param nodeName The nodeName.
   * @return The generic node.
   */
  public Node spOffspringListAdd(Node listName, Node nodeName) {
    Node v$1 = GNode.create("IntegerLiteral", "0");
    Node v$2 = GNode.create("Arguments", v$1, nodeName);
    Node v$3 = GNode.create("CallExpression", listName, null, "add", v$2);
    Node v$4 = GNode.create("ExpressionStatement", v$3);
    return v$4;
  }

  /**
   * Create a for statement.
   *
   * @param listName The listName.
   * @return The generic node.
   */
  public Node spForLoop(Node listName) {
    Node v$1 = GNode.create("Modifiers", false);
    Node v$2 = GNode.create("QualifiedIdentifier", "Node");
    Node v$3 = GNode.create("Type", v$2, null);
    Node v$4 = GNode.create("EnhancedForControl", v$1, v$3, "no", listName);
    Node v$5 = GNode.create("PrimaryIdentifier", "no");
    Node v$6 = GNode.create("Arguments", v$5);
    Node v$7 = GNode.create("CallExpression", null, null, "checkExitScope", 
      v$6);
    Node v$8 = GNode.create("ExpressionStatement", v$7);
    Node v$9 = GNode.create("Block", v$8);
    Node v$10 = GNode.create("ForStatement", v$4, v$9);
    return v$10;
  }

  /**
   * Create a field declaration.
   *
   * @param name The name.
   * @param value The value.
   * @return The generic node.
   */
  public Node storeValue(String name, Node value) {
    Node v$1 = GNode.create("Modifier", "final");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("QualifiedIdentifier", "Object");
    Node v$4 = GNode.create("Type", v$3, null);
    Node v$5 = GNode.create("Declarator", name, null, value);
    Node v$6 = GNode.create("Declarators", v$5);
    Node v$7 = GNode.create("FieldDeclaration", v$2, v$4, v$6);
    return v$7;
  }

  /**
   * Create a field declaration.
   *
   * @param type The type.
   * @param value The value.
   * @return The generic node.
   */
  public Node staticFieldDecl(Node type, Node value) {
    Node v$1 = GNode.create("Modifier", "final");
    Node v$2 = GNode.create("Modifier", "static");
    Node v$3 = GNode.create("Modifier", "protected");
    Node v$4 = GNode.create("Modifiers", v$1, v$2, v$3);
    Node v$5 = GNode.create("Type", type, null);
    Node v$6 = GNode.create("Declarator", "name", null, value);
    Node v$7 = GNode.create("Declarators", v$6);
    Node v$8 = GNode.create("FieldDeclaration", v$4, v$5, v$7);
    return v$8;
  }

  /**
   * Create a call expression.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node subtractInt(Node argument1, Node argument2) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "subtractInt");
    Node v$3 = GNode.create("Arguments", argument1, argument2);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create a call expression.
   *
   * @param argument1 The argument1.
   * @param argument2 The argument2.
   * @return The generic node.
   */
  public Node subtractFloat64(Node argument1, Node argument2) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "subtractFloat64");
    Node v$3 = GNode.create("Arguments", argument1, argument2);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create a selection expression.
   *
   * @param support The support.
   * @param arg The arg.
   * @return The generic node.
   */
  public Node support(Node support, String arg) {
    Node v$1 = GNode.create("SelectionExpression", support, arg);
    return v$1;
  }

  /**
   * Create a field declaration.
   *
   * @param arg The arg.
   * @param value The value.
   * @return The generic node.
   */
  public Node supportNodeMatch(String arg, Node value) {
    Node v$1 = GNode.create("Modifier", "public");
    Node v$2 = GNode.create("Modifier", "static");
    Node v$3 = GNode.create("Modifier", "final");
    Node v$4 = GNode.create("Modifiers", v$1, v$2, v$3);
    Node v$5 = GNode.create("QualifiedIdentifier", "Analyzer", "NodeMatch");
    Node v$6 = GNode.create("Type", v$5, null);
    Node v$7 = GNode.create("Declarator", arg, null, value);
    Node v$8 = GNode.create("Declarators", v$7);
    Node v$9 = GNode.create("FieldDeclaration", v$4, v$6, v$8);
    return v$9;
  }

  /**
   * Create a switch statement.
   *
   * @param arg The arg.
   * @return The generic node.
   */
  public Node switchStmnt(Node arg) {
    Node v$1 = GNode.create("Arguments", false);
    Node v$2 = GNode.create("CallExpression", arg, null, "tag", v$1);
    Node v$3 = GNode.create("SwitchStatement", v$2);
    return v$3;
  }

  /**
   * Create a conditional statement.
   *
   * @param arg The arg.
   * @param action The action.
   * @return The generic node.
   */
  public Node switchWrap(Node arg, Node action) {
    Node v$1 = GNode.create("NullLiteral", false);
    Node v$2 = GNode.create("EqualityExpression", v$1, "!=", arg);
    Node v$3 = GNode.create("ExpressionStatement", action);
    Node v$4 = GNode.create("ConditionalStatement", v$2, v$3, null);
    return v$4;
  }

  /**
   * Create a switch statement.
   *
   * @param c The c.
   * @param action The action.
   * @return The generic node.
   */
  public Node caseStmnt(Node c, List<Node> action) {
    Node v$1 = GNode.create("PrimaryIdentifier", "blah");
    Node v$2 = GNode.create("BreakStatement", null);
    Node v$3 = GNode.create("CaseClause", action.size() + 2).
      add(c).addAll(action).add(v$2);
    Node v$4 = GNode.create("SwitchStatement", v$1, v$3);
    return v$4;
  }

  /**
   * Create a call expression.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node tail(Node argument) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("SelectionExpression", v$1, "tail");
    Node v$3 = GNode.create("Arguments", argument);
    Node v$4 = GNode.create("CallExpression", v$2, null, "apply", v$3);
    return v$4;
  }

  /**
   * Create a call expression.
   *
   * @param argument The argument.
   * @return The generic node.
   */
  public Node tailWrapper(Node argument) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("Arguments", argument);
    Node v$3 = GNode.create("CallExpression", v$1, null, "wrapTail", v$2);
    return v$3;
  }

  /**
   * Create a selection expression.
   *
   * @param tail The tail.
   * @return The generic node.
   */
  public Node thisExpr(String tail) {
    Node v$1 = GNode.create("ThisExpression", null);
    Node v$2 = GNode.create("SelectionExpression", v$1, tail);
    return v$2;
  }

  /**
   * Create a method declaration.
   *
   * @return The generic node.
   */
  public Node toStringMethod() {
    Node v$1 = GNode.create("Modifier", "public");
    Node v$2 = GNode.create("Modifiers", v$1);
    Node v$3 = GNode.create("QualifiedIdentifier", "String");
    Node v$4 = GNode.create("Type", v$3, null);
    Node v$5 = GNode.create("FormalParameters", false);
    Node v$6 = GNode.create("Modifiers", false);
    Node v$7 = GNode.create("QualifiedIdentifier", "String");
    Node v$8 = GNode.create("Type", v$7, null);
    Node v$9 = GNode.create("Declarator", "string", null, null);
    Node v$10 = GNode.create("Declarators", v$9);
    Node v$11 = GNode.create("FieldDeclaration", v$6, v$8, v$10);
    Node v$12 = GNode.create("Block", v$11);
    Node v$13 = GNode.create("MethodDeclaration", v$2, null, v$4, "toString", 
      v$5, null, null, v$12);
    return v$13;
  }

  /**
   * Create a call expression.
   *
   * @param first The first.
   * @param second The second.
   * @return The generic node.
   */
  public Node unionWrapper(Node first, Node second) {
    Node v$1 = GNode.create("PrimaryIdentifier", "Primitives");
    Node v$2 = GNode.create("Arguments", first, second);
    Node v$3 = GNode.create("CallExpression", v$1, null, "wrapUnion", v$2);
    return v$3;
  }

}
