All Downloads are FREE. Search and download functionalities are using the official Maven repository.

yale.compiler.debugger.0.9.0.source-code.AS3DebuggerBURM Maven / Gradle / Ivy


/*  Generated Thu Jan 18 13:12:12 PST 2018 by JBurg version Set in build.properties */

package flash.tools.debugger.expression;


	/*
    
      Licensed to the Apache Software Foundation (ASF) under one or more
      contributor license agreements.  See the NOTICE file distributed with
      this work for additional information regarding copyright ownership.
      The ASF licenses this file to You under the Apache License, Version 2.0
      (the "License"); you may not use this file except in compliance with
      the License.  You may obtain a copy of the License at
    
          http://www.apache.org/licenses/LICENSE-2.0
    
      Unless required by applicable law or agreed to in writing, software
      distributed under the License is distributed on an "AS IS" BASIS,
      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
      See the License for the specific language governing permissions and
      limitations under the License.

		AS3DebuggerBURM.java is a Bottom-Up Rewrite Machine for ActionScript 3.0.

		A BURM recognizes patterns of nodes within an tree (in this case, an
		abstract syntax tree for AS 3.0 expressions) and performs rule-based reduction
		on them (in this case producing DebuggerValues).

		AS3DebuggerBURM.java is generated from AS3DebuggerBURM.jbg using JBurg, an open-source
		Java implementation of a Bottom-Up Rewrite Generator.

		The most important entry point of this class is burm(),
		which is called by the code generator.
	*/

    import static org.apache.royale.abc.ABCConstants.*;
    import static org.apache.royale.compiler.tree.ASTNodeID.*;

    import org.apache.royale.compiler.constants.IASLanguageConstants;
    import org.apache.royale.compiler.exceptions.BURMAbortException;
    import org.apache.royale.compiler.problems.*;
    import org.apache.royale.compiler.internal.semantics.SemanticUtils;
    import org.apache.royale.compiler.tree.ASTNodeID;
    import org.apache.royale.compiler.tree.as.IASNode;
    import org.apache.royale.compiler.tree.as.ITryNode;
public class AS3DebuggerBURM
	
{
	java.util.Stack __reducedValues = new java.util.Stack();

    final static boolean NEED_VALUE = true;
    final static boolean DISCARD_VALUE = false;


    /**
     *  The reducer has all the implementation
     *  logic for the rewrite; the BURM constructed
     *  by this specification drives that logic.
     */
    AS3DebuggerReducer reducer;


    /*
     *  **  Cost functions  **
     * Cost functions are Java code that returns an int value.
     * The value is used to compute the cost of a particular
     * candidate reduction. The BURM searches for the lowest
     * total cost sequence of reductions to transform the input
     * AST into a value, so low values mean "good cost," higher
     * values mean "less desirable."   The total cost of a reduction
     * is always strictly less than Integer.MAX_VALUE; a cost of
     * Integer.MAX_VALUE tells the pattern matcher that the
     * reduction is not feasible.
     */


    /**
     *  @return "feasible" if the reducer can reduce this to a dotted name.
     */
    int isDottedName(IASNode iNode)
    {
       return reducer.isDottedName(iNode);
    }

    /**
     *  @return "feasible" if the reducer can reduce this to a package name.
     */
    int isPackageName(IASNode iNode)
    {
       return reducer.isPackageName(iNode);
    }

    /**
     *  @return "feasible" if this node's qualifier is a compile-time constant.
     */
    int qualifierIsCompileTimeConstant(IASNode iNode)
    {
       return reducer.qualifierIsCompileTimeConstant(iNode);
    }

    /**
     *  @return "feasible" if this node can be resolved to a compile-time constant.
     */
    int isCompileTimeConstant(IASNode iNode)
    {
       return reducer.isCompileTimeConstant(iNode);
    }

    /**
     *  @return "feasible" if this function call node can be resolved to a compile-time constant function.
     */
    int isCompileTimeConstantFunction(IASNode iNode)
    {
       return reducer.isCompileTimeConstantFunction(iNode);
    }

    /**
     *  @return "feasible" if this binary node has at least one expression that is
     *          of type "float".
     */
    int isFloatBinOp(IASNode iNode)
    {
       return reducer.isFloatBinOp(iNode);
    }

    /**
     *  @return "feasible" if this node is for 'new Array()'.
     */
    int isEmptyArrayConstructor(IASNode iNode)
    {
        return reducer.isEmptyArrayConstructor(iNode);
    }

    /**
     *  @return "feasible" if this node is for 'new Object()'.
     */
    int isEmptyObjectConstructor(IASNode iNode)
    {
        return reducer.isEmptyObjectConstructor(iNode);
    }

    /**
     * @return "feasible" if this node resolves to a type definition.
     */
    int isKnownType(IASNode iNode)
    {
        return reducer.isKnownType(iNode);
    }

    /**
     * @return "feasible" if the type parameter resolves to a type definition.
     */
    int parameterTypeIsConstant(IASNode iNode)
    {
        return reducer.parameterTypeIsConstant(iNode);
    }

    /**
     *  recordError is a convenience method for error reductions;
     *  it adds a problem to the current set of problems and
     */
    Object recordError(ICompilerProblem problem)
    {
        return new Object();
    }

    int isIntLiteral(IASNode iNode)
    {
        return reducer.isIntLiteral(iNode);
    }

    int isUintLiteral(IASNode iNode)
    {
        return reducer.isUintLiteral(iNode);
    }

    int isDoubleLiteral(IASNode iNode)
    {
        return reducer.isDoubleLiteral(iNode);
    }

    int isFloatLiteral(IASNode iNode)
    {
        return reducer.isDoubleLiteral(iNode);
    }


	
	public static final int __non_resolving_identifier_NT = 1;
	public static final int __float_constant_NT = 2;
	public static final int __type_name_NT = 3;
	public static final int __integer_constant_NT = 4;
	public static final int __boolean_literal_NT = 5;
	public static final int __literal_NT = 6;
	public static final int __decl_name_NT = 7;
	public static final int __runtime_name_expression_NT = 8;
	public static final int __double_constant_NT = 9;
	public static final int __object_literal_NT = 10;
	public static final int __boolean_constant_NT = 11;
	public static final int __foldedExpression_NT = 12;
	public static final int __expression_NT = 13;
	public static final int __numeric_constant_NT = 14;
	public static final int __type_param_expression_NT = 15;
	public static final int __required_constant_value_NT = 16;
	public static final int __object_literal_element_NT = 17;
	public static final int __void_expression_NT = 18;
	public static final int __comparison_expression_NT = 19;
	public static final int __constant_value_NT = 20;
	public static final int __e4x_literal_NT = 21;
	public static final int __vector_literal_NT = 22;
	public static final int __new_type_name_NT = 23;
	public static final int __qualifiedNamePart_NT = 24;
	public static final int __string_constant_NT = 25;
	public static final int __name_NT = 26;
	public static final int __dottedNamePart_NT = 27;
	public static final int __array_literal_NT = 28;
	public static final int __uint_constant_NT = 29;
	public static final int nStates = 29;

	private static final JBurgSubgoal[][] ___subgoals_by_rule = 
	{
		null,
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		{
			new JBurgSubgoal(__expression_NT,true,0,0),
		},
		{
			new JBurgSubgoal(__expression_NT,true,0,0),
		},
		{
			new JBurgSubgoal(__e4x_literal_NT,true,0,0),
		},
		null,
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,true,0,0),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1,0),
			new JBurgSubgoal(__name_NT,false,0,0,1,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__runtime_name_expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__runtime_name_expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		null,
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__void_expression_NT,true,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__runtime_name_expression_NT,false,0,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__name_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__dottedNamePart_NT,false,0,0),
			new JBurgSubgoal(__dottedNamePart_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__dottedNamePart_NT,false,0,0),
			new JBurgSubgoal(__dottedNamePart_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__dottedNamePart_NT,false,0,0),
			new JBurgSubgoal(__dottedNamePart_NT,false,0,1),
		},
		null,
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		null,
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		null,
		{
			new JBurgSubgoal(__dottedNamePart_NT,false,0,0),
			new JBurgSubgoal(__dottedNamePart_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__dottedNamePart_NT,false,0,0),
			new JBurgSubgoal(__dottedNamePart_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,true,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,true,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,true,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,true,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0,1,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,true,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0,1),
			new JBurgSubgoal(__expression_NT,true,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,true,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__foldedExpression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__foldedExpression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__name_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,1),
		},
		null,
		null,
		{
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__name_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,1),
			new JBurgSubgoal(__expression_NT,true,0,2),
		},
		{
			new JBurgSubgoal(__new_type_name_NT,false,0,1),
			new JBurgSubgoal(__expression_NT,true,0,2),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,1,0),
			new JBurgSubgoal(__name_NT,false,0,1,1),
			new JBurgSubgoal(__expression_NT,true,0,2),
		},
		{
			new JBurgSubgoal(__vector_literal_NT,false,0,1),
		},
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		{
			new JBurgSubgoal(__object_literal_element_NT,true,0,0),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
			new JBurgSubgoal(__type_name_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__type_param_expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__expression_NT,false,0,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0,0),
			new JBurgSubgoal(__name_NT,false,0,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__name_NT,false,0,1,0,0),
			new JBurgSubgoal(__name_NT,false,0,1,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__name_NT,false,0,1,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__name_NT,false,0,1,0,0),
			new JBurgSubgoal(__name_NT,false,0,1,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__name_NT,false,0,1,0),
			new JBurgSubgoal(__name_NT,false,0,1,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__name_NT,false,0,1,0),
			new JBurgSubgoal(__expression_NT,false,0,1,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__name_NT,false,0,1,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__name_NT,false,0,1,0),
			new JBurgSubgoal(__name_NT,false,0,1,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__name_NT,false,0,1,0),
			new JBurgSubgoal(__expression_NT,false,0,1,1),
		},
		{
			new JBurgSubgoal(__dottedNamePart_NT,false,0,0),
			new JBurgSubgoal(__dottedNamePart_NT,false,0,1),
		},
		null,
		{
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
		},
		null,
		null,
		null,
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		null,
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1),
			new JBurgSubgoal(__expression_NT,false,0,2),
		},
		{
			new JBurgSubgoal(__decl_name_NT,false,0,0,0),
			new JBurgSubgoal(__type_name_NT,false,0,0,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
		},
		{
			new JBurgSubgoal(__name_NT,false,0,0),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1,1),
		},
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,false,0,1,1),
		},
		{
			new JBurgSubgoal(__type_name_NT,false,0,0),
			new JBurgSubgoal(__expression_NT,true,0,1),
		},
		null,
		null,
		null,
		{
			new JBurgSubgoal(__constant_value_NT,false,0,0),
		},
		null,
		{
			new JBurgSubgoal(__expression_NT,false,0,0),
		},
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
		null,
	};


	public static final int ERROR_TRAP = 268435456;
	
	public JBurgAnnotation label( IASNode to_be_labelled)
	{
		JBurgAnnotation result = null;

		int i;

		int arity;

		result = this.getJBurgAnnotation(to_be_labelled);
		arity = SemanticUtils.getChildCount(to_be_labelled);
		i = 0;
		while ( ( arity > i ) )
		{
			result.addChild(this.label(((IASNode)SemanticUtils.getNthChild(to_be_labelled, i))));
			i =  (i + 1) ;
		}
		return(result);
	}

	/* expression = Op_AssignId(expression, expression) */
	
	private Object action_1( IASNode __p) throws java.lang.Exception
	{
		Object rvalue = (Object)__reducedValues.pop();
		Object non_lvalue = (Object)__reducedValues.pop();
		return reducer.error_reduce_Op_AssignId(__p,non_lvalue,rvalue);
	}

	/* type_name = name { ... } */
	
	private Object action_2( IASNode __p) throws java.lang.Exception
	{
		Object name = (Object)__reducedValues.pop();
		return reducer.reduce_nameToTypeName(name,true);
	}

	/* new_type_name = type_name { ... } */
	
	private Object action_3( IASNode __p) throws java.lang.Exception
	{
		Object type_name = (Object)__reducedValues.pop();
		return reducer.reduce_nameToTypeName(type_name,false);
	}

	/* type_param_expression = name { ... } */
	
	private Object action_4( IASNode __p) throws java.lang.Exception
	{
		Object name = (Object)__reducedValues.pop();
		return reducer.reduce_typeNameParameterAsType(__p,name);
	}

	/* expression = name { ... } */
	
	private Object action_5( IASNode __p) throws java.lang.Exception
	{
		Object name = (Object)__reducedValues.pop();
		return reducer.transform_name_to_expression(__p,name);
	}

	/* expression = runtime_name_expression { ... } */
	
	private Object action_6( IASNode __p) throws java.lang.Exception
	{
		Object runtime_name_expression = (Object)__reducedValues.pop();
		return reducer.transform_runtime_name_expression(__p,runtime_name_expression);
	}

	/* expression = string_constant { ... } */
	
	private Object action_7( IASNode __p) throws java.lang.Exception
	{
		String string_constant = (String)__reducedValues.pop();
		return reducer.transform_string_constant(__p,string_constant);
	}

	/* expression = integer_constant { ... } */
	
	private Object action_8( IASNode __p) throws java.lang.Exception
	{
		Integer integer_constant = (Integer)__reducedValues.pop();
		return reducer.transform_integer_constant(__p,integer_constant);
	}

	/* expression = uint_constant { ... } */
	
	private Object action_9( IASNode __p) throws java.lang.Exception
	{
		Long uint_constant = (Long)__reducedValues.pop();
		return reducer.transform_uint_constant(__p,uint_constant);
	}

	/* expression = boolean_constant { ... } */
	
	private Object action_10( IASNode __p) throws java.lang.Exception
	{
		Boolean boolean_constant = (Boolean)__reducedValues.pop();
		return reducer.transform_boolean_constant(__p,boolean_constant);
	}

	/* required_constant_value = expression { ... } */
	
	private Object action_11( IASNode __p) throws java.lang.Exception
	{
		Object expression = (Object)__reducedValues.pop();
		return reducer.transform_expression_to_constant_value(__p,expression);
	}

	/* integer_constant = LiteralIntegerZeroID(void) */
	
	private Integer action_12( IASNode __p) throws java.lang.Exception
	{
		return reducer.getIntegerZeroContent(__p);
	}

	/* integer_constant = LiteralIntegerID(void) */
	
	private Integer action_13( IASNode __p) throws java.lang.Exception
	{
		return reducer.getIntegerContent(__p);
	}

	/* uint_constant = LiteralIntegerZeroID(void) */
	
	private Long action_14( IASNode __p) throws java.lang.Exception
	{
		return reducer.getIntegerZeroContentAsLong(__p);
	}

	/* constant_value = string_constant { ... } */
	
	private Object action_15( IASNode __p) throws java.lang.Exception
	{
		String string_constant = (String)__reducedValues.pop();
		return reducer.transform_string_constant_to_constant(__p,string_constant);
	}

	/* constant_value = boolean_constant { ... } */
	
	private Object action_16( IASNode __p) throws java.lang.Exception
	{
		Boolean boolean_constant = (Boolean)__reducedValues.pop();
		return reducer.transform_boolean_constant_to_constant(__p,boolean_constant);
	}

	/* constant_value = numeric_constant { ... } */
	
	private Object action_17( IASNode __p) throws java.lang.Exception
	{
		Number numeric_constant = (Number)__reducedValues.pop();
		return reducer.transform_numeric_constant_to_constant(__p,numeric_constant);
	}

	/* expression = double_constant { ... } */
	
	private Object action_18( IASNode __p) throws java.lang.Exception
	{
		Double double_constant = (Double)__reducedValues.pop();
		return reducer.transform_double_constant(__p,double_constant);
	}

	/* expression = integer_constant { ... } */
	
	private Object action_19( IASNode __p) throws java.lang.Exception
	{
		Integer integer_constant = (Integer)__reducedValues.pop();
		return reducer.transform_integer_constant(__p,integer_constant);
	}

	/* expression = numeric_constant { ... } */
	
	private Object action_20( IASNode __p) throws java.lang.Exception
	{
		Number numeric_constant = (Number)__reducedValues.pop();
		return reducer.transform_numeric_constant(__p,numeric_constant);
	}

	/* expression = float_constant { ... } */
	
	private Object action_21( IASNode __p) throws java.lang.Exception
	{
		Float float_constant = (Float)__reducedValues.pop();
		return reducer.transform_float_constant(__p,float_constant);
	}

	/* expression = constant_value { ... } */
	
	private Object action_22( IASNode __p) throws java.lang.Exception
	{
		Object constant_value = (Object)__reducedValues.pop();
		return reducer.transform_constant_value(__p,constant_value);
	}

	/* expression = non_resolving_identifier { ... } */
	
	private Object action_23( IASNode __p) throws java.lang.Exception
	{
		String non_resolving_identifier = (String)__reducedValues.pop();
		return reducer.transform_non_resolving_identifier(__p,non_resolving_identifier);
	}

	/* boolean_literal = boolean_constant { ... } */
	
	private Object action_24( IASNode __p) throws java.lang.Exception
	{
		Boolean boolean_constant = (Boolean)__reducedValues.pop();
		return reducer.transform_boolean_constant(__p,boolean_constant);
	}

	/* expression = XMLContentID(ContainerID(expression+)) */
	
	private Object action_25( IASNode __p) throws java.lang.Exception
	{
		java.util.Vector exprs = (java.util.Vector)__reducedValues.pop();
		return reducer.reduce_XMLContent(__p,exprs);
	}

	/* expression = XMLListContentID(ContainerID(expression*)) */
	
	private Object action_26( IASNode __p) throws java.lang.Exception
	{
		java.util.Vector exprs = (java.util.Vector)__reducedValues.pop();
		return reducer.reduce_XMLList(__p,exprs);
	}

	/* expression = XMLListContentID(ContainerID(e4x_literal*)) */
	
	private Object action_27( IASNode __p) throws java.lang.Exception
	{
		java.util.Vector elements = (java.util.Vector)__reducedValues.pop();
		return reducer.reduce_XMLListConst(__p,elements);
	}

	/* e4x_literal = LiteralXMLID(void) */
	
	private String action_28( IASNode __p) throws java.lang.Exception
	{
		return reducer.getStringLiteralContent(__p);
	}

	/* expression = Op_AddID(expression, expression) */
	
	private Object action_29( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,l,r,OP_add);
	}

	/* expression = ArrayIndexExpressionID(expression, expression) */
	
	private Object action_30( IASNode __p) throws java.lang.Exception
	{
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_arrayIndexExpr(__p,stem,false,index);
	}

	/* array_literal = ArrayLiteralID(ContainerID(expression*)) */
	
	private Object action_31( IASNode __p) throws java.lang.Exception
	{
		java.util.Vector elements = (java.util.Vector)__reducedValues.pop();
		return reducer.reduce_arrayLiteral(__p,elements);
	}

	/* expression = Op_BitwiseAndAssignID(ArrayIndexExpressionID(expression, expression), expression) */
	
	private Object action_32( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentBracketExpr(__p,stem,index,expr,OP_bitand);
	}

	/* expression = Op_BitwiseAndAssignID(MemberAccessExpressionID(expression, name), expression) */
	
	private Object action_33( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object member = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentMemberExpr(__p,stem,member,expr,OP_bitand);
	}

	/* expression = Op_BitwiseAndAssignID(name, expression) */
	
	private Object action_34( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object operand = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentNameExpr(__p,operand,expr,OP_bitand);
	}

	/* expression = Op_BitwiseOrAssignID(ArrayIndexExpressionID(expression, expression), expression) */
	
	private Object action_35( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentBracketExpr(__p,stem,index,expr,OP_bitor);
	}

	/* expression = Op_BitwiseOrAssignID(MemberAccessExpressionID(expression, name), expression) */
	
	private Object action_36( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object member = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentMemberExpr(__p,stem,member,expr,OP_bitor);
	}

	/* expression = Op_BitwiseOrAssignID(name, expression) */
	
	private Object action_37( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object operand = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentNameExpr(__p,operand,expr,OP_bitor);
	}

	/* expression = Op_BitwiseXorAssignID(ArrayIndexExpressionID(expression, expression), expression) */
	
	private Object action_38( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentBracketExpr(__p,stem,index,expr,OP_bitxor);
	}

	/* expression = Op_BitwiseXorAssignID(MemberAccessExpressionID(expression, name), expression) */
	
	private Object action_39( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object member = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentMemberExpr(__p,stem,member,expr,OP_bitxor);
	}

	/* expression = Op_BitwiseXorAssignID(name, expression) */
	
	private Object action_40( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object operand = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentNameExpr(__p,operand,expr,OP_bitxor);
	}

	/* expression = Op_DivideAssignID(ArrayIndexExpressionID(expression, expression), expression) */
	
	private Object action_41( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentBracketExpr(__p,stem,index,expr,OP_divide);
	}

	/* expression = Op_DivideAssignID(MemberAccessExpressionID(expression, name), expression) */
	
	private Object action_42( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object member = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentMemberExpr(__p,stem,member,expr,OP_divide);
	}

	/* expression = Op_DivideAssignID(name, expression) */
	
	private Object action_43( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object operand = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentNameExpr(__p,operand,expr,OP_divide);
	}

	/* expression = Op_LeftShiftAssignID(ArrayIndexExpressionID(expression, expression), expression) */
	
	private Object action_44( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentBracketExpr(__p,stem,index,expr,OP_lshift);
	}

	/* expression = Op_LeftShiftAssignID(MemberAccessExpressionID(expression, name), expression) */
	
	private Object action_45( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object member = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentMemberExpr(__p,stem,member,expr,OP_lshift);
	}

	/* expression = Op_LeftShiftAssignID(name, expression) */
	
	private Object action_46( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object operand = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentNameExpr(__p,operand,expr,OP_lshift);
	}

	/* expression = Op_SubtractAssignID(ArrayIndexExpressionID(expression, expression), expression) */
	
	private Object action_47( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentBracketExpr(__p,stem,index,expr,OP_subtract);
	}

	/* expression = Op_SubtractAssignID(MemberAccessExpressionID(expression, name), expression) */
	
	private Object action_48( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object member = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentMemberExpr(__p,stem,member,expr,OP_subtract);
	}

	/* expression = Op_SubtractAssignID(name, expression) */
	
	private Object action_49( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object operand = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentNameExpr(__p,operand,expr,OP_subtract);
	}

	/* expression = Op_ModuloAssignID(ArrayIndexExpressionID(expression, expression), expression) */
	
	private Object action_50( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentBracketExpr(__p,stem,index,expr,OP_modulo);
	}

	/* expression = Op_ModuloAssignID(MemberAccessExpressionID(expression, name), expression) */
	
	private Object action_51( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object member = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentMemberExpr(__p,stem,member,expr,OP_modulo);
	}

	/* expression = Op_ModuloAssignID(name, expression) */
	
	private Object action_52( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object operand = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentNameExpr(__p,operand,expr,OP_modulo);
	}

	/* expression = Op_MultiplyAssignID(ArrayIndexExpressionID(expression, expression), expression) */
	
	private Object action_53( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentBracketExpr(__p,stem,index,expr,OP_multiply);
	}

	/* expression = Op_MultiplyAssignID(MemberAccessExpressionID(expression, name), expression) */
	
	private Object action_54( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object member = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentMemberExpr(__p,stem,member,expr,OP_multiply);
	}

	/* expression = Op_MultiplyAssignID(name, expression) */
	
	private Object action_55( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object operand = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentNameExpr(__p,operand,expr,OP_multiply);
	}

	/* expression = Op_AddAssignID(ArrayIndexExpressionID(expression, expression), expression) */
	
	private Object action_56( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentBracketExpr(__p,stem,index,expr,OP_add);
	}

	/* expression = Op_AddAssignID(MemberAccessExpressionID(expression, name), expression) */
	
	private Object action_57( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object member = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentMemberExpr(__p,stem,member,expr,OP_add);
	}

	/* expression = Op_AddAssignID(name, expression) */
	
	private Object action_58( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object operand = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentNameExpr(__p,operand,expr,OP_add);
	}

	/* expression = Op_RightShiftAssignID(ArrayIndexExpressionID(expression, expression), expression) */
	
	private Object action_59( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentBracketExpr(__p,stem,index,expr,OP_rshift);
	}

	/* expression = Op_RightShiftAssignID(MemberAccessExpressionID(expression, name), expression) */
	
	private Object action_60( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object member = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentMemberExpr(__p,stem,member,expr,OP_rshift);
	}

	/* expression = Op_RightShiftAssignID(name, expression) */
	
	private Object action_61( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object operand = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentNameExpr(__p,operand,expr,OP_rshift);
	}

	/* expression = Op_AssignId(ArrayIndexExpressionID(expression, expression), expression) */
	
	private Object action_62( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_assignToBracketExpr_to_expression(__p,stem,index,r,false);
	}

	/* expression = Op_AssignId(Op_DescendantsID(expression, name), expression) */
	
	private Object action_63( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object member = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_assignToDescendantsExpr(__p,stem,member,r,NEED_VALUE);
	}

	/* expression = Op_AssignId(MemberAccessExpressionID(expression, name), expression) */
	
	private Object action_64( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object member = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_assignToMemberExpr_to_expression(__p,stem,member,r);
	}

	/* expression = Op_AssignId(name, expression) */
	
	private Object action_65( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object lval = (Object)__reducedValues.pop();
		return reducer.reduce_assignToNameExpr_to_expression(__p,lval,r);
	}

	/* expression = Op_AssignId(MemberAccessExpressionID(expression, Op_AtID(NamespaceAccessExpressionID(name, name))), expression) */
	
	private Object action_66( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object attribute = (Object)__reducedValues.pop();
		Object qualifier = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_assignToQualifiedAttributeExpr(__p,stem,qualifier,attribute,r,NEED_VALUE);
	}

	/* expression = Op_AssignId(MemberAccessExpressionID(expression, NamespaceAccessExpressionID(name, name)), expression) */
	
	private Object action_67( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object member = (Object)__reducedValues.pop();
		Object qualifier = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_assignToQualifiedMemberExpr(__p,stem,qualifier,member,r,NEED_VALUE);
	}

	/* expression = Op_AssignId(MemberAccessExpressionID(expression, NamespaceAccessExpressionID(name, expression)), expression) */
	
	private Object action_68( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object member = (Object)__reducedValues.pop();
		Object qualifier = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_assignToQualifiedRuntimeMemberExpr(__p,stem,qualifier,member,r,NEED_VALUE);
	}

	/* void_expression = Op_AssignId(runtime_name_expression, expression) */
	
	private Object action_69( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object lval = (Object)__reducedValues.pop();
		return reducer.reduce_assignToRuntimeNameExpr(__p,lval,r,DISCARD_VALUE);
	}

	/* expression = Op_AssignId(runtime_name_expression, expression) */
	
	private Object action_70( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object lval = (Object)__reducedValues.pop();
		return reducer.reduce_assignToRuntimeNameExpr(__p,lval,r,NEED_VALUE);
	}

	/* expression = Op_AssignId(ArrayIndexExpressionID(SuperID(void), expression), expression) */
	
	private Object action_71( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object index = (Object)__reducedValues.pop();
	IASNode stem = SemanticUtils.getNthChild(SemanticUtils.getNthChild(__p, 0), 0);
		return reducer.reduce_assignToBracketExpr_to_expression(__p,null,index,r,true);
	}

	/* expression = Op_AssignId(MemberAccessExpressionID(expression, ArrayIndexExpressionID(Op_AtID(void), expression)), expression) */
	
	private Object action_72( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object rt_attr_name = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_assignToUnqualifiedRuntimeAttributeExpr(__p,stem,rt_attr_name,r,NEED_VALUE);
	}

	/* expression = Op_AssignId(Op_DescendantsID(expression, ArrayIndexExpressionID(Op_AtID(void), expression)), expression) */
	
	private Object action_73( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object rt_attr_name = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_assignToUnqualifiedRuntimeAttributeExpr(__p,stem,rt_attr_name,r,NEED_VALUE);
	}

	/* expression = Op_UnsignedRightShiftAssignID(ArrayIndexExpressionID(expression, expression), expression) */
	
	private Object action_74( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentBracketExpr(__p,stem,index,expr,OP_urshift);
	}

	/* expression = Op_UnsignedRightShiftAssignID(MemberAccessExpressionID(expression, name), expression) */
	
	private Object action_75( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object member = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentMemberExpr(__p,stem,member,expr,OP_urshift);
	}

	/* expression = Op_UnsignedRightShiftAssignID(name, expression) */
	
	private Object action_76( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object operand = (Object)__reducedValues.pop();
		return reducer.compoundBinaryAssignmentNameExpr(__p,operand,expr,OP_urshift);
	}

	/* expression = Op_AsID(expression, expression) */
	
	private Object action_77( IASNode __p) throws java.lang.Exception
	{
		Object typename = (Object)__reducedValues.pop();
		Object expr = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,expr,typename,OP_astypelate);
	}

	/* name = Op_AtID(name) */
	
	private Object action_78( IASNode __p) throws java.lang.Exception
	{
		Object attr_name = (Object)__reducedValues.pop();
		return reducer.reduce_attributeName(__p,attr_name);
	}

	/* expression = Op_BitwiseNotID(expression) */
	
	private Object action_79( IASNode __p) throws java.lang.Exception
	{
		Object unary = (Object)__reducedValues.pop();
		return reducer.unaryOp(__p,unary,OP_bitnot);
	}

	/* expression = Op_BitwiseAndID(expression, expression) */
	
	private Object action_80( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,l,r,OP_bitand);
	}

	/* expression = Op_LeftShiftID(expression, expression) */
	
	private Object action_81( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,l,r,OP_lshift);
	}

	/* expression = Op_BitwiseOrID(expression, expression) */
	
	private Object action_82( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,l,r,OP_bitor);
	}

	/* expression = Op_RightShiftID(expression, expression) */
	
	private Object action_83( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,l,r,OP_rshift);
	}

	/* expression = Op_UnsignedRightShift(expression, expression) */
	
	private Object action_84( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,l,r,OP_urshift);
	}

	/* expression = Op_BitwiseXorID(expression, expression) */
	
	private Object action_85( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,l,r,OP_bitxor);
	}

	/* boolean_constant = LiteralBooleanID(void) */
	
	private Boolean action_86( IASNode __p) throws java.lang.Exception
	{
		return reducer.reduce_booleanLiteral(__p);
	}

	/* expression = Op_CommaID(expression, void_expression+) */
	
	private Object action_87( IASNode __p) throws java.lang.Exception
	{
		java.util.Vector exprs = (java.util.Vector)__reducedValues.pop();
		Object payload_expr = (Object)__reducedValues.pop();
		return reducer.reduce_commaExpr(__p,payload_expr,exprs);
	}

	/* expression = Op_DeleteID(expression) */
	
	private Object action_88( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		return reducer.reduce_deleteExprExprExpr(__p,expr);
	}

	/* expression = Op_DeleteID(MemberAccessExpressionID(expression, ArrayIndexExpressionID(Op_AtID(void), expression))) */
	
	private Object action_89( IASNode __p) throws java.lang.Exception
	{
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_deleteAtBracketExpr(__p,stem,index);
	}

	/* expression = Op_DeleteID(ArrayIndexExpressionID(expression, expression)) */
	
	private Object action_90( IASNode __p) throws java.lang.Exception
	{
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_deleteBracketExpr(__p,stem,index);
	}

	/* expression = Op_DeleteID(Op_DescendantsID(expression, name)) */
	
	private Object action_91( IASNode __p) throws java.lang.Exception
	{
		Object field = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_deleteDescendantsExpr(__p,stem,field);
	}

	/* expression = Op_DeleteID(MemberAccessExpressionID(expression, name)) */
	
	private Object action_92( IASNode __p) throws java.lang.Exception
	{
		Object field = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_deleteMemberExpr(__p,stem,field);
	}

	/* expression = Op_DeleteID(name) */
	
	private Object action_93( IASNode __p) throws java.lang.Exception
	{
		Object n = (Object)__reducedValues.pop();
		return reducer.reduce_deleteNameExpr(__p,n);
	}

	/* expression = Op_DeleteID(MemberAccessExpressionID(expression, runtime_name_expression)) */
	
	private Object action_94( IASNode __p) throws java.lang.Exception
	{
		Object rt_name = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_deleteRuntimeNameExpr(__p,stem,rt_name);
	}

	/* expression = Op_DescendantsID(expression, name) */
	
	private Object action_95( IASNode __p) throws java.lang.Exception
	{
		Object descendants = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_memberAccessExpr(__p,stem,descendants,OP_getdescendants);
	}

	/* expression = Op_DivideID(expression, expression) */
	
	private Object action_96( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,l,r,OP_divide);
	}

	/* dottedNamePart = MemberAccessExpressionID(dottedNamePart, dottedNamePart) */
	
	private String action_97( IASNode __p) throws java.lang.Exception
	{
		String second = (String)__reducedValues.pop();
		String first = (String)__reducedValues.pop();
		return reducer.reduce_by_concatenation(__p,first,second);
	}

	/* name = MemberAccessExpressionID(dottedNamePart, dottedNamePart) */
	
	private Object action_98( IASNode __p) throws java.lang.Exception
	{
		String second = (String)__reducedValues.pop();
		String first = (String)__reducedValues.pop();
		return reducer.dottedName(__p,first,second);
	}

	/* name = MemberAccessExpressionID(dottedNamePart, dottedNamePart) */
	
	private Object action_99( IASNode __p) throws java.lang.Exception
	{
		String second = (String)__reducedValues.pop();
		String first = (String)__reducedValues.pop();
		return reducer.errorPackageName(__p,first,second);
	}

	/* double_constant = LiteralDoubleID(void) */
	
	private Double action_100( IASNode __p) throws java.lang.Exception
	{
		return reducer.getDoubleContent(__p);
	}

	/* expression = E4XFilterID(expression, expression) */
	
	private Object action_101( IASNode __p) throws java.lang.Exception
	{
		Object filter = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_e4xFilter(__p,stem,filter);
	}

	/* expression = EmbedID(void) */
	
	private Object action_102( IASNode __p) throws java.lang.Exception
	{
		return reducer.reduce_embed(__p);
	}

	/* comparison_expression = Op_EqualID(expression, expression) */
	
	private Object action_103( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,l,r,OP_equals);
	}

	/* foldedExpression = FoldedExpressionID(void) */
	
	private Object action_104( IASNode __p) throws java.lang.Exception
	{
		return reducer.reduceLazyExpression(__p);
	}

	/* name = FullNameID(dottedNamePart, dottedNamePart) */
	
	private Object action_105( IASNode __p) throws java.lang.Exception
	{
		String second = (String)__reducedValues.pop();
		String first = (String)__reducedValues.pop();
		return reducer.dottedName(__p,first,second);
	}

	/* dottedNamePart = FullNameID(dottedNamePart, dottedNamePart) */
	
	private String action_106( IASNode __p) throws java.lang.Exception
	{
		String second = (String)__reducedValues.pop();
		String first = (String)__reducedValues.pop();
		return reducer.reduce_by_concatenation(__p,first,second);
	}

	/* expression = FunctionCallID(ArrayIndexExpressionID(expression, expression), ContainerID(expression*)) */
	
	private Object action_107( IASNode __p) throws java.lang.Exception
	{
		java.util.Vector args = (java.util.Vector)__reducedValues.pop();
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_functionAsBracketExpr(__p,stem,index,args);
	}

	/* expression = FunctionCallID(MemberAccessExpressionID(expression, name), ContainerID(expression*)) */
	
	private Object action_108( IASNode __p) throws java.lang.Exception
	{
		java.util.Vector args = (java.util.Vector)__reducedValues.pop();
		Object method_name = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_functionAsMemberExpr(__p,stem,method_name,args);
	}

	/* expression = FunctionCallID(expression, ContainerID(expression*)) */
	
	private Object action_109( IASNode __p) throws java.lang.Exception
	{
		java.util.Vector args = (java.util.Vector)__reducedValues.pop();
		Object random_expr = (Object)__reducedValues.pop();
		return reducer.reduce_functionAsRandomExpr(__p,random_expr,args);
	}

	/* expression = FunctionCallID(name, ContainerID(expression*)) */
	
	private Object action_110( IASNode __p) throws java.lang.Exception
	{
		java.util.Vector args = (java.util.Vector)__reducedValues.pop();
		Object method_name = (Object)__reducedValues.pop();
		return reducer.reduce_functionCallExpr_to_expression(__p,method_name,args);
	}

	/* expression = FunctionCallID(MemberAccessExpressionID(FunctionCallID(SuperID(void), ContainerID(expression)), name), ContainerID(expression*)) */
	
	private Object action_111( IASNode __p) throws java.lang.Exception
	{
		java.util.Vector args = (java.util.Vector)__reducedValues.pop();
		Object method_name = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_functionCallOfSuperclassMethod_to_expression(__p,stem,method_name,args);
	}

	/* expression = FunctionCallID(MemberAccessExpressionID(SuperID(void), name), ContainerID(expression*)) */
	
	private Object action_112( IASNode __p) throws java.lang.Exception
	{
		java.util.Vector args = (java.util.Vector)__reducedValues.pop();
		Object method_name = (Object)__reducedValues.pop();
		return reducer.reduce_functionCallOfSuperclassMethod_to_expression(__p,null,method_name,args);
	}

	/* expression = FunctionCallID(IdentifierID(void), ContainerID(expression*)) */
	
	private Object action_113( IASNode __p) throws java.lang.Exception
	{
		java.util.Vector args = (java.util.Vector)__reducedValues.pop();
	IASNode specialName = SemanticUtils.getNthChild(__p, 0);
		return reducer.reduce_functionCallSpecial_to_expression(__p,specialName,args);
	}

	/* comparison_expression = Op_GreaterThanEqualsID(expression, expression) */
	
	private Object action_114( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,l,r,OP_greaterequals);
	}

	/* comparison_expression = Op_GreaterThanID(expression, expression) */
	
	private Object action_115( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,l,r,OP_greaterthan);
	}

	/* expression = Op_InID(expression, expression) */
	
	private Object action_116( IASNode __p) throws java.lang.Exception
	{
		Object haystack = (Object)__reducedValues.pop();
		Object needle = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,needle,haystack,OP_in);
	}

	/* expression = Op_InstanceOfID(expression, expression) */
	
	private Object action_117( IASNode __p) throws java.lang.Exception
	{
		Object typename = (Object)__reducedValues.pop();
		Object expr = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,expr,typename,OP_instanceof);
	}

	/* expression = Op_IsID(expression, expression) */
	
	private Object action_118( IASNode __p) throws java.lang.Exception
	{
		Object typename = (Object)__reducedValues.pop();
		Object expr = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,expr,typename,OP_istypelate);
	}

	/* comparison_expression = Op_LessThanEqualsID(expression, expression) */
	
	private Object action_119( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,l,r,OP_lessequals);
	}

	/* comparison_expression = Op_LessThanID(expression, expression) */
	
	private Object action_120( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,l,r,OP_lessthan);
	}

	/* expression = Op_LogicalAndID(expression, foldedExpression) */
	
	private Object action_121( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.reduce_logicalAndExpr(__p,l,r);
	}

	/* expression = Op_LogicalNotID(expression) */
	
	private Object action_122( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		return reducer.reduce_logicalNotExpr(__p,expr);
	}

	/* expression = Op_LogicalOrID(expression, foldedExpression) */
	
	private Object action_123( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.reduce_logicalOrExpr(__p,l,r);
	}

	/* expression = MemberAccessExpressionID(expression, name) */
	
	private Object action_124( IASNode __p) throws java.lang.Exception
	{
		Object member = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_memberAccessExpr(__p,stem,member,OP_getproperty);
	}

	/* expression = Op_ModuloID(expression, expression) */
	
	private Object action_125( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,l,r,OP_modulo);
	}

	/* expression = Op_MultiplyID(expression, expression) */
	
	private Object action_126( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,l,r,OP_multiply);
	}

	/* name = NamespaceAccessExpressionID(NamespaceIdentifierID(void), name) */
	
	private Object action_127( IASNode __p) throws java.lang.Exception
	{
		Object qualified_name = (Object)__reducedValues.pop();
	IASNode qualifier = SemanticUtils.getNthChild(__p, 0);
		return reducer.reduce_namespaceAccess(__p,qualifier,qualified_name);
	}

	/* name = NamespaceAccessExpressionID(NamespaceIdentifierID(void), name) */
	
	private Object action_128( IASNode __p) throws java.lang.Exception
	{
		Object qualified_name = (Object)__reducedValues.pop();
	IASNode qualifier = SemanticUtils.getNthChild(__p, 0);
		return reducer.error_namespaceAccess(__p,qualifier,qualified_name);
	}

	/* name = NamespaceIdentifierID(void) */
	
	private Object action_129( IASNode __p) throws java.lang.Exception
	{
		return reducer.reduce_namespaceAsName_to_name(__p);
	}

	/* expression = NamespaceIdentifierID(void) */
	
	private Object action_130( IASNode __p) throws java.lang.Exception
	{
		return reducer.reduce_namespaceAsName_to_expression(__p);
	}

	/* runtime_name_expression = NamespaceAccessExpressionID(NamespaceIdentifierID(void), expression) */
	
	private Object action_131( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
	IASNode qualifier = SemanticUtils.getNthChild(__p, 0);
		return reducer.reduce_namespaceMultinameL(__p,qualifier,expr);
	}

	/* runtime_name_expression = NamespaceAccessExpressionID(expression, name) */
	
	private Object action_132( IASNode __p) throws java.lang.Exception
	{
		Object qualfied_name = (Object)__reducedValues.pop();
		Object qualifier = (Object)__reducedValues.pop();
		return reducer.reduce_namespaceRTQName(__p,qualifier,qualfied_name);
	}

	/* runtime_name_expression = NamespaceAccessExpressionID(expression, expression) */
	
	private Object action_133( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object qualifier = (Object)__reducedValues.pop();
		return reducer.reduce_namespaceRTQNameL(__p,qualifier,expr);
	}

	/* comparison_expression = Op_NotEqualID(expression, expression) */
	
	private Object action_134( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.reduce_neqExpr(__p,l,r);
	}

	/* expression = FunctionCallID(KeywordNewID(void), expression, ContainerID(expression*)) */
	
	private Object action_135( IASNode __p) throws java.lang.Exception
	{
		java.util.Vector args = (java.util.Vector)__reducedValues.pop();
		Object random_expr = (Object)__reducedValues.pop();
		return reducer.reduce_newAsRandomExpr(__p,random_expr,args);
	}

	/* expression = FunctionCallID(KeywordNewID(void), new_type_name, ContainerID(expression*)) */
	
	private Object action_136( IASNode __p) throws java.lang.Exception
	{
		java.util.Vector args = (java.util.Vector)__reducedValues.pop();
		Object class_binding = (Object)__reducedValues.pop();
		return reducer.reduce_newExpr(__p,class_binding,args);
	}

	/* expression = FunctionCallID(KeywordNewID(void), MemberAccessExpressionID(expression, name), ContainerID(expression*)) */
	
	private Object action_137( IASNode __p) throws java.lang.Exception
	{
		java.util.Vector args = (java.util.Vector)__reducedValues.pop();
		Object member = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_newMemberProperty(__p,stem,member,args);
	}

	/* expression = FunctionCallID(KeywordNewID(void), vector_literal, ContainerID(void)) */
	
	private Object action_138( IASNode __p) throws java.lang.Exception
	{
		Object literal = (Object)__reducedValues.pop();
		return reducer.reduce_newVectorLiteral(__p,literal);
	}

	/* expression = NilID(void) */
	
	private Object action_139( IASNode __p) throws java.lang.Exception
	{
		return reducer.reduce_nilExpr_to_expression(__p);
	}

	/* non_resolving_identifier = NonResolvingIdentifierID(void) */
	
	private String action_140( IASNode __p) throws java.lang.Exception
	{
		return reducer.getIdentifierContent(__p);
	}

	/* constant_value = LiteralNullID(void) */
	
	private Object action_141( IASNode __p) throws java.lang.Exception
	{
		return reducer.reduce_nullLiteral_to_constant_value(__p);
	}

	/* object_literal = LiteralNullID(void) */
	
	private Object action_142( IASNode __p) throws java.lang.Exception
	{
		return reducer.reduce_nullLiteral_to_object_literal(__p);
	}

	/* integer_constant = LiteralNumberID(void) */
	
	private Integer action_143( IASNode __p) throws java.lang.Exception
	{
		return reducer.getIntegerContent(__p);
	}

	/* uint_constant = LiteralNumberID(void) */
	
	private Long action_144( IASNode __p) throws java.lang.Exception
	{
		return reducer.getUintContent(__p);
	}

	/* float_constant = LiteralNumberID(void) */
	
	private Float action_145( IASNode __p) throws java.lang.Exception
	{
		return reducer.getFloatContent(__p);
	}

	/* double_constant = LiteralNumberID(void) */
	
	private Double action_146( IASNode __p) throws java.lang.Exception
	{
		return reducer.getDoubleContent(__p);
	}

	/* double_constant = LiteralNumberID(void) */
	
	private Double action_147( IASNode __p) throws java.lang.Exception
	{
		return reducer.getDoubleContent(__p);
	}

	/* object_literal = ObjectLiteralExpressionID(ContainerID(object_literal_element*)) */
	
	private Object action_148( IASNode __p) throws java.lang.Exception
	{
		java.util.Vector elements = (java.util.Vector)__reducedValues.pop();
		return reducer.reduce_objectLiteral(__p,elements);
	}

	/* object_literal_element = ObjectLiteralValuePairID(expression, expression) */
	
	private Object action_149( IASNode __p) throws java.lang.Exception
	{
		Object value = (Object)__reducedValues.pop();
		Object id = (Object)__reducedValues.pop();
		return reducer.reduce_objectLiteralElement(__p,id,value);
	}

	/* type_name = TypedExpressionID(name, type_name) */
	
	private Object action_150( IASNode __p) throws java.lang.Exception
	{
		Object param = (Object)__reducedValues.pop();
		Object base = (Object)__reducedValues.pop();
		return reducer.reduce_parameterizedTypeName(__p,base,param);
	}

	/* expression = TypedExpressionID(expression, type_param_expression) */
	
	private Object action_151( IASNode __p) throws java.lang.Exception
	{
		Object param = (Object)__reducedValues.pop();
		Object base = (Object)__reducedValues.pop();
		return reducer.reduce_parameterizedTypeExpression(__p,base,param);
	}

	/* expression = Op_PostDecrID(ArrayIndexExpressionID(expression, expression)) */
	
	private Object action_152( IASNode __p) throws java.lang.Exception
	{
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_postDecBracketExpr(__p,stem,index,true);
	}

	/* expression = Op_PostDecrID(MemberAccessExpressionID(expression, name)) */
	
	private Object action_153( IASNode __p) throws java.lang.Exception
	{
		Object field = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_postDecMemberExpr(__p,stem,field,true);
	}

	/* expression = Op_PostDecrID(name) */
	
	private Object action_154( IASNode __p) throws java.lang.Exception
	{
		Object unary = (Object)__reducedValues.pop();
		return reducer.reduce_postDecNameExpr(__p,unary,true);
	}

	/* expression = Op_PostIncrID(ArrayIndexExpressionID(expression, expression)) */
	
	private Object action_155( IASNode __p) throws java.lang.Exception
	{
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_postIncBracketExpr(__p,stem,index,true);
	}

	/* expression = Op_PostIncrID(MemberAccessExpressionID(expression, name)) */
	
	private Object action_156( IASNode __p) throws java.lang.Exception
	{
		Object field = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_postIncMemberExpr(__p,stem,field,true);
	}

	/* expression = Op_PostIncrID(name) */
	
	private Object action_157( IASNode __p) throws java.lang.Exception
	{
		Object unary = (Object)__reducedValues.pop();
		return reducer.reduce_postIncNameExpr(__p,unary,true);
	}

	/* expression = Op_PreDecrID(ArrayIndexExpressionID(expression, expression)) */
	
	private Object action_158( IASNode __p) throws java.lang.Exception
	{
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_preDecBracketExpr(__p,stem,index,true);
	}

	/* expression = Op_PreDecrID(MemberAccessExpressionID(expression, name)) */
	
	private Object action_159( IASNode __p) throws java.lang.Exception
	{
		Object field = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_preDecMemberExpr(__p,stem,field,true);
	}

	/* expression = Op_PreDecrID(name) */
	
	private Object action_160( IASNode __p) throws java.lang.Exception
	{
		Object unary = (Object)__reducedValues.pop();
		return reducer.reduce_preDecNameExpr(__p,unary,true);
	}

	/* expression = Op_PreIncrID(ArrayIndexExpressionID(expression, expression)) */
	
	private Object action_161( IASNode __p) throws java.lang.Exception
	{
		Object index = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_preIncBracketExpr(__p,stem,index,true);
	}

	/* expression = Op_PreIncrID(MemberAccessExpressionID(expression, name)) */
	
	private Object action_162( IASNode __p) throws java.lang.Exception
	{
		Object field = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_preIncMemberExpr(__p,stem,field,true);
	}

	/* expression = Op_PreIncrID(name) */
	
	private Object action_163( IASNode __p) throws java.lang.Exception
	{
		Object unary = (Object)__reducedValues.pop();
		return reducer.reduce_preIncNameExpr(__p,unary,true);
	}

	/* expression = MemberAccessExpressionID(expression, Op_AtID(NamespaceAccessExpressionID(name, name))) */
	
	private Object action_164( IASNode __p) throws java.lang.Exception
	{
		Object member = (Object)__reducedValues.pop();
		Object qualifier = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_qualifiedAttributeExpr(__p,stem,qualifier,member,OP_getproperty);
	}

	/* expression = MemberAccessExpressionID(expression, Op_AtID(NamespaceAccessExpressionID(name, expression))) */
	
	private Object action_165( IASNode __p) throws java.lang.Exception
	{
		Object runtime_member = (Object)__reducedValues.pop();
		Object qualifier = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_qualifiedAttributeRuntimeMemberExpr(__p,stem,qualifier,runtime_member,OP_getproperty);
	}

	/* expression = Op_DescendantsID(expression, Op_AtID(NamespaceAccessExpressionID(name, name))) */
	
	private Object action_166( IASNode __p) throws java.lang.Exception
	{
		Object member = (Object)__reducedValues.pop();
		Object qualifier = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_qualifiedAttributeExpr(__p,stem,qualifier,member,OP_getdescendants);
	}

	/* expression = Op_DescendantsID(expression, NamespaceAccessExpressionID(name, name)) */
	
	private Object action_167( IASNode __p) throws java.lang.Exception
	{
		Object member = (Object)__reducedValues.pop();
		Object qualifier = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_qualifiedMemberAccessExpr(__p,stem,qualifier,member,OP_getdescendants);
	}

	/* expression = Op_DescendantsID(expression, NamespaceAccessExpressionID(name, expression)) */
	
	private Object action_168( IASNode __p) throws java.lang.Exception
	{
		Object runtime_member = (Object)__reducedValues.pop();
		Object qualifier = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_qualifiedAttributeRuntimeMemberExpr(__p,stem,qualifier,runtime_member,OP_getdescendants);
	}

	/* expression = Op_DescendantsID(expression, Op_AtID(NamespaceAccessExpressionID(name, expression))) */
	
	private Object action_169( IASNode __p) throws java.lang.Exception
	{
		Object runtime_member = (Object)__reducedValues.pop();
		Object qualifier = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_qualifiedAttributeRuntimeMemberExpr(__p,stem,qualifier,runtime_member,OP_getdescendants);
	}

	/* expression = MemberAccessExpressionID(expression, NamespaceAccessExpressionID(name, name)) */
	
	private Object action_170( IASNode __p) throws java.lang.Exception
	{
		Object member = (Object)__reducedValues.pop();
		Object qualifier = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_qualifiedMemberAccessExpr(__p,stem,qualifier,member,OP_getproperty);
	}

	/* expression = MemberAccessExpressionID(expression, NamespaceAccessExpressionID(name, expression)) */
	
	private Object action_171( IASNode __p) throws java.lang.Exception
	{
		Object runtime_member = (Object)__reducedValues.pop();
		Object qualifier = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_qualifiedMemberRuntimeNameExpr(__p,stem,qualifier,runtime_member);
	}

	/* name = QualifiedNamespaceExpressionID(dottedNamePart, dottedNamePart) */
	
	private Object action_172( IASNode __p) throws java.lang.Exception
	{
		String second = (String)__reducedValues.pop();
		String first = (String)__reducedValues.pop();
		return reducer.dottedName(__p,first,second);
	}

	/* object_literal = LiteralRegexID(void) */
	
	private Object action_173( IASNode __p) throws java.lang.Exception
	{
		return reducer.reduce_regexLiteral(__p);
	}

	/* expression = ArrayIndexExpressionID(Op_AtID(void), expression) */
	
	private Object action_174( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		return reducer.reduce_runtimeAttributeExp(__p,expr);
	}

	/* expression = RuntimeNameExpressionID(expression) */
	
	private Object action_175( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		return reducer.reduce_runtimeNameExpression(__p,expr);
	}

	/* name = IdentifierID(void) */
	
	private Object action_176( IASNode __p) throws java.lang.Exception
	{
		return reducer.reduce_simpleName(__p);
	}

	/* qualifiedNamePart = IdentifierID(void) */
	
	private Object action_177( IASNode __p) throws java.lang.Exception
	{
		return reducer.getIdentifierContent(__p);
	}

	/* decl_name = IdentifierID(void) */
	
	private Object action_178( IASNode __p) throws java.lang.Exception
	{
		return reducer.reduce_declName(__p);
	}

	/* comparison_expression = Op_StrictEqualID(expression, expression) */
	
	private Object action_179( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,l,r,OP_strictequals);
	}

	/* comparison_expression = Op_StrictNotEqualID(expression, expression) */
	
	private Object action_180( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.reduce_strictneqExpr(__p,l,r);
	}

	/* string_constant = LiteralStringID(void) */
	
	private String action_181( IASNode __p) throws java.lang.Exception
	{
		return reducer.getStringLiteralContent(__p);
	}

	/* expression = Op_SubtractID(expression, expression) */
	
	private Object action_182( IASNode __p) throws java.lang.Exception
	{
		Object r = (Object)__reducedValues.pop();
		Object l = (Object)__reducedValues.pop();
		return reducer.binaryOp(__p,l,r,OP_subtract);
	}

	/* name = MemberAccessExpressionID(SuperID(void), name) */
	
	private Object action_183( IASNode __p) throws java.lang.Exception
	{
		Object qualified_name = (Object)__reducedValues.pop();
		return reducer.reduce_superAccess(__p,qualified_name);
	}

	/* expression = ArrayIndexExpressionID(SuperID(void), expression) */
	
	private Object action_184( IASNode __p) throws java.lang.Exception
	{
		Object index = (Object)__reducedValues.pop();
	IASNode stem = SemanticUtils.getNthChild(__p, 0);
		return reducer.reduce_arrayIndexExpr(__p,null,true,index);
	}

	/* expression = TernaryExpressionID(expression, expression, expression) */
	
	private Object action_185( IASNode __p) throws java.lang.Exception
	{
		Object when_false = (Object)__reducedValues.pop();
		Object when_true = (Object)__reducedValues.pop();
		Object test = (Object)__reducedValues.pop();
		return reducer.reduce_ternaryExpr(__p,test,when_true,when_false);
	}

	/* name = VariableExpressionID(VariableID(decl_name, type_name)) */
	
	private Object action_186( IASNode __p) throws java.lang.Exception
	{
		Object var_type = (Object)__reducedValues.pop();
		Object var_name = (Object)__reducedValues.pop();
		return reducer.reduce_typedVariableExpression(__p,var_name,var_type);
	}

	/* expression = Op_TypeOfID(expression) */
	
	private Object action_187( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		return reducer.reduce_typeof_expr(__p,expr);
	}

	/* expression = Op_TypeOfID(name) */
	
	private Object action_188( IASNode __p) throws java.lang.Exception
	{
		Object n = (Object)__reducedValues.pop();
		return reducer.reduce_typeof_name(__p,n);
	}

	/* expression = Op_SubtractID(expression) */
	
	private Object action_189( IASNode __p) throws java.lang.Exception
	{
		Object e = (Object)__reducedValues.pop();
		return reducer.unaryOp(__p,e,OP_negate);
	}

	/* expression = Op_AddID(expression) */
	
	private Object action_190( IASNode __p) throws java.lang.Exception
	{
		Object e = (Object)__reducedValues.pop();
		{
		    return reducer.unaryOp(__p, e, OP_convert_d);
		}
	}

	/* expression = MemberAccessExpressionID(expression, ArrayIndexExpressionID(Op_AtID(void), expression)) */
	
	private Object action_191( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_unqualifiedAttributeExpr(__p,stem,expr,OP_getproperty);
	}

	/* expression = Op_DescendantsID(expression, ArrayIndexExpressionID(Op_AtID(void), expression)) */
	
	private Object action_192( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		Object stem = (Object)__reducedValues.pop();
		return reducer.reduce_unqualifiedAttributeExpr(__p,stem,expr,OP_getdescendants);
	}

	/* vector_literal = VectorLiteralID(type_name, ContainerID(expression*)) */
	
	private Object action_193( IASNode __p) throws java.lang.Exception
	{
		java.util.Vector elements = (java.util.Vector)__reducedValues.pop();
		Object type_param = (Object)__reducedValues.pop();
		return reducer.reduce_vectorLiteral(__p,type_param,elements);
	}

	/* constant_value = LiteralObjectID(void) */
	
	private Object action_194( IASNode __p) throws java.lang.Exception
	{
		return reducer.reduce_void0Literal_to_constant_value(__p);
	}

	/* object_literal = LiteralObjectID(void) */
	
	private Object action_195( IASNode __p) throws java.lang.Exception
	{
		return reducer.reduce_void0Literal_to_object_literal(__p);
	}

	/* object_literal = Op_VoidID(void) */
	
	private Object action_196( IASNode __p) throws java.lang.Exception
	{
		return reducer.reduce_void0Operator(__p);
	}

	/* constant_value = Op_VoidID(constant_value) */
	
	private Object action_197( IASNode __p) throws java.lang.Exception
	{
		Object value = (Object)__reducedValues.pop();
		return reducer.reduce_voidOperator_to_constant_value(__p,value);
	}

	/* type_name = VoidID(void) */
	
	private Object action_198( IASNode __p) throws java.lang.Exception
	{
		return reducer.reduce_voidExpr_to_type_name(__p);
	}

	/* expression = Op_VoidID(expression) */
	
	private Object action_199( IASNode __p) throws java.lang.Exception
	{
		Object expr = (Object)__reducedValues.pop();
		return reducer.reduce_voidOperator_to_expression(__p,expr);
	}

	/* literal = array_literal */
	
	private Object action_200( IASNode __p) throws java.lang.Exception
	{
		return((Object)__reducedValues.pop());
	}

	/* string_constant = e4x_literal */
	
	private String action_201( IASNode __p) throws java.lang.Exception
	{
		return((String)__reducedValues.pop());
	}

	/* numeric_constant = uint_constant */
	
	private Number action_202( IASNode __p) throws java.lang.Exception
	{
		return((Number)__reducedValues.pop());
	}

	/* numeric_constant = float_constant */
	
	private Number action_203( IASNode __p) throws java.lang.Exception
	{
		return((Number)__reducedValues.pop());
	}

	/* new_type_name = name */
	
	private Object action_204( IASNode __p) throws java.lang.Exception
	{
		return((Object)__reducedValues.pop());
	}

	/* type_param_expression = expression */
	
	private Object action_205( IASNode __p) throws java.lang.Exception
	{
		return((Object)__reducedValues.pop());
	}

	/* literal = object_literal */
	
	private Object action_206( IASNode __p) throws java.lang.Exception
	{
		return((Object)__reducedValues.pop());
	}

	/* dottedNamePart = qualifiedNamePart */
	
	private String action_207( IASNode __p) throws java.lang.Exception
	{
		return((String)__reducedValues.pop());
	}

	/* expression = literal */
	
	private Object action_208( IASNode __p) throws java.lang.Exception
	{
		return((Object)__reducedValues.pop());
	}

	/* numeric_constant = double_constant */
	
	private Number action_209( IASNode __p) throws java.lang.Exception
	{
		return((Number)__reducedValues.pop());
	}

	/* literal = boolean_literal */
	
	private Object action_210( IASNode __p) throws java.lang.Exception
	{
		return((Object)__reducedValues.pop());
	}

	/* numeric_constant = integer_constant */
	
	private Number action_211( IASNode __p) throws java.lang.Exception
	{
		return((Number)__reducedValues.pop());
	}

	/* required_constant_value = constant_value */
	
	private Object action_212( IASNode __p) throws java.lang.Exception
	{
		return((Object)__reducedValues.pop());
	}

	/* expression = comparison_expression */
	
	private Object action_213( IASNode __p) throws java.lang.Exception
	{
		return((Object)__reducedValues.pop());
	}
	
	private void dispatchAction( JBurgAnnotation ___node, int iRule) throws java.lang.Exception
	{
		IASNode __p = ___node.getNode();

		switch( iRule )
		{
			case 1:
			{
				__reducedValues.push(this.action_1(__p));
				break;
			}
			case 2:
			{
				this.reduceAntecedent(___node, __name_NT);
				__reducedValues.push(this.action_2(__p));
				break;
			}
			case 3:
			{
				this.reduceAntecedent(___node, __type_name_NT);
				__reducedValues.push(this.action_3(__p));
				break;
			}
			case 4:
			{
				this.reduceAntecedent(___node, __name_NT);
				__reducedValues.push(this.action_4(__p));
				break;
			}
			case 5:
			{
				this.reduceAntecedent(___node, __name_NT);
				__reducedValues.push(this.action_5(__p));
				break;
			}
			case 6:
			{
				this.reduceAntecedent(___node, __runtime_name_expression_NT);
				__reducedValues.push(this.action_6(__p));
				break;
			}
			case 7:
			{
				this.reduceAntecedent(___node, __string_constant_NT);
				__reducedValues.push(this.action_7(__p));
				break;
			}
			case 8:
			{
				this.reduceAntecedent(___node, __integer_constant_NT);
				__reducedValues.push(this.action_8(__p));
				break;
			}
			case 9:
			{
				this.reduceAntecedent(___node, __uint_constant_NT);
				__reducedValues.push(this.action_9(__p));
				break;
			}
			case 10:
			{
				this.reduceAntecedent(___node, __boolean_constant_NT);
				__reducedValues.push(this.action_10(__p));
				break;
			}
			case 11:
			{
				this.reduceAntecedent(___node, __expression_NT);
				__reducedValues.push(this.action_11(__p));
				break;
			}
			case 12:
			{
				__reducedValues.push(this.action_12(__p));
				break;
			}
			case 13:
			{
				__reducedValues.push(this.action_13(__p));
				break;
			}
			case 14:
			{
				__reducedValues.push(this.action_14(__p));
				break;
			}
			case 15:
			{
				this.reduceAntecedent(___node, __string_constant_NT);
				__reducedValues.push(this.action_15(__p));
				break;
			}
			case 16:
			{
				this.reduceAntecedent(___node, __boolean_constant_NT);
				__reducedValues.push(this.action_16(__p));
				break;
			}
			case 17:
			{
				this.reduceAntecedent(___node, __numeric_constant_NT);
				__reducedValues.push(this.action_17(__p));
				break;
			}
			case 18:
			{
				this.reduceAntecedent(___node, __double_constant_NT);
				__reducedValues.push(this.action_18(__p));
				break;
			}
			case 19:
			{
				this.reduceAntecedent(___node, __integer_constant_NT);
				__reducedValues.push(this.action_19(__p));
				break;
			}
			case 20:
			{
				this.reduceAntecedent(___node, __numeric_constant_NT);
				__reducedValues.push(this.action_20(__p));
				break;
			}
			case 21:
			{
				this.reduceAntecedent(___node, __float_constant_NT);
				__reducedValues.push(this.action_21(__p));
				break;
			}
			case 22:
			{
				this.reduceAntecedent(___node, __constant_value_NT);
				__reducedValues.push(this.action_22(__p));
				break;
			}
			case 23:
			{
				this.reduceAntecedent(___node, __non_resolving_identifier_NT);
				__reducedValues.push(this.action_23(__p));
				break;
			}
			case 24:
			{
				this.reduceAntecedent(___node, __boolean_constant_NT);
				__reducedValues.push(this.action_24(__p));
				break;
			}
			case 25:
			{
				__reducedValues.push(this.action_25(__p));
				break;
			}
			case 26:
			{
				__reducedValues.push(this.action_26(__p));
				break;
			}
			case 27:
			{
				__reducedValues.push(this.action_27(__p));
				break;
			}
			case 28:
			{
				__reducedValues.push(this.action_28(__p));
				break;
			}
			case 29:
			{
				__reducedValues.push(this.action_29(__p));
				break;
			}
			case 30:
			{
				__reducedValues.push(this.action_30(__p));
				break;
			}
			case 31:
			{
				__reducedValues.push(this.action_31(__p));
				break;
			}
			case 32:
			{
				__reducedValues.push(this.action_32(__p));
				break;
			}
			case 33:
			{
				__reducedValues.push(this.action_33(__p));
				break;
			}
			case 34:
			{
				__reducedValues.push(this.action_34(__p));
				break;
			}
			case 35:
			{
				__reducedValues.push(this.action_35(__p));
				break;
			}
			case 36:
			{
				__reducedValues.push(this.action_36(__p));
				break;
			}
			case 37:
			{
				__reducedValues.push(this.action_37(__p));
				break;
			}
			case 38:
			{
				__reducedValues.push(this.action_38(__p));
				break;
			}
			case 39:
			{
				__reducedValues.push(this.action_39(__p));
				break;
			}
			case 40:
			{
				__reducedValues.push(this.action_40(__p));
				break;
			}
			case 41:
			{
				__reducedValues.push(this.action_41(__p));
				break;
			}
			case 42:
			{
				__reducedValues.push(this.action_42(__p));
				break;
			}
			case 43:
			{
				__reducedValues.push(this.action_43(__p));
				break;
			}
			case 44:
			{
				__reducedValues.push(this.action_44(__p));
				break;
			}
			case 45:
			{
				__reducedValues.push(this.action_45(__p));
				break;
			}
			case 46:
			{
				__reducedValues.push(this.action_46(__p));
				break;
			}
			case 47:
			{
				__reducedValues.push(this.action_47(__p));
				break;
			}
			case 48:
			{
				__reducedValues.push(this.action_48(__p));
				break;
			}
			case 49:
			{
				__reducedValues.push(this.action_49(__p));
				break;
			}
			case 50:
			{
				__reducedValues.push(this.action_50(__p));
				break;
			}
			case 51:
			{
				__reducedValues.push(this.action_51(__p));
				break;
			}
			case 52:
			{
				__reducedValues.push(this.action_52(__p));
				break;
			}
			case 53:
			{
				__reducedValues.push(this.action_53(__p));
				break;
			}
			case 54:
			{
				__reducedValues.push(this.action_54(__p));
				break;
			}
			case 55:
			{
				__reducedValues.push(this.action_55(__p));
				break;
			}
			case 56:
			{
				__reducedValues.push(this.action_56(__p));
				break;
			}
			case 57:
			{
				__reducedValues.push(this.action_57(__p));
				break;
			}
			case 58:
			{
				__reducedValues.push(this.action_58(__p));
				break;
			}
			case 59:
			{
				__reducedValues.push(this.action_59(__p));
				break;
			}
			case 60:
			{
				__reducedValues.push(this.action_60(__p));
				break;
			}
			case 61:
			{
				__reducedValues.push(this.action_61(__p));
				break;
			}
			case 62:
			{
				__reducedValues.push(this.action_62(__p));
				break;
			}
			case 63:
			{
				__reducedValues.push(this.action_63(__p));
				break;
			}
			case 64:
			{
				__reducedValues.push(this.action_64(__p));
				break;
			}
			case 65:
			{
				__reducedValues.push(this.action_65(__p));
				break;
			}
			case 66:
			{
				__reducedValues.push(this.action_66(__p));
				break;
			}
			case 67:
			{
				__reducedValues.push(this.action_67(__p));
				break;
			}
			case 68:
			{
				__reducedValues.push(this.action_68(__p));
				break;
			}
			case 69:
			{
				__reducedValues.push(this.action_69(__p));
				break;
			}
			case 70:
			{
				__reducedValues.push(this.action_70(__p));
				break;
			}
			case 71:
			{
				__reducedValues.push(this.action_71(__p));
				break;
			}
			case 72:
			{
				__reducedValues.push(this.action_72(__p));
				break;
			}
			case 73:
			{
				__reducedValues.push(this.action_73(__p));
				break;
			}
			case 74:
			{
				__reducedValues.push(this.action_74(__p));
				break;
			}
			case 75:
			{
				__reducedValues.push(this.action_75(__p));
				break;
			}
			case 76:
			{
				__reducedValues.push(this.action_76(__p));
				break;
			}
			case 77:
			{
				__reducedValues.push(this.action_77(__p));
				break;
			}
			case 78:
			{
				__reducedValues.push(this.action_78(__p));
				break;
			}
			case 79:
			{
				__reducedValues.push(this.action_79(__p));
				break;
			}
			case 80:
			{
				__reducedValues.push(this.action_80(__p));
				break;
			}
			case 81:
			{
				__reducedValues.push(this.action_81(__p));
				break;
			}
			case 82:
			{
				__reducedValues.push(this.action_82(__p));
				break;
			}
			case 83:
			{
				__reducedValues.push(this.action_83(__p));
				break;
			}
			case 84:
			{
				__reducedValues.push(this.action_84(__p));
				break;
			}
			case 85:
			{
				__reducedValues.push(this.action_85(__p));
				break;
			}
			case 86:
			{
				__reducedValues.push(this.action_86(__p));
				break;
			}
			case 87:
			{
				__reducedValues.push(this.action_87(__p));
				break;
			}
			case 88:
			{
				__reducedValues.push(this.action_88(__p));
				break;
			}
			case 89:
			{
				__reducedValues.push(this.action_89(__p));
				break;
			}
			case 90:
			{
				__reducedValues.push(this.action_90(__p));
				break;
			}
			case 91:
			{
				__reducedValues.push(this.action_91(__p));
				break;
			}
			case 92:
			{
				__reducedValues.push(this.action_92(__p));
				break;
			}
			case 93:
			{
				__reducedValues.push(this.action_93(__p));
				break;
			}
			case 94:
			{
				__reducedValues.push(this.action_94(__p));
				break;
			}
			case 95:
			{
				__reducedValues.push(this.action_95(__p));
				break;
			}
			case 96:
			{
				__reducedValues.push(this.action_96(__p));
				break;
			}
			case 97:
			{
				__reducedValues.push(this.action_97(__p));
				break;
			}
			case 98:
			{
				__reducedValues.push(this.action_98(__p));
				break;
			}
			case 99:
			{
				__reducedValues.push(this.action_99(__p));
				break;
			}
			case 100:
			{
				__reducedValues.push(this.action_100(__p));
				break;
			}
			case 101:
			{
				__reducedValues.push(this.action_101(__p));
				break;
			}
			case 102:
			{
				__reducedValues.push(this.action_102(__p));
				break;
			}
			case 103:
			{
				__reducedValues.push(this.action_103(__p));
				break;
			}
			case 104:
			{
				__reducedValues.push(this.action_104(__p));
				break;
			}
			case 105:
			{
				__reducedValues.push(this.action_105(__p));
				break;
			}
			case 106:
			{
				__reducedValues.push(this.action_106(__p));
				break;
			}
			case 107:
			{
				__reducedValues.push(this.action_107(__p));
				break;
			}
			case 108:
			{
				__reducedValues.push(this.action_108(__p));
				break;
			}
			case 109:
			{
				__reducedValues.push(this.action_109(__p));
				break;
			}
			case 110:
			{
				__reducedValues.push(this.action_110(__p));
				break;
			}
			case 111:
			{
				__reducedValues.push(this.action_111(__p));
				break;
			}
			case 112:
			{
				__reducedValues.push(this.action_112(__p));
				break;
			}
			case 113:
			{
				__reducedValues.push(this.action_113(__p));
				break;
			}
			case 114:
			{
				__reducedValues.push(this.action_114(__p));
				break;
			}
			case 115:
			{
				__reducedValues.push(this.action_115(__p));
				break;
			}
			case 116:
			{
				__reducedValues.push(this.action_116(__p));
				break;
			}
			case 117:
			{
				__reducedValues.push(this.action_117(__p));
				break;
			}
			case 118:
			{
				__reducedValues.push(this.action_118(__p));
				break;
			}
			case 119:
			{
				__reducedValues.push(this.action_119(__p));
				break;
			}
			case 120:
			{
				__reducedValues.push(this.action_120(__p));
				break;
			}
			case 121:
			{
				__reducedValues.push(this.action_121(__p));
				break;
			}
			case 122:
			{
				__reducedValues.push(this.action_122(__p));
				break;
			}
			case 123:
			{
				__reducedValues.push(this.action_123(__p));
				break;
			}
			case 124:
			{
				__reducedValues.push(this.action_124(__p));
				break;
			}
			case 125:
			{
				__reducedValues.push(this.action_125(__p));
				break;
			}
			case 126:
			{
				__reducedValues.push(this.action_126(__p));
				break;
			}
			case 127:
			{
				__reducedValues.push(this.action_127(__p));
				break;
			}
			case 128:
			{
				__reducedValues.push(this.action_128(__p));
				break;
			}
			case 129:
			{
				__reducedValues.push(this.action_129(__p));
				break;
			}
			case 130:
			{
				__reducedValues.push(this.action_130(__p));
				break;
			}
			case 131:
			{
				__reducedValues.push(this.action_131(__p));
				break;
			}
			case 132:
			{
				__reducedValues.push(this.action_132(__p));
				break;
			}
			case 133:
			{
				__reducedValues.push(this.action_133(__p));
				break;
			}
			case 134:
			{
				__reducedValues.push(this.action_134(__p));
				break;
			}
			case 135:
			{
				__reducedValues.push(this.action_135(__p));
				break;
			}
			case 136:
			{
				__reducedValues.push(this.action_136(__p));
				break;
			}
			case 137:
			{
				__reducedValues.push(this.action_137(__p));
				break;
			}
			case 138:
			{
				__reducedValues.push(this.action_138(__p));
				break;
			}
			case 139:
			{
				__reducedValues.push(this.action_139(__p));
				break;
			}
			case 140:
			{
				__reducedValues.push(this.action_140(__p));
				break;
			}
			case 141:
			{
				__reducedValues.push(this.action_141(__p));
				break;
			}
			case 142:
			{
				__reducedValues.push(this.action_142(__p));
				break;
			}
			case 143:
			{
				__reducedValues.push(this.action_143(__p));
				break;
			}
			case 144:
			{
				__reducedValues.push(this.action_144(__p));
				break;
			}
			case 145:
			{
				__reducedValues.push(this.action_145(__p));
				break;
			}
			case 146:
			{
				__reducedValues.push(this.action_146(__p));
				break;
			}
			case 147:
			{
				__reducedValues.push(this.action_147(__p));
				break;
			}
			case 148:
			{
				__reducedValues.push(this.action_148(__p));
				break;
			}
			case 149:
			{
				__reducedValues.push(this.action_149(__p));
				break;
			}
			case 150:
			{
				__reducedValues.push(this.action_150(__p));
				break;
			}
			case 151:
			{
				__reducedValues.push(this.action_151(__p));
				break;
			}
			case 152:
			{
				__reducedValues.push(this.action_152(__p));
				break;
			}
			case 153:
			{
				__reducedValues.push(this.action_153(__p));
				break;
			}
			case 154:
			{
				__reducedValues.push(this.action_154(__p));
				break;
			}
			case 155:
			{
				__reducedValues.push(this.action_155(__p));
				break;
			}
			case 156:
			{
				__reducedValues.push(this.action_156(__p));
				break;
			}
			case 157:
			{
				__reducedValues.push(this.action_157(__p));
				break;
			}
			case 158:
			{
				__reducedValues.push(this.action_158(__p));
				break;
			}
			case 159:
			{
				__reducedValues.push(this.action_159(__p));
				break;
			}
			case 160:
			{
				__reducedValues.push(this.action_160(__p));
				break;
			}
			case 161:
			{
				__reducedValues.push(this.action_161(__p));
				break;
			}
			case 162:
			{
				__reducedValues.push(this.action_162(__p));
				break;
			}
			case 163:
			{
				__reducedValues.push(this.action_163(__p));
				break;
			}
			case 164:
			{
				__reducedValues.push(this.action_164(__p));
				break;
			}
			case 165:
			{
				__reducedValues.push(this.action_165(__p));
				break;
			}
			case 166:
			{
				__reducedValues.push(this.action_166(__p));
				break;
			}
			case 167:
			{
				__reducedValues.push(this.action_167(__p));
				break;
			}
			case 168:
			{
				__reducedValues.push(this.action_168(__p));
				break;
			}
			case 169:
			{
				__reducedValues.push(this.action_169(__p));
				break;
			}
			case 170:
			{
				__reducedValues.push(this.action_170(__p));
				break;
			}
			case 171:
			{
				__reducedValues.push(this.action_171(__p));
				break;
			}
			case 172:
			{
				__reducedValues.push(this.action_172(__p));
				break;
			}
			case 173:
			{
				__reducedValues.push(this.action_173(__p));
				break;
			}
			case 174:
			{
				__reducedValues.push(this.action_174(__p));
				break;
			}
			case 175:
			{
				__reducedValues.push(this.action_175(__p));
				break;
			}
			case 176:
			{
				__reducedValues.push(this.action_176(__p));
				break;
			}
			case 177:
			{
				__reducedValues.push(this.action_177(__p));
				break;
			}
			case 178:
			{
				__reducedValues.push(this.action_178(__p));
				break;
			}
			case 179:
			{
				__reducedValues.push(this.action_179(__p));
				break;
			}
			case 180:
			{
				__reducedValues.push(this.action_180(__p));
				break;
			}
			case 181:
			{
				__reducedValues.push(this.action_181(__p));
				break;
			}
			case 182:
			{
				__reducedValues.push(this.action_182(__p));
				break;
			}
			case 183:
			{
				__reducedValues.push(this.action_183(__p));
				break;
			}
			case 184:
			{
				__reducedValues.push(this.action_184(__p));
				break;
			}
			case 185:
			{
				__reducedValues.push(this.action_185(__p));
				break;
			}
			case 186:
			{
				__reducedValues.push(this.action_186(__p));
				break;
			}
			case 187:
			{
				__reducedValues.push(this.action_187(__p));
				break;
			}
			case 188:
			{
				__reducedValues.push(this.action_188(__p));
				break;
			}
			case 189:
			{
				__reducedValues.push(this.action_189(__p));
				break;
			}
			case 190:
			{
				__reducedValues.push(this.action_190(__p));
				break;
			}
			case 191:
			{
				__reducedValues.push(this.action_191(__p));
				break;
			}
			case 192:
			{
				__reducedValues.push(this.action_192(__p));
				break;
			}
			case 193:
			{
				__reducedValues.push(this.action_193(__p));
				break;
			}
			case 194:
			{
				__reducedValues.push(this.action_194(__p));
				break;
			}
			case 195:
			{
				__reducedValues.push(this.action_195(__p));
				break;
			}
			case 196:
			{
				__reducedValues.push(this.action_196(__p));
				break;
			}
			case 197:
			{
				__reducedValues.push(this.action_197(__p));
				break;
			}
			case 198:
			{
				__reducedValues.push(this.action_198(__p));
				break;
			}
			case 199:
			{
				__reducedValues.push(this.action_199(__p));
				break;
			}
			case 200:
			{
				this.reduceAntecedent(___node, __array_literal_NT);
				__reducedValues.push(this.action_200(__p));
				break;
			}
			case 201:
			{
				this.reduceAntecedent(___node, __e4x_literal_NT);
				__reducedValues.push(this.action_201(__p));
				break;
			}
			case 202:
			{
				this.reduceAntecedent(___node, __uint_constant_NT);
				__reducedValues.push(this.action_202(__p));
				break;
			}
			case 203:
			{
				this.reduceAntecedent(___node, __float_constant_NT);
				__reducedValues.push(this.action_203(__p));
				break;
			}
			case 204:
			{
				this.reduceAntecedent(___node, __name_NT);
				__reducedValues.push(this.action_204(__p));
				break;
			}
			case 205:
			{
				this.reduceAntecedent(___node, __expression_NT);
				__reducedValues.push(this.action_205(__p));
				break;
			}
			case 206:
			{
				this.reduceAntecedent(___node, __object_literal_NT);
				__reducedValues.push(this.action_206(__p));
				break;
			}
			case 207:
			{
				this.reduceAntecedent(___node, __qualifiedNamePart_NT);
				__reducedValues.push(this.action_207(__p));
				break;
			}
			case 208:
			{
				this.reduceAntecedent(___node, __literal_NT);
				__reducedValues.push(this.action_208(__p));
				break;
			}
			case 209:
			{
				this.reduceAntecedent(___node, __double_constant_NT);
				__reducedValues.push(this.action_209(__p));
				break;
			}
			case 210:
			{
				this.reduceAntecedent(___node, __boolean_literal_NT);
				__reducedValues.push(this.action_210(__p));
				break;
			}
			case 211:
			{
				this.reduceAntecedent(___node, __integer_constant_NT);
				__reducedValues.push(this.action_211(__p));
				break;
			}
			case 212:
			{
				this.reduceAntecedent(___node, __constant_value_NT);
				__reducedValues.push(this.action_212(__p));
				break;
			}
			case 213:
			{
				this.reduceAntecedent(___node, __comparison_expression_NT);
				__reducedValues.push(this.action_213(__p));
				break;
			}
			default:
			{
				throw new IllegalStateException("Unmatched reduce action " + iRule);
			}
		}
	}

	class JBurgAnnotation_ArrayIndexExpressionID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_ArrayIndexExpressionID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_19f5ce75(goalState);

						int currentCost = getCostForRule_73120769(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_303dd361(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_19f5ce75(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 30;
					}
					currentCost = getCostForRule_73120769(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 174;
					}
					currentCost = getCostForRule_303dd361(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 184;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_19f5ce75( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
		
		private int getCostForRule_73120769( int goalState)
		{

			if ( this.getNthChild(0).getArity() == 0 && this.getNthChild(0).getOperator() == Op_AtID )
				return(normalizeCost((long)1 + (long)((long)this.getNthChild(1).getCost(__expression_NT))));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_303dd361( int goalState)
		{

			if ( this.getNthChild(0).getArity() == 0 && this.getNthChild(0).getOperator() == SuperID )
				return(normalizeCost((long)1 + (long)((long)this.getNthChild(1).getCost(__expression_NT))));
			else
				return(Integer.MAX_VALUE);
		}
	}

	class JBurgAnnotation_ArrayLiteralID_1_n extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private java.util.Vector narySubtrees = new java.util.Vector();
		JBurgAnnotation_ArrayLiteralID_1_n(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_array_literal = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __array_literal_NT:
				{
					if ( cachedCostFor_array_literal == -1 )
					{
						cachedCostFor_array_literal = getCostForRule_2e5fb7f0(goalState);

					}
					return(cachedCostFor_array_literal);
				}
				case __expression_NT:
				{
					return(getCost(__literal_NT));
				}
				case __literal_NT:
				{
					return(getCost(__array_literal_NT));
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __array_literal_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_2e5fb7f0(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 31;
					}
					return(rule);
				}
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__literal_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 208;
					}
					return(rule);
				}
				case __literal_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__array_literal_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 200;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1 + narySubtrees.size());
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					return narySubtrees.get(index - 1);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				narySubtrees.add(child);
		}
		
		private int getCostForRule_2e5fb7f0( int goalState)
		{

			if ( this.getArity() == 1 && this.getNthChild(0).getOperator() == ContainerID )
				return(normalizeCost((long)1 + (long)((long)getNaryCost(this.getNthChild(0), __expression_NT, 0))));
			else
				return(Integer.MAX_VALUE);
		}
	}

	class JBurgAnnotation_E4XFilterID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_E4XFilterID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_196e5228(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_196e5228(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 101;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_196e5228( int goalState)
		{

			return(normalizeCost((long)3 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_EmbedID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_EmbedID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					return(2);
				}
				case __required_constant_value_NT:
				{
					return(268435458);
				}
				case __type_param_expression_NT:
				{
					return(2);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					return(102);
				}
				case __required_constant_value_NT:
				{
					return(11);
				}
				case __type_param_expression_NT:
				{
					return(205);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
	}

	class JBurgAnnotation_FoldedExpressionID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_FoldedExpressionID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __foldedExpression_NT:
				{
					return(1);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __foldedExpression_NT:
				{
					return(104);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
	}

	class JBurgAnnotation_FullNameID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_FullNameID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_name = -1;
		private int cachedCostFor_dottedNamePart = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __dottedNamePart_NT:
				{
					if ( cachedCostFor_dottedNamePart == -1 )
					{
						cachedCostFor_dottedNamePart = getCostForRule_7a242723(goalState);

					}
					return(cachedCostFor_dottedNamePart);
				}
				case __expression_NT:
				{
					return(normalizeCost((long)2000 + (long)getCost(__name_NT)));
				}
				case __name_NT:
				{
					if ( cachedCostFor_name == -1 )
					{
						cachedCostFor_name = getCostForRule_245c45dd(goalState);

					}
					return(cachedCostFor_name);
				}
				case __new_type_name_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)20 + (long)getCost(__type_name_NT));

					int currentCost = getCost(__name_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_name_NT:
				{
					return(normalizeCost((long)1 + (long)getCost(__name_NT)));
				}
				case __type_param_expression_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)getCostFunctionResult_a1e6528e() + (long)getCost(__name_NT));

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __dottedNamePart_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_7a242723(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 106;
					}
					return(rule);
				}
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)2000 + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 5;
					}
					return(rule);
				}
				case __name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_245c45dd(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 105;
					}
					return(rule);
				}
				case __new_type_name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)20 + (long)getCost(__type_name_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 3;
					}
					currentCost = getCost(__name_NT);
					if ( ( bestCost > currentCost )  )
					{
						rule = 204;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)1 + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 2;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)getCostFunctionResult_a1e6528e() + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 4;
					}
					currentCost = getCost(__expression_NT);
					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		private int cachedCostFunctionResult_cab71592 = -1;
		
		private int getCostFunctionResult_a1e6528e( )
		{
			if ( cachedCostFunctionResult_cab71592 == -1 )
				cachedCostFunctionResult_cab71592 = isKnownType(m_node);
			return(cachedCostFunctionResult_cab71592);
		}
		
		private int getCostForRule_245c45dd( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__dottedNamePart_NT)) + ((long)this.getNthChild(0).getCost(__dottedNamePart_NT))) ));
		}
		
		private int getCostForRule_7a242723( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__dottedNamePart_NT)) + ((long)this.getNthChild(0).getCost(__dottedNamePart_NT))) ));
		}
	}

	class JBurgAnnotation_FunctionCallID_2_n extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		private java.util.Vector narySubtrees = new java.util.Vector();
		JBurgAnnotation_FunctionCallID_2_n(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_776f9691(goalState);

						int currentCost = getCostForRule_1c7b6546(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_47bd44d5(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_1098352(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_a5946fc(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_4dcf53a4(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_60792d24(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_2d27216a(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_6d09ec94(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_5a6cc0e2(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_73d5d686(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_776f9691(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 107;
					}
					currentCost = getCostForRule_1c7b6546(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 108;
					}
					currentCost = getCostForRule_47bd44d5(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 109;
					}
					currentCost = getCostForRule_1098352(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 110;
					}
					currentCost = getCostForRule_a5946fc(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 111;
					}
					currentCost = getCostForRule_4dcf53a4(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 112;
					}
					currentCost = getCostForRule_60792d24(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 113;
					}
					currentCost = getCostForRule_2d27216a(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 135;
					}
					currentCost = getCostForRule_6d09ec94(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 136;
					}
					currentCost = getCostForRule_5a6cc0e2(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 137;
					}
					currentCost = getCostForRule_73d5d686(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 138;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2 + narySubtrees.size());
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					return narySubtrees.get(index - 2);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				narySubtrees.add(child);
		}
		
		private int getCostForRule_776f9691( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getArity() == 2 && this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID && this.getNthChild(1).getOperator() == ContainerID )
				return(normalizeCost((long)4 + (long) ( (((long)getNaryCost(this.getNthChild(1), __expression_NT, 0)) + ((long)factoredPath_1.getCost(__expression_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_1c7b6546( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getArity() == 2 && this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID && this.getNthChild(1).getOperator() == ContainerID )
				return(normalizeCost((long)4 + (long) ( (((long)getNaryCost(this.getNthChild(1), __expression_NT, 0)) + ((long)factoredPath_1.getCost(__name_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_47bd44d5( int goalState)
		{

			if ( this.getArity() == 2 && this.getNthChild(1).getOperator() == ContainerID )
				return(normalizeCost((long)30 + (long) (((long)getNaryCost(this.getNthChild(1), __expression_NT, 0)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_1098352( int goalState)
		{

			if ( this.getArity() == 2 && this.getNthChild(1).getOperator() == ContainerID )
				return(normalizeCost((long)3 + (long) (((long)getNaryCost(this.getNthChild(1), __expression_NT, 0)) + ((long)this.getNthChild(0).getCost(__name_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_a5946fc( int goalState)
		{
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);
			JBurgAnnotation factoredPath_4 = (((this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation).getArity() > 1? (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation).getNthChild(1): errorAnnotation).getArity() > 0? ((this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation).getArity() > 1? (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation).getNthChild(1): errorAnnotation).getNthChild(0): errorAnnotation);

			if ( this.getArity() == 2 && this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID && this.getNthChild(0).getNthChild(0).getArity() == 2 && this.getNthChild(0).getNthChild(0).getOperator() == FunctionCallID && this.getNthChild(0).getNthChild(0).getNthChild(0).getArity() == 0 && this.getNthChild(0).getNthChild(0).getNthChild(0).getOperator() == SuperID && this.getNthChild(0).getNthChild(0).getNthChild(1).getArity() == 1 && this.getNthChild(0).getNthChild(0).getNthChild(1).getOperator() == ContainerID && this.getNthChild(1).getOperator() == ContainerID )
				return(normalizeCost((long)2 + (long) ( (((long)getNaryCost(this.getNthChild(1), __expression_NT, 0)) + ((long)factoredPath_1.getCost(__name_NT)))  + ((long)factoredPath_4.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_4dcf53a4( int goalState)
		{
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getArity() == 2 && this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID && this.getNthChild(0).getNthChild(0).getArity() == 0 && this.getNthChild(0).getNthChild(0).getOperator() == SuperID && this.getNthChild(1).getOperator() == ContainerID )
				return(normalizeCost((long)2 + (long) (((long)getNaryCost(this.getNthChild(1), __expression_NT, 0)) + ((long)factoredPath_1.getCost(__name_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_60792d24( int goalState)
		{

			if ( this.getArity() == 2 && this.getNthChild(0).getArity() == 0 && this.getNthChild(0).getOperator() == IdentifierID && this.getNthChild(1).getOperator() == ContainerID )
				return(normalizeCost((long)1 + (long)((long)getNaryCost(this.getNthChild(1), __expression_NT, 0))));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_2d27216a( int goalState)
		{

			if ( this.getArity() == 3 && this.getNthChild(0).getArity() == 0 && this.getNthChild(0).getOperator() == KeywordNewID && this.getNthChild(2).getOperator() == ContainerID )
				return(normalizeCost((long)30 + (long) (((long)getNaryCost(this.getNthChild(2), __expression_NT, 0)) + ((long)this.getNthChild(1).getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_6d09ec94( int goalState)
		{

			if ( this.getArity() == 3 && this.getNthChild(0).getArity() == 0 && this.getNthChild(0).getOperator() == KeywordNewID && this.getNthChild(2).getOperator() == ContainerID )
				return(normalizeCost((long)2 + (long) (((long)getNaryCost(this.getNthChild(2), __expression_NT, 0)) + ((long)this.getNthChild(1).getCost(__new_type_name_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_5a6cc0e2( int goalState)
		{
			JBurgAnnotation factoredPath_2 = (this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_3 = (this.getNthChild(1).getArity() > 1? this.getNthChild(1).getNthChild(1): errorAnnotation);

			if ( this.getArity() == 3 && this.getNthChild(0).getArity() == 0 && this.getNthChild(0).getOperator() == KeywordNewID && this.getNthChild(1).getArity() == 2 && this.getNthChild(1).getOperator() == MemberAccessExpressionID && this.getNthChild(2).getOperator() == ContainerID )
				return(normalizeCost((long)10 + (long) ( (((long)getNaryCost(this.getNthChild(2), __expression_NT, 0)) + ((long)factoredPath_3.getCost(__name_NT)))  + ((long)factoredPath_2.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_73d5d686( int goalState)
		{

			if ( this.getArity() == 3 && this.getNthChild(0).getArity() == 0 && this.getNthChild(0).getOperator() == KeywordNewID && this.getNthChild(2).getArity() == 0 && this.getNthChild(2).getOperator() == ContainerID )
				return(normalizeCost((long)0 + (long)((long)this.getNthChild(1).getCost(__vector_literal_NT))));
			else
				return(Integer.MAX_VALUE);
		}
	}

	class JBurgAnnotation_IdentifierID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_IdentifierID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __decl_name_NT:
				{
					return(0);
				}
				case __dottedNamePart_NT:
				{
					return(0);
				}
				case __expression_NT:
				{
					return(2000);
				}
				case __name_NT:
				{
					return(0);
				}
				case __new_type_name_NT:
				{
					return(0);
				}
				case __qualifiedNamePart_NT:
				{
					return(0);
				}
				case __required_constant_value_NT:
				{
					return(268437456);
				}
				case __type_name_NT:
				{
					return(1);
				}
				case __type_param_expression_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)getCostFunctionResult_a1e6528e() + (long)getCost(__name_NT));

					if ( ( bestCost > 2000 )  )
						bestCost = 2000;
					return(bestCost);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __decl_name_NT:
				{
					return(178);
				}
				case __dottedNamePart_NT:
				{
					return(207);
				}
				case __expression_NT:
				{
					return(5);
				}
				case __name_NT:
				{
					return(176);
				}
				case __new_type_name_NT:
				{
					return(204);
				}
				case __qualifiedNamePart_NT:
				{
					return(177);
				}
				case __required_constant_value_NT:
				{
					return(11);
				}
				case __type_name_NT:
				{
					return(2);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)getCostFunctionResult_a1e6528e() + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 4;
					}
					if ( ( bestCost > 2000 )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
		private int cachedCostFunctionResult_cab71592 = -1;
		
		private int getCostFunctionResult_a1e6528e( )
		{
			if ( cachedCostFunctionResult_cab71592 == -1 )
				cachedCostFunctionResult_cab71592 = isKnownType(m_node);
			return(cachedCostFunctionResult_cab71592);
		}
	}

	class JBurgAnnotation_LiteralBooleanID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_LiteralBooleanID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __boolean_constant_NT:
				{
					return(0);
				}
				case __boolean_literal_NT:
				{
					return(1);
				}
				case __constant_value_NT:
				{
					return(1);
				}
				case __expression_NT:
				{
					return(1);
				}
				case __literal_NT:
				{
					return(1);
				}
				case __required_constant_value_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > 1 )  )
						bestCost = 1;
					return(bestCost);
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __boolean_constant_NT:
				{
					return(86);
				}
				case __boolean_literal_NT:
				{
					return(24);
				}
				case __constant_value_NT:
				{
					return(16);
				}
				case __expression_NT:
				{
					return(10);
				}
				case __literal_NT:
				{
					return(210);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 11;
					}
					if ( ( bestCost > 1 )  )
					{
						rule = 212;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
	}

	class JBurgAnnotation_LiteralDoubleID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_LiteralDoubleID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					return(normalizeCost((long)1 + (long)getCost(__numeric_constant_NT)));
				}
				case __double_constant_NT:
				{
					return(cachedCost_93d73ad());
				}
				case __expression_NT:
				{
					int bestCost;

					bestCost = getCost(__constant_value_NT);

					int currentCost = normalizeCost((long)5 + (long)getCost(__numeric_constant_NT));

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					currentCost = normalizeCost((long)5 + (long)getCost(__double_constant_NT));
					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
				case __numeric_constant_NT:
				{
					return(getCost(__double_constant_NT));
				}
				case __required_constant_value_NT:
				{
					int bestCost;

					bestCost = getCost(__constant_value_NT);

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)1 + (long)getCost(__numeric_constant_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 17;
					}
					return(rule);
				}
				case __double_constant_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = cachedCost_93d73ad();

					if ( ( bestCost > currentCost )  )
					{
						rule = 100;
					}
					return(rule);
				}
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__constant_value_NT);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 22;
					}
					currentCost = normalizeCost((long)5 + (long)getCost(__numeric_constant_NT));
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 20;
					}
					currentCost = normalizeCost((long)5 + (long)getCost(__double_constant_NT));
					if ( ( bestCost > currentCost )  )
					{
						rule = 18;
					}
					return(rule);
				}
				case __numeric_constant_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__double_constant_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 209;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__constant_value_NT);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 212;
					}
					currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));
					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
		private int cachedCostFunctionResult_c81f7f59 = -1;
		
		private int cachedCost_93d73ad( )
		{
			if ( cachedCostFunctionResult_c81f7f59 == -1 )
				cachedCostFunctionResult_c81f7f59 = isDoubleLiteral(m_node);
			return(cachedCostFunctionResult_c81f7f59);
		}
	}

	class JBurgAnnotation_LiteralIntegerID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_LiteralIntegerID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					return(2);
				}
				case __expression_NT:
				{
					return(2);
				}
				case __integer_constant_NT:
				{
					return(1);
				}
				case __numeric_constant_NT:
				{
					return(1);
				}
				case __required_constant_value_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > 2 )  )
						bestCost = 2;
					return(bestCost);
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					return(17);
				}
				case __expression_NT:
				{
					return(8);
				}
				case __integer_constant_NT:
				{
					return(13);
				}
				case __numeric_constant_NT:
				{
					return(211);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 11;
					}
					if ( ( bestCost > 2 )  )
					{
						rule = 212;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
	}

	class JBurgAnnotation_LiteralIntegerZeroID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_LiteralIntegerZeroID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					return(normalizeCost((long)1 + (long)getCost(__numeric_constant_NT)));
				}
				case __expression_NT:
				{
					int bestCost;

					bestCost = 2;

					int currentCost = getCost(__constant_value_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					currentCost = normalizeCost((long)5 + (long)getCost(__numeric_constant_NT));
					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					if ( ( bestCost > 6 )  )
						bestCost = 6;
					if ( ( bestCost > 2 )  )
						bestCost = 2;
					return(bestCost);
				}
				case __integer_constant_NT:
				{
					return(1);
				}
				case __numeric_constant_NT:
				{
					return(1);
				}
				case __required_constant_value_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					int currentCost = getCost(__constant_value_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
				case __uint_constant_NT:
				{
					return(1);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)1 + (long)getCost(__numeric_constant_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 17;
					}
					return(rule);
				}
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					bestCost = 2;
					rule = 8;
					int currentCost = getCost(__constant_value_NT);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 22;
					}
					currentCost = normalizeCost((long)5 + (long)getCost(__numeric_constant_NT));
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 20;
					}
					if ( ( bestCost > 6 )  )
					{
						bestCost = 6;
						rule = 19;
					}
					if ( ( bestCost > 2 )  )
					{
						rule = 9;
					}
					return(rule);
				}
				case __integer_constant_NT:
				{
					return(12);
				}
				case __numeric_constant_NT:
				{
					return(211);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 11;
					}
					currentCost = getCost(__constant_value_NT);
					if ( ( bestCost > currentCost )  )
					{
						rule = 212;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
				case __uint_constant_NT:
				{
					return(14);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
	}

	class JBurgAnnotation_LiteralNullID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_LiteralNullID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					return(0);
				}
				case __expression_NT:
				{
					return(0);
				}
				case __literal_NT:
				{
					return(1);
				}
				case __object_literal_NT:
				{
					return(1);
				}
				case __required_constant_value_NT:
				{
					int bestCost;

					bestCost = 0;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					return(141);
				}
				case __expression_NT:
				{
					return(22);
				}
				case __literal_NT:
				{
					return(206);
				}
				case __object_literal_NT:
				{
					return(142);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					bestCost = 0;
					rule = 212;
					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
	}

	class JBurgAnnotation_LiteralNumberID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_LiteralNumberID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					return(normalizeCost((long)1 + (long)getCost(__numeric_constant_NT)));
				}
				case __double_constant_NT:
				{
					int bestCost;

					bestCost = cachedCost_93d73ad();

					if ( ( bestCost > 3 )  )
						bestCost = 3;
					return(bestCost);
				}
				case __expression_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)1 + (long)getCost(__integer_constant_NT));

					int currentCost = getCost(__constant_value_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					currentCost = normalizeCost((long)5 + (long)getCost(__numeric_constant_NT));
					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					currentCost = normalizeCost((long)5 + (long)getCost(__integer_constant_NT));
					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					currentCost = normalizeCost((long)1 + (long)getCost(__uint_constant_NT));
					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					currentCost = normalizeCost((long)5 + (long)getCost(__float_constant_NT));
					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					currentCost = normalizeCost((long)5 + (long)getCost(__double_constant_NT));
					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
				case __float_constant_NT:
				{
					return(cachedCost_11f1fae4());
				}
				case __integer_constant_NT:
				{
					return(cachedCost_bd6f3177());
				}
				case __numeric_constant_NT:
				{
					int bestCost;

					bestCost = getCost(__integer_constant_NT);

					int currentCost = getCost(__uint_constant_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					currentCost = getCost(__float_constant_NT);
					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					currentCost = getCost(__double_constant_NT);
					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
				case __required_constant_value_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					int currentCost = getCost(__constant_value_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
				case __uint_constant_NT:
				{
					return(cachedCost_bd6f3177());
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)1 + (long)getCost(__numeric_constant_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 17;
					}
					return(rule);
				}
				case __double_constant_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = cachedCost_93d73ad();

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 146;
					}
					if ( ( bestCost > 3 )  )
					{
						rule = 147;
					}
					return(rule);
				}
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)1 + (long)getCost(__integer_constant_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 8;
					}
					currentCost = getCost(__constant_value_NT);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 22;
					}
					currentCost = normalizeCost((long)5 + (long)getCost(__numeric_constant_NT));
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 20;
					}
					currentCost = normalizeCost((long)5 + (long)getCost(__integer_constant_NT));
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 19;
					}
					currentCost = normalizeCost((long)1 + (long)getCost(__uint_constant_NT));
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 9;
					}
					currentCost = normalizeCost((long)5 + (long)getCost(__float_constant_NT));
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 21;
					}
					currentCost = normalizeCost((long)5 + (long)getCost(__double_constant_NT));
					if ( ( bestCost > currentCost )  )
					{
						rule = 18;
					}
					return(rule);
				}
				case __float_constant_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = cachedCost_11f1fae4();

					if ( ( bestCost > currentCost )  )
					{
						rule = 145;
					}
					return(rule);
				}
				case __integer_constant_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = cachedCost_bd6f3177();

					if ( ( bestCost > currentCost )  )
					{
						rule = 143;
					}
					return(rule);
				}
				case __numeric_constant_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__integer_constant_NT);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 211;
					}
					currentCost = getCost(__uint_constant_NT);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 202;
					}
					currentCost = getCost(__float_constant_NT);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 203;
					}
					currentCost = getCost(__double_constant_NT);
					if ( ( bestCost > currentCost )  )
					{
						rule = 209;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 11;
					}
					currentCost = getCost(__constant_value_NT);
					if ( ( bestCost > currentCost )  )
					{
						rule = 212;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
				case __uint_constant_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = cachedCost_bd6f3177();

					if ( ( bestCost > currentCost )  )
					{
						rule = 144;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
		private int cachedCostFunctionResult_b3089da0 = -1;
		
		private int cachedCost_bd6f3177( )
		{
			if ( cachedCostFunctionResult_b3089da0 == -1 )
				cachedCostFunctionResult_b3089da0 = isIntLiteral(m_node);
			return(cachedCostFunctionResult_b3089da0);
		}
		private int cachedCostFunctionResult_9626e1c5 = -1;
		
		private int cachedCost_11f1fae4( )
		{
			if ( cachedCostFunctionResult_9626e1c5 == -1 )
				cachedCostFunctionResult_9626e1c5 = isFloatLiteral(m_node);
			return(cachedCostFunctionResult_9626e1c5);
		}
		private int cachedCostFunctionResult_c81f7f59 = -1;
		
		private int cachedCost_93d73ad( )
		{
			if ( cachedCostFunctionResult_c81f7f59 == -1 )
				cachedCostFunctionResult_c81f7f59 = isDoubleLiteral(m_node);
			return(cachedCostFunctionResult_c81f7f59);
		}
	}

	class JBurgAnnotation_LiteralObjectID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_LiteralObjectID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					return(0);
				}
				case __expression_NT:
				{
					return(0);
				}
				case __literal_NT:
				{
					return(1);
				}
				case __object_literal_NT:
				{
					return(1);
				}
				case __required_constant_value_NT:
				{
					int bestCost;

					bestCost = 0;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					return(194);
				}
				case __expression_NT:
				{
					return(22);
				}
				case __literal_NT:
				{
					return(206);
				}
				case __object_literal_NT:
				{
					return(195);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					bestCost = 0;
					rule = 212;
					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
	}

	class JBurgAnnotation_LiteralRegexID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_LiteralRegexID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					return(5);
				}
				case __literal_NT:
				{
					return(5);
				}
				case __object_literal_NT:
				{
					return(5);
				}
				case __required_constant_value_NT:
				{
					return(268435461);
				}
				case __type_param_expression_NT:
				{
					return(5);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					return(208);
				}
				case __literal_NT:
				{
					return(206);
				}
				case __object_literal_NT:
				{
					return(173);
				}
				case __required_constant_value_NT:
				{
					return(11);
				}
				case __type_param_expression_NT:
				{
					return(205);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
	}

	class JBurgAnnotation_LiteralStringID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_LiteralStringID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					return(1);
				}
				case __expression_NT:
				{
					return(1);
				}
				case __required_constant_value_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > 1 )  )
						bestCost = 1;
					return(bestCost);
				}
				case __string_constant_NT:
				{
					return(0);
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					return(15);
				}
				case __expression_NT:
				{
					return(7);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 11;
					}
					if ( ( bestCost > 1 )  )
					{
						rule = 212;
					}
					return(rule);
				}
				case __string_constant_NT:
				{
					return(181);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
	}

	class JBurgAnnotation_LiteralXMLID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_LiteralXMLID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					return(1);
				}
				case __e4x_literal_NT:
				{
					return(0);
				}
				case __expression_NT:
				{
					return(1);
				}
				case __required_constant_value_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > 1 )  )
						bestCost = 1;
					return(bestCost);
				}
				case __string_constant_NT:
				{
					return(0);
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					return(15);
				}
				case __e4x_literal_NT:
				{
					return(28);
				}
				case __expression_NT:
				{
					return(7);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 11;
					}
					if ( ( bestCost > 1 )  )
					{
						rule = 212;
					}
					return(rule);
				}
				case __string_constant_NT:
				{
					return(201);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
	}

	class JBurgAnnotation_MemberAccessExpressionID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_MemberAccessExpressionID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		private int cachedCostFor_name = -1;
		private int cachedCostFor_dottedNamePart = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __dottedNamePart_NT:
				{
					if ( cachedCostFor_dottedNamePart == -1 )
					{
						cachedCostFor_dottedNamePart = getCostForRule_67ed95e7(goalState);

					}
					return(cachedCostFor_dottedNamePart);
				}
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_45a2a8c2(goalState);

						int currentCost = getCostForRule_79f50b44(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_24c9931a(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_2f0068c9(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_7f343153(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_2ecaaada(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = normalizeCost((long)2000 + (long)getCost(__name_NT));
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __name_NT:
				{
					if ( cachedCostFor_name == -1 )
					{
						cachedCostFor_name = getCostForRule_4673ad5a(goalState);

						int currentCost = getCostForRule_6a19c37d(goalState);

						if ( ( cachedCostFor_name > currentCost )  )
							cachedCostFor_name = currentCost;
						currentCost = getCostForRule_34f9d9c4(goalState);
						if ( ( cachedCostFor_name > currentCost )  )
							cachedCostFor_name = currentCost;
					}
					return(cachedCostFor_name);
				}
				case __new_type_name_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)20 + (long)getCost(__type_name_NT));

					int currentCost = getCost(__name_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_name_NT:
				{
					return(normalizeCost((long)1 + (long)getCost(__name_NT)));
				}
				case __type_param_expression_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)getCostFunctionResult_a1e6528e() + (long)getCost(__name_NT));

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __dottedNamePart_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_67ed95e7(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 97;
					}
					return(rule);
				}
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_45a2a8c2(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 124;
					}
					currentCost = getCostForRule_79f50b44(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 164;
					}
					currentCost = getCostForRule_24c9931a(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 165;
					}
					currentCost = getCostForRule_2f0068c9(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 170;
					}
					currentCost = getCostForRule_7f343153(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 171;
					}
					currentCost = getCostForRule_2ecaaada(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 191;
					}
					currentCost = normalizeCost((long)2000 + (long)getCost(__name_NT));
					if ( ( bestCost > currentCost )  )
					{
						rule = 5;
					}
					return(rule);
				}
				case __name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_4673ad5a(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 98;
					}
					currentCost = getCostForRule_6a19c37d(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 99;
					}
					currentCost = getCostForRule_34f9d9c4(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 183;
					}
					return(rule);
				}
				case __new_type_name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)20 + (long)getCost(__type_name_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 3;
					}
					currentCost = getCost(__name_NT);
					if ( ( bestCost > currentCost )  )
					{
						rule = 204;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)1 + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 2;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)getCostFunctionResult_a1e6528e() + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 4;
					}
					currentCost = getCost(__expression_NT);
					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		private int cachedCostFunctionResult_cab71592 = -1;
		
		private int getCostFunctionResult_a1e6528e( )
		{
			if ( cachedCostFunctionResult_cab71592 == -1 )
				cachedCostFunctionResult_cab71592 = isKnownType(m_node);
			return(cachedCostFunctionResult_cab71592);
		}
		
		private int getCostForRule_67ed95e7( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__dottedNamePart_NT)) + ((long)this.getNthChild(0).getCost(__dottedNamePart_NT))) ));
		}
		
		private int getCostForRule_4673ad5a( int goalState)
		{

			return(normalizeCost((long)cachedCost_b05ac882() + (long) (((long)this.getNthChild(1).getCost(__dottedNamePart_NT)) + ((long)this.getNthChild(0).getCost(__dottedNamePart_NT))) ));
		}
		private int cachedCostFunctionResult_f25f3279 = -1;
		
		private int cachedCost_b05ac882( )
		{
			if ( cachedCostFunctionResult_f25f3279 == -1 )
				cachedCostFunctionResult_f25f3279 = isDottedName(m_node);
			return(cachedCostFunctionResult_f25f3279);
		}
		
		private int getCostForRule_6a19c37d( int goalState)
		{

			return(normalizeCost((long)cachedCost_609fc9ba() + (long) (((long)this.getNthChild(1).getCost(__dottedNamePart_NT)) + ((long)this.getNthChild(0).getCost(__dottedNamePart_NT))) ));
		}
		private int cachedCostFunctionResult_1ec55d2c = -1;
		
		private int cachedCost_609fc9ba( )
		{
			if ( cachedCostFunctionResult_1ec55d2c == -1 )
				cachedCostFunctionResult_1ec55d2c = isPackageName(m_node);
			return(cachedCostFunctionResult_1ec55d2c);
		}
		
		private int getCostForRule_45a2a8c2( int goalState)
		{

			return(normalizeCost((long)10 + (long) (((long)this.getNthChild(1).getCost(__name_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
		
		private int getCostForRule_79f50b44( int goalState)
		{
			JBurgAnnotation factoredPath_2 = ((this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation).getArity() > 0? (this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_3 = ((this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation).getArity() > 1? (this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(1).getArity() == 1 && this.getNthChild(1).getOperator() == Op_AtID && this.getNthChild(1).getNthChild(0).getArity() == 2 && this.getNthChild(1).getNthChild(0).getOperator() == NamespaceAccessExpressionID )
				return(normalizeCost((long)1 + (long) ( (((long)factoredPath_3.getCost(__name_NT)) + ((long)factoredPath_2.getCost(__name_NT)))  + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_24c9931a( int goalState)
		{
			JBurgAnnotation factoredPath_2 = ((this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation).getArity() > 0? (this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_3 = ((this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation).getArity() > 1? (this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(1).getArity() == 1 && this.getNthChild(1).getOperator() == Op_AtID && this.getNthChild(1).getNthChild(0).getArity() == 2 && this.getNthChild(1).getNthChild(0).getOperator() == NamespaceAccessExpressionID )
				return(normalizeCost((long)1 + (long) ( (((long)factoredPath_3.getCost(__expression_NT)) + ((long)factoredPath_2.getCost(__name_NT)))  + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_2f0068c9( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(1).getArity() > 1? this.getNthChild(1).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(1).getArity() == 2 && this.getNthChild(1).getOperator() == NamespaceAccessExpressionID )
				return(normalizeCost((long)10 + (long) ( (((long)factoredPath_1.getCost(__name_NT)) + ((long)factoredPath_0.getCost(__name_NT)))  + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_7f343153( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(1).getArity() > 1? this.getNthChild(1).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(1).getArity() == 2 && this.getNthChild(1).getOperator() == NamespaceAccessExpressionID )
				return(normalizeCost((long)100 + (long) ( (((long)factoredPath_1.getCost(__expression_NT)) + ((long)factoredPath_0.getCost(__name_NT)))  + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_34f9d9c4( int goalState)
		{

			if ( this.getNthChild(0).getArity() == 0 && this.getNthChild(0).getOperator() == SuperID )
				return(normalizeCost((long)0 + (long)((long)this.getNthChild(1).getCost(__name_NT))));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_2ecaaada( int goalState)
		{
			JBurgAnnotation factoredPath_1 = (this.getNthChild(1).getArity() > 1? this.getNthChild(1).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(1).getArity() == 2 && this.getNthChild(1).getOperator() == ArrayIndexExpressionID && this.getNthChild(1).getNthChild(0).getArity() == 0 && this.getNthChild(1).getNthChild(0).getOperator() == Op_AtID )
				return(normalizeCost((long)1 + (long) (((long)factoredPath_1.getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
	}

	class JBurgAnnotation_NamespaceAccessExpressionID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_NamespaceAccessExpressionID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_runtime_name_expression = -1;
		private int cachedCostFor_name = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)2000 + (long)getCost(__name_NT));

					int currentCost = normalizeCost((long)1 + (long)getCost(__runtime_name_expression_NT));

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
				case __name_NT:
				{
					if ( cachedCostFor_name == -1 )
					{
						cachedCostFor_name = getCostForRule_4f9e39fb(goalState);

						int currentCost = getCostForRule_145c442f(goalState);

						if ( ( cachedCostFor_name > currentCost )  )
							cachedCostFor_name = currentCost;
					}
					return(cachedCostFor_name);
				}
				case __new_type_name_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)20 + (long)getCost(__type_name_NT));

					int currentCost = getCost(__name_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __runtime_name_expression_NT:
				{
					if ( cachedCostFor_runtime_name_expression == -1 )
					{
						cachedCostFor_runtime_name_expression = getCostForRule_30fa6ff2(goalState);

						int currentCost = getCostForRule_4a37b7d0(goalState);

						if ( ( cachedCostFor_runtime_name_expression > currentCost )  )
							cachedCostFor_runtime_name_expression = currentCost;
						currentCost = getCostForRule_74580e8c(goalState);
						if ( ( cachedCostFor_runtime_name_expression > currentCost )  )
							cachedCostFor_runtime_name_expression = currentCost;
					}
					return(cachedCostFor_runtime_name_expression);
				}
				case __type_name_NT:
				{
					return(normalizeCost((long)1 + (long)getCost(__name_NT)));
				}
				case __type_param_expression_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)getCostFunctionResult_a1e6528e() + (long)getCost(__name_NT));

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)2000 + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 5;
					}
					currentCost = normalizeCost((long)1 + (long)getCost(__runtime_name_expression_NT));
					if ( ( bestCost > currentCost )  )
					{
						rule = 6;
					}
					return(rule);
				}
				case __name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_4f9e39fb(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 127;
					}
					currentCost = getCostForRule_145c442f(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 128;
					}
					return(rule);
				}
				case __new_type_name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)20 + (long)getCost(__type_name_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 3;
					}
					currentCost = getCost(__name_NT);
					if ( ( bestCost > currentCost )  )
					{
						rule = 204;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __runtime_name_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_30fa6ff2(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 131;
					}
					currentCost = getCostForRule_4a37b7d0(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 132;
					}
					currentCost = getCostForRule_74580e8c(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 133;
					}
					return(rule);
				}
				case __type_name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)1 + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 2;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)getCostFunctionResult_a1e6528e() + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 4;
					}
					currentCost = getCost(__expression_NT);
					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		private int cachedCostFunctionResult_cab71592 = -1;
		
		private int getCostFunctionResult_a1e6528e( )
		{
			if ( cachedCostFunctionResult_cab71592 == -1 )
				cachedCostFunctionResult_cab71592 = isKnownType(m_node);
			return(cachedCostFunctionResult_cab71592);
		}
		
		private int getCostForRule_4f9e39fb( int goalState)
		{

			if ( this.getNthChild(0).getArity() == 0 && this.getNthChild(0).getOperator() == NamespaceIdentifierID )
				return(normalizeCost((long)cachedCost_d3ce5471() + (long)((long)this.getNthChild(1).getCost(__name_NT))));
			else
				return(Integer.MAX_VALUE);
		}
		private int cachedCostFunctionResult_af76905a = -1;
		
		private int cachedCost_d3ce5471( )
		{
			if ( cachedCostFunctionResult_af76905a == -1 )
				cachedCostFunctionResult_af76905a = qualifierIsCompileTimeConstant(m_node);
			return(cachedCostFunctionResult_af76905a);
		}
		
		private int getCostForRule_145c442f( int goalState)
		{

			if ( this.getNthChild(0).getArity() == 0 && this.getNthChild(0).getOperator() == NamespaceIdentifierID )
				return(normalizeCost((long)ERROR_TRAP + (long)((long)this.getNthChild(1).getCost(__name_NT))));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_30fa6ff2( int goalState)
		{

			if ( this.getNthChild(0).getArity() == 0 && this.getNthChild(0).getOperator() == NamespaceIdentifierID )
				return(normalizeCost((long)cachedCost_d3ce5471() + (long)((long)this.getNthChild(1).getCost(__expression_NT))));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_4a37b7d0( int goalState)
		{

			return(normalizeCost((long)2000 + (long) (((long)this.getNthChild(1).getCost(__name_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
		
		private int getCostForRule_74580e8c( int goalState)
		{

			return(normalizeCost((long)2000 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_NamespaceIdentifierID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_NamespaceIdentifierID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					return(1);
				}
				case __name_NT:
				{
					return(1);
				}
				case __new_type_name_NT:
				{
					return(1);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_name_NT:
				{
					return(2);
				}
				case __type_param_expression_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)getCostFunctionResult_a1e6528e() + (long)getCost(__name_NT));

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					return(130);
				}
				case __name_NT:
				{
					return(129);
				}
				case __new_type_name_NT:
				{
					return(204);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_name_NT:
				{
					return(2);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)getCostFunctionResult_a1e6528e() + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 4;
					}
					currentCost = getCost(__expression_NT);
					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
		private int cachedCostFunctionResult_cab71592 = -1;
		
		private int getCostFunctionResult_a1e6528e( )
		{
			if ( cachedCostFunctionResult_cab71592 == -1 )
				cachedCostFunctionResult_cab71592 = isKnownType(m_node);
			return(cachedCostFunctionResult_cab71592);
		}
	}

	class JBurgAnnotation_NilID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_NilID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					return(1);
				}
				case __required_constant_value_NT:
				{
					return(268435457);
				}
				case __type_param_expression_NT:
				{
					return(1);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					return(139);
				}
				case __required_constant_value_NT:
				{
					return(11);
				}
				case __type_param_expression_NT:
				{
					return(205);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
	}

	class JBurgAnnotation_NonResolvingIdentifierID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_NonResolvingIdentifierID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					return(1);
				}
				case __non_resolving_identifier_NT:
				{
					return(0);
				}
				case __required_constant_value_NT:
				{
					return(268435457);
				}
				case __type_param_expression_NT:
				{
					return(1);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					return(23);
				}
				case __non_resolving_identifier_NT:
				{
					return(140);
				}
				case __required_constant_value_NT:
				{
					return(11);
				}
				case __type_param_expression_NT:
				{
					return(205);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
	}

	class JBurgAnnotation_ObjectLiteralExpressionID_1_n extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private java.util.Vector narySubtrees = new java.util.Vector();
		JBurgAnnotation_ObjectLiteralExpressionID_1_n(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_object_literal = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					return(getCost(__literal_NT));
				}
				case __literal_NT:
				{
					return(getCost(__object_literal_NT));
				}
				case __object_literal_NT:
				{
					if ( cachedCostFor_object_literal == -1 )
					{
						cachedCostFor_object_literal = getCostForRule_2d34114(goalState);

					}
					return(cachedCostFor_object_literal);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__literal_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 208;
					}
					return(rule);
				}
				case __literal_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__object_literal_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 206;
					}
					return(rule);
				}
				case __object_literal_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_2d34114(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 148;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1 + narySubtrees.size());
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					return narySubtrees.get(index - 1);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				narySubtrees.add(child);
		}
		
		private int getCostForRule_2d34114( int goalState)
		{

			if ( this.getArity() == 1 && this.getNthChild(0).getOperator() == ContainerID )
				return(normalizeCost((long)3 + (long)((long)getNaryCost(this.getNthChild(0), __object_literal_element_NT, 0))));
			else
				return(Integer.MAX_VALUE);
		}
	}

	class JBurgAnnotation_ObjectLiteralValuePairID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_ObjectLiteralValuePairID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_object_literal_element = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __object_literal_element_NT:
				{
					if ( cachedCostFor_object_literal_element == -1 )
					{
						cachedCostFor_object_literal_element = getCostForRule_61352b43(goalState);

					}
					return(cachedCostFor_object_literal_element);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __object_literal_element_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_61352b43(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 149;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_61352b43( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_AddAssignID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_AddAssignID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_164b8982(goalState);

						int currentCost = getCostForRule_22d3c9a9(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_3a10e706(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_164b8982(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 56;
					}
					currentCost = getCostForRule_22d3c9a9(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 57;
					}
					currentCost = getCostForRule_3a10e706(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 58;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_164b8982( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__expression_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_22d3c9a9( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__name_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_3a10e706( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__name_NT))) ));
		}
	}

	class JBurgAnnotation_Op_AddID_1 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		JBurgAnnotation_Op_AddID_1(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_7237ac34(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_7237ac34(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 190;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_7237ac34( int goalState)
		{

			return(normalizeCost((long)0 + (long)((long)this.getNthChild(0).getCost(__expression_NT))));
		}
	}

	class JBurgAnnotation_Op_AddID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_AddID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_387a2c69(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_387a2c69(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 29;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_387a2c69( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_AsID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_AsID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_4d8244e(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_4d8244e(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 77;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_4d8244e( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_AssignId_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_AssignId_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		private int cachedCostFor_void_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_39cdcb04(goalState);

						int currentCost = getCostForRule_76d48605(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_1fa4e5d2(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_5a1b583c(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_d593d90(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_5fef7690(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_67dd82ca(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_6707fcb5(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_2376e878(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_7094170(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_cc95889(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_54f3eff1(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
				case __void_expression_NT:
				{
					if ( cachedCostFor_void_expression == -1 )
					{
						cachedCostFor_void_expression = getCostForRule_4052e83f(goalState);

					}
					return(cachedCostFor_void_expression);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_39cdcb04(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 1;
					}
					currentCost = getCostForRule_76d48605(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 62;
					}
					currentCost = getCostForRule_1fa4e5d2(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 63;
					}
					currentCost = getCostForRule_5a1b583c(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 64;
					}
					currentCost = getCostForRule_d593d90(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 65;
					}
					currentCost = getCostForRule_5fef7690(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 66;
					}
					currentCost = getCostForRule_67dd82ca(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 67;
					}
					currentCost = getCostForRule_6707fcb5(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 68;
					}
					currentCost = getCostForRule_2376e878(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 70;
					}
					currentCost = getCostForRule_7094170(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 71;
					}
					currentCost = getCostForRule_cc95889(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 72;
					}
					currentCost = getCostForRule_54f3eff1(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 73;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
				case __void_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_4052e83f(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 69;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_39cdcb04( int goalState)
		{

			return(normalizeCost((long)ERROR_TRAP + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
		
		private int getCostForRule_76d48605( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID )
				return(normalizeCost((long)1 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__expression_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_1fa4e5d2( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == Op_DescendantsID )
				return(normalizeCost((long)1 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__name_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_5a1b583c( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)10 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__name_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_d593d90( int goalState)
		{

			return(normalizeCost((long)2 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__name_NT))) ));
		}
		
		private int getCostForRule_5fef7690( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_4 = (((this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getArity() > 0? (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getNthChild(0): errorAnnotation).getArity() > 0? ((this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getArity() > 0? (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getNthChild(0): errorAnnotation).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_5 = (((this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getArity() > 0? (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getNthChild(0): errorAnnotation).getArity() > 1? ((this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getArity() > 0? (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getNthChild(0): errorAnnotation).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID && this.getNthChild(0).getNthChild(1).getArity() == 1 && this.getNthChild(0).getNthChild(1).getOperator() == Op_AtID && this.getNthChild(0).getNthChild(1).getNthChild(0).getArity() == 2 && this.getNthChild(0).getNthChild(1).getNthChild(0).getOperator() == NamespaceAccessExpressionID )
				return(normalizeCost((long)1 + (long) ( ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_5.getCost(__name_NT)))  + ((long)factoredPath_4.getCost(__name_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_67dd82ca( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_2 = ((this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getArity() > 0? (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_3 = ((this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getArity() > 1? (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID && this.getNthChild(0).getNthChild(1).getArity() == 2 && this.getNthChild(0).getNthChild(1).getOperator() == NamespaceAccessExpressionID )
				return(normalizeCost((long)1 + (long) ( ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_3.getCost(__name_NT)))  + ((long)factoredPath_2.getCost(__name_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_6707fcb5( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_2 = ((this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getArity() > 0? (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_3 = ((this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getArity() > 1? (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID && this.getNthChild(0).getNthChild(1).getArity() == 2 && this.getNthChild(0).getNthChild(1).getOperator() == NamespaceAccessExpressionID )
				return(normalizeCost((long)1 + (long) ( ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_3.getCost(__expression_NT)))  + ((long)factoredPath_2.getCost(__name_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_4052e83f( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__runtime_name_expression_NT))) ));
		}
		
		private int getCostForRule_2376e878( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__runtime_name_expression_NT))) ));
		}
		
		private int getCostForRule_7094170( int goalState)
		{
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID && this.getNthChild(0).getNthChild(0).getArity() == 0 && this.getNthChild(0).getNthChild(0).getOperator() == SuperID )
				return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_cc95889( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_3 = ((this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getArity() > 1? (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID && this.getNthChild(0).getNthChild(1).getArity() == 2 && this.getNthChild(0).getNthChild(1).getOperator() == ArrayIndexExpressionID && this.getNthChild(0).getNthChild(1).getNthChild(0).getArity() == 0 && this.getNthChild(0).getNthChild(1).getNthChild(0).getOperator() == Op_AtID )
				return(normalizeCost((long)1 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_3.getCost(__expression_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_54f3eff1( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_3 = ((this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getArity() > 1? (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == Op_DescendantsID && this.getNthChild(0).getNthChild(1).getArity() == 2 && this.getNthChild(0).getNthChild(1).getOperator() == ArrayIndexExpressionID && this.getNthChild(0).getNthChild(1).getNthChild(0).getArity() == 0 && this.getNthChild(0).getNthChild(1).getNthChild(0).getOperator() == Op_AtID )
				return(normalizeCost((long)1 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_3.getCost(__expression_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
	}

	class JBurgAnnotation_Op_AtID_1 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		JBurgAnnotation_Op_AtID_1(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_name = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					return(normalizeCost((long)2000 + (long)getCost(__name_NT)));
				}
				case __name_NT:
				{
					if ( cachedCostFor_name == -1 )
					{
						cachedCostFor_name = getCostForRule_d1d2384(goalState);

					}
					return(cachedCostFor_name);
				}
				case __new_type_name_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)20 + (long)getCost(__type_name_NT));

					int currentCost = getCost(__name_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_name_NT:
				{
					return(normalizeCost((long)1 + (long)getCost(__name_NT)));
				}
				case __type_param_expression_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)getCostFunctionResult_a1e6528e() + (long)getCost(__name_NT));

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)2000 + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 5;
					}
					return(rule);
				}
				case __name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_d1d2384(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 78;
					}
					return(rule);
				}
				case __new_type_name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)20 + (long)getCost(__type_name_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 3;
					}
					currentCost = getCost(__name_NT);
					if ( ( bestCost > currentCost )  )
					{
						rule = 204;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)1 + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 2;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)getCostFunctionResult_a1e6528e() + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 4;
					}
					currentCost = getCost(__expression_NT);
					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				throw new IllegalStateException("too many children");
		}
		private int cachedCostFunctionResult_cab71592 = -1;
		
		private int getCostFunctionResult_a1e6528e( )
		{
			if ( cachedCostFunctionResult_cab71592 == -1 )
				cachedCostFunctionResult_cab71592 = isKnownType(m_node);
			return(cachedCostFunctionResult_cab71592);
		}
		
		private int getCostForRule_d1d2384( int goalState)
		{

			return(normalizeCost((long)0 + (long)((long)this.getNthChild(0).getCost(__name_NT))));
		}
	}

	class JBurgAnnotation_Op_BitwiseAndAssignID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_BitwiseAndAssignID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_4b563fbe(goalState);

						int currentCost = getCostForRule_91dd42(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_5755de7f(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_4b563fbe(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 32;
					}
					currentCost = getCostForRule_91dd42(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 33;
					}
					currentCost = getCostForRule_5755de7f(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 34;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_4b563fbe( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__expression_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_91dd42( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__name_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_5755de7f( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__name_NT))) ));
		}
	}

	class JBurgAnnotation_Op_BitwiseAndID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_BitwiseAndID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_33b0c612(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_33b0c612(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 80;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_33b0c612( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_BitwiseNotID_1 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		JBurgAnnotation_Op_BitwiseNotID_1(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_49e1a415(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_49e1a415(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 79;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_49e1a415( int goalState)
		{

			return(normalizeCost((long)1 + (long)((long)this.getNthChild(0).getCost(__expression_NT))));
		}
	}

	class JBurgAnnotation_Op_BitwiseOrAssignID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_BitwiseOrAssignID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_47140ba6(goalState);

						int currentCost = getCostForRule_3ecb831d(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_bfe5280(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_47140ba6(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 35;
					}
					currentCost = getCostForRule_3ecb831d(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 36;
					}
					currentCost = getCostForRule_bfe5280(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 37;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_47140ba6( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__expression_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_3ecb831d( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__name_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_bfe5280( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__name_NT))) ));
		}
	}

	class JBurgAnnotation_Op_BitwiseOrID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_BitwiseOrID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_4ffb8ee6(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_4ffb8ee6(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 82;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_4ffb8ee6( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_BitwiseXorAssignID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_BitwiseXorAssignID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_2855f584(goalState);

						int currentCost = getCostForRule_4ae458f8(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_33f77976(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_2855f584(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 38;
					}
					currentCost = getCostForRule_4ae458f8(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 39;
					}
					currentCost = getCostForRule_33f77976(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 40;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_2855f584( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__expression_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_4ae458f8( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__name_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_33f77976( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__name_NT))) ));
		}
	}

	class JBurgAnnotation_Op_BitwiseXorID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_BitwiseXorID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_20e85d50(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_20e85d50(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 85;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_20e85d50( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_CommaID_2_n extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		private java.util.Vector narySubtrees = new java.util.Vector();
		JBurgAnnotation_Op_CommaID_2_n(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_2716751c(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_2716751c(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 87;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2 + narySubtrees.size());
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					return narySubtrees.get(index - 2);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				narySubtrees.add(child);
		}
		
		private int getCostForRule_2716751c( int goalState)
		{

			if ( (this.getArity() >= 2) )
				return(normalizeCost((long)0 + (long) (((long)getNaryCost(this, __void_expression_NT, 1)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
	}

	class JBurgAnnotation_Op_DeleteID_1 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		JBurgAnnotation_Op_DeleteID_1(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_4fddca9e(goalState);

						int currentCost = getCostForRule_47e926da(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_2589e1aa(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_31a3de92(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_100b6b02(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_1e5a402f(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_743466ff(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_4fddca9e(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 88;
					}
					currentCost = getCostForRule_47e926da(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 89;
					}
					currentCost = getCostForRule_2589e1aa(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 90;
					}
					currentCost = getCostForRule_31a3de92(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 91;
					}
					currentCost = getCostForRule_100b6b02(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 92;
					}
					currentCost = getCostForRule_1e5a402f(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 93;
					}
					currentCost = getCostForRule_743466ff(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 94;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_4fddca9e( int goalState)
		{

			return(normalizeCost((long)2000 + (long)((long)this.getNthChild(0).getCost(__expression_NT))));
		}
		
		private int getCostForRule_47e926da( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_2 = ((this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getArity() > 1? (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID && this.getNthChild(0).getNthChild(1).getArity() == 2 && this.getNthChild(0).getNthChild(1).getOperator() == ArrayIndexExpressionID && this.getNthChild(0).getNthChild(1).getNthChild(0).getArity() == 0 && this.getNthChild(0).getNthChild(1).getNthChild(0).getOperator() == Op_AtID )
				return(normalizeCost((long)1 + (long) (((long)factoredPath_2.getCost(__expression_NT)) + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_2589e1aa( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID )
				return(normalizeCost((long)1 + (long) (((long)factoredPath_1.getCost(__expression_NT)) + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_31a3de92( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == Op_DescendantsID )
				return(normalizeCost((long)1 + (long) (((long)factoredPath_1.getCost(__name_NT)) + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_100b6b02( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)1 + (long) (((long)factoredPath_1.getCost(__name_NT)) + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_1e5a402f( int goalState)
		{

			return(normalizeCost((long)2 + (long)((long)this.getNthChild(0).getCost(__name_NT))));
		}
		
		private int getCostForRule_743466ff( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)1 + (long) (((long)factoredPath_1.getCost(__runtime_name_expression_NT)) + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
	}

	class JBurgAnnotation_Op_DescendantsID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_DescendantsID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_5b4c71a5(goalState);

						int currentCost = getCostForRule_105452b5(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_5c4333a8(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_b97a541(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_336e2ccf(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_11d01ed(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_5b4c71a5(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 95;
					}
					currentCost = getCostForRule_105452b5(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 166;
					}
					currentCost = getCostForRule_5c4333a8(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 167;
					}
					currentCost = getCostForRule_b97a541(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 168;
					}
					currentCost = getCostForRule_336e2ccf(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 169;
					}
					currentCost = getCostForRule_11d01ed(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 192;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_5b4c71a5( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__name_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
		
		private int getCostForRule_105452b5( int goalState)
		{
			JBurgAnnotation factoredPath_2 = ((this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation).getArity() > 0? (this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_3 = ((this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation).getArity() > 1? (this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(1).getArity() == 1 && this.getNthChild(1).getOperator() == Op_AtID && this.getNthChild(1).getNthChild(0).getArity() == 2 && this.getNthChild(1).getNthChild(0).getOperator() == NamespaceAccessExpressionID )
				return(normalizeCost((long)1 + (long) ( (((long)factoredPath_3.getCost(__name_NT)) + ((long)factoredPath_2.getCost(__name_NT)))  + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_5c4333a8( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(1).getArity() > 1? this.getNthChild(1).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(1).getArity() == 2 && this.getNthChild(1).getOperator() == NamespaceAccessExpressionID )
				return(normalizeCost((long)10 + (long) ( (((long)factoredPath_1.getCost(__name_NT)) + ((long)factoredPath_0.getCost(__name_NT)))  + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_b97a541( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(1).getArity() > 1? this.getNthChild(1).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(1).getArity() == 2 && this.getNthChild(1).getOperator() == NamespaceAccessExpressionID )
				return(normalizeCost((long)1 + (long) ( (((long)factoredPath_1.getCost(__expression_NT)) + ((long)factoredPath_0.getCost(__name_NT)))  + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_336e2ccf( int goalState)
		{
			JBurgAnnotation factoredPath_2 = ((this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation).getArity() > 0? (this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_3 = ((this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation).getArity() > 1? (this.getNthChild(1).getArity() > 0? this.getNthChild(1).getNthChild(0): errorAnnotation).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(1).getArity() == 1 && this.getNthChild(1).getOperator() == Op_AtID && this.getNthChild(1).getNthChild(0).getArity() == 2 && this.getNthChild(1).getNthChild(0).getOperator() == NamespaceAccessExpressionID )
				return(normalizeCost((long)1 + (long) ( (((long)factoredPath_3.getCost(__expression_NT)) + ((long)factoredPath_2.getCost(__name_NT)))  + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_11d01ed( int goalState)
		{
			JBurgAnnotation factoredPath_1 = (this.getNthChild(1).getArity() > 1? this.getNthChild(1).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(1).getArity() == 2 && this.getNthChild(1).getOperator() == ArrayIndexExpressionID && this.getNthChild(1).getNthChild(0).getArity() == 0 && this.getNthChild(1).getNthChild(0).getOperator() == Op_AtID )
				return(normalizeCost((long)1 + (long) (((long)factoredPath_1.getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
	}

	class JBurgAnnotation_Op_DivideAssignID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_DivideAssignID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_4486ac15(goalState);

						int currentCost = getCostForRule_720db469(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_30c7e6b3(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_4486ac15(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 41;
					}
					currentCost = getCostForRule_720db469(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 42;
					}
					currentCost = getCostForRule_30c7e6b3(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 43;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_4486ac15( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__expression_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_720db469( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__name_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_30c7e6b3( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__name_NT))) ));
		}
	}

	class JBurgAnnotation_Op_DivideID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_DivideID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_593c8b2f(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_593c8b2f(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 96;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_593c8b2f( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_EqualID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_EqualID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_comparison_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __comparison_expression_NT:
				{
					if ( cachedCostFor_comparison_expression == -1 )
					{
						cachedCostFor_comparison_expression = getCostForRule_28ab6219(goalState);

					}
					return(cachedCostFor_comparison_expression);
				}
				case __expression_NT:
				{
					return(getCost(__comparison_expression_NT));
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __comparison_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_28ab6219(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 103;
					}
					return(rule);
				}
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__comparison_expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 213;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_28ab6219( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_GreaterThanEqualsID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_GreaterThanEqualsID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_comparison_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __comparison_expression_NT:
				{
					if ( cachedCostFor_comparison_expression == -1 )
					{
						cachedCostFor_comparison_expression = getCostForRule_371a3599(goalState);

					}
					return(cachedCostFor_comparison_expression);
				}
				case __expression_NT:
				{
					return(getCost(__comparison_expression_NT));
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __comparison_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_371a3599(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 114;
					}
					return(rule);
				}
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__comparison_expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 213;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_371a3599( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_GreaterThanID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_GreaterThanID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_comparison_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __comparison_expression_NT:
				{
					if ( cachedCostFor_comparison_expression == -1 )
					{
						cachedCostFor_comparison_expression = getCostForRule_3867bfb7(goalState);

					}
					return(cachedCostFor_comparison_expression);
				}
				case __expression_NT:
				{
					return(getCost(__comparison_expression_NT));
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __comparison_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_3867bfb7(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 115;
					}
					return(rule);
				}
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__comparison_expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 213;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_3867bfb7( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_InID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_InID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_5bf3e67(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_5bf3e67(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 116;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_5bf3e67( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_InstanceOfID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_InstanceOfID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_76772f63(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_76772f63(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 117;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_76772f63( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_IsID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_IsID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_10276ac9(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_10276ac9(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 118;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_10276ac9( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_LeftShiftAssignID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_LeftShiftAssignID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_1538e57d(goalState);

						int currentCost = getCostForRule_6988adbb(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_264b8bde(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_1538e57d(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 44;
					}
					currentCost = getCostForRule_6988adbb(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 45;
					}
					currentCost = getCostForRule_264b8bde(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 46;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_1538e57d( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__expression_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_6988adbb( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__name_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_264b8bde( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__name_NT))) ));
		}
	}

	class JBurgAnnotation_Op_LeftShiftID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_LeftShiftID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_d91dcfc(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_d91dcfc(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 81;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_d91dcfc( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_LessThanEqualsID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_LessThanEqualsID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_comparison_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __comparison_expression_NT:
				{
					if ( cachedCostFor_comparison_expression == -1 )
					{
						cachedCostFor_comparison_expression = getCostForRule_5f50d33e(goalState);

					}
					return(cachedCostFor_comparison_expression);
				}
				case __expression_NT:
				{
					return(getCost(__comparison_expression_NT));
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __comparison_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_5f50d33e(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 119;
					}
					return(rule);
				}
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__comparison_expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 213;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_5f50d33e( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_LessThanID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_LessThanID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_comparison_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __comparison_expression_NT:
				{
					if ( cachedCostFor_comparison_expression == -1 )
					{
						cachedCostFor_comparison_expression = getCostForRule_7319481a(goalState);

					}
					return(cachedCostFor_comparison_expression);
				}
				case __expression_NT:
				{
					return(getCost(__comparison_expression_NT));
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __comparison_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_7319481a(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 120;
					}
					return(rule);
				}
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__comparison_expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 213;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_7319481a( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_LogicalAndID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_LogicalAndID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_97638dc(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_97638dc(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 121;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_97638dc( int goalState)
		{

			return(normalizeCost((long)5 + (long) (((long)this.getNthChild(1).getCost(__foldedExpression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_LogicalNotID_1 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		JBurgAnnotation_Op_LogicalNotID_1(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_a036332(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_a036332(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 122;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_a036332( int goalState)
		{

			return(normalizeCost((long)1 + (long)((long)this.getNthChild(0).getCost(__expression_NT))));
		}
	}

	class JBurgAnnotation_Op_LogicalOrID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_LogicalOrID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_5313986f(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_5313986f(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 123;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_5313986f( int goalState)
		{

			return(normalizeCost((long)5 + (long) (((long)this.getNthChild(1).getCost(__foldedExpression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_ModuloAssignID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_ModuloAssignID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_6a73538f(goalState);

						int currentCost = getCostForRule_52fb36c5(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_4370d55b(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_6a73538f(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 50;
					}
					currentCost = getCostForRule_52fb36c5(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 51;
					}
					currentCost = getCostForRule_4370d55b(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 52;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_6a73538f( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__expression_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_52fb36c5( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__name_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_4370d55b( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__name_NT))) ));
		}
	}

	class JBurgAnnotation_Op_ModuloID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_ModuloID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_c6ffdba(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_c6ffdba(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 125;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_c6ffdba( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_MultiplyAssignID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_MultiplyAssignID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_7c703893(goalState);

						int currentCost = getCostForRule_77b674c6(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_3229ad66(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_7c703893(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 53;
					}
					currentCost = getCostForRule_77b674c6(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 54;
					}
					currentCost = getCostForRule_3229ad66(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 55;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_7c703893( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__expression_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_77b674c6( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__name_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_3229ad66( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__name_NT))) ));
		}
	}

	class JBurgAnnotation_Op_MultiplyID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_MultiplyID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_41d804b4(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_41d804b4(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 126;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_41d804b4( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_NotEqualID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_NotEqualID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_comparison_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __comparison_expression_NT:
				{
					if ( cachedCostFor_comparison_expression == -1 )
					{
						cachedCostFor_comparison_expression = getCostForRule_3c1118bc(goalState);

					}
					return(cachedCostFor_comparison_expression);
				}
				case __expression_NT:
				{
					return(getCost(__comparison_expression_NT));
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __comparison_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_3c1118bc(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 134;
					}
					return(rule);
				}
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__comparison_expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 213;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_3c1118bc( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_PostDecrID_1 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		JBurgAnnotation_Op_PostDecrID_1(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_78c54bbc(goalState);

						int currentCost = getCostForRule_7f88b5f(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_684c2b0(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_78c54bbc(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 152;
					}
					currentCost = getCostForRule_7f88b5f(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 153;
					}
					currentCost = getCostForRule_684c2b0(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 154;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_78c54bbc( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID )
				return(normalizeCost((long)8 + (long) (((long)factoredPath_1.getCost(__expression_NT)) + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_7f88b5f( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)8 + (long) (((long)factoredPath_1.getCost(__name_NT)) + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_684c2b0( int goalState)
		{

			return(normalizeCost((long)7 + (long)((long)this.getNthChild(0).getCost(__name_NT))));
		}
	}

	class JBurgAnnotation_Op_PostIncrID_1 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		JBurgAnnotation_Op_PostIncrID_1(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_32e4ee24(goalState);

						int currentCost = getCostForRule_60aecb6f(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_234f1656(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_32e4ee24(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 155;
					}
					currentCost = getCostForRule_60aecb6f(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 156;
					}
					currentCost = getCostForRule_234f1656(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 157;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_32e4ee24( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID )
				return(normalizeCost((long)8 + (long) (((long)factoredPath_1.getCost(__expression_NT)) + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_60aecb6f( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)8 + (long) (((long)factoredPath_1.getCost(__name_NT)) + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_234f1656( int goalState)
		{

			return(normalizeCost((long)7 + (long)((long)this.getNthChild(0).getCost(__name_NT))));
		}
	}

	class JBurgAnnotation_Op_PreDecrID_1 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		JBurgAnnotation_Op_PreDecrID_1(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_3fec1cd(goalState);

						int currentCost = getCostForRule_16fe9a58(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_1dce5b(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_3fec1cd(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 158;
					}
					currentCost = getCostForRule_16fe9a58(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 159;
					}
					currentCost = getCostForRule_1dce5b(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 160;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_3fec1cd( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID )
				return(normalizeCost((long)8 + (long) (((long)factoredPath_1.getCost(__expression_NT)) + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_16fe9a58( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)8 + (long) (((long)factoredPath_1.getCost(__name_NT)) + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_1dce5b( int goalState)
		{

			return(normalizeCost((long)7 + (long)((long)this.getNthChild(0).getCost(__name_NT))));
		}
	}

	class JBurgAnnotation_Op_PreIncrID_1 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		JBurgAnnotation_Op_PreIncrID_1(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_5bbb85a8(goalState);

						int currentCost = getCostForRule_2ebec7bb(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_4cf0b46e(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_5bbb85a8(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 161;
					}
					currentCost = getCostForRule_2ebec7bb(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 162;
					}
					currentCost = getCostForRule_4cf0b46e(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 163;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_5bbb85a8( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID )
				return(normalizeCost((long)8 + (long) (((long)factoredPath_1.getCost(__expression_NT)) + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_2ebec7bb( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)8 + (long) (((long)factoredPath_1.getCost(__name_NT)) + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_4cf0b46e( int goalState)
		{

			return(normalizeCost((long)7 + (long)((long)this.getNthChild(0).getCost(__name_NT))));
		}
	}

	class JBurgAnnotation_Op_RightShiftAssignID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_RightShiftAssignID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_22f1c4bd(goalState);

						int currentCost = getCostForRule_2560938e(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_7d3b0b86(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_22f1c4bd(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 59;
					}
					currentCost = getCostForRule_2560938e(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 60;
					}
					currentCost = getCostForRule_7d3b0b86(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 61;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_22f1c4bd( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__expression_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_2560938e( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__name_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_7d3b0b86( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__name_NT))) ));
		}
	}

	class JBurgAnnotation_Op_RightShiftID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_RightShiftID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_34a1838b(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_34a1838b(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 83;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_34a1838b( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_StrictEqualID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_StrictEqualID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_comparison_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __comparison_expression_NT:
				{
					if ( cachedCostFor_comparison_expression == -1 )
					{
						cachedCostFor_comparison_expression = getCostForRule_18d97d8e(goalState);

					}
					return(cachedCostFor_comparison_expression);
				}
				case __expression_NT:
				{
					return(getCost(__comparison_expression_NT));
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __comparison_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_18d97d8e(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 179;
					}
					return(rule);
				}
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__comparison_expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 213;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_18d97d8e( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_StrictNotEqualID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_StrictNotEqualID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_comparison_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __comparison_expression_NT:
				{
					if ( cachedCostFor_comparison_expression == -1 )
					{
						cachedCostFor_comparison_expression = getCostForRule_390471f8(goalState);

					}
					return(cachedCostFor_comparison_expression);
				}
				case __expression_NT:
				{
					return(getCost(__comparison_expression_NT));
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __comparison_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_390471f8(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 180;
					}
					return(rule);
				}
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__comparison_expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 213;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_390471f8( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_SubtractAssignID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_SubtractAssignID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_1c463a65(goalState);

						int currentCost = getCostForRule_24c34fbd(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_77a563a6(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_1c463a65(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 47;
					}
					currentCost = getCostForRule_24c34fbd(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 48;
					}
					currentCost = getCostForRule_77a563a6(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 49;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_1c463a65( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__expression_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_24c34fbd( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__name_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_77a563a6( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__name_NT))) ));
		}
	}

	class JBurgAnnotation_Op_SubtractID_1 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		JBurgAnnotation_Op_SubtractID_1(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_6db4471b(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_6db4471b(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 189;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_6db4471b( int goalState)
		{

			return(normalizeCost((long)1 + (long)((long)this.getNthChild(0).getCost(__expression_NT))));
		}
	}

	class JBurgAnnotation_Op_SubtractID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_SubtractID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_408ccdda(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_408ccdda(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 182;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_408ccdda( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_TypeOfID_1 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		JBurgAnnotation_Op_TypeOfID_1(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_7e8cccd1(goalState);

						int currentCost = getCostForRule_22e828f5(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_7e8cccd1(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 187;
					}
					currentCost = getCostForRule_22e828f5(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 188;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_7e8cccd1( int goalState)
		{

			return(normalizeCost((long)10 + (long)((long)this.getNthChild(0).getCost(__expression_NT))));
		}
		
		private int getCostForRule_22e828f5( int goalState)
		{

			return(normalizeCost((long)1 + (long)((long)this.getNthChild(0).getCost(__name_NT))));
		}
	}

	class JBurgAnnotation_Op_UnsignedRightShift_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_UnsignedRightShift_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_6dab2f2c(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_6dab2f2c(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 84;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_6dab2f2c( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_Op_UnsignedRightShiftAssignID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_Op_UnsignedRightShiftAssignID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_4befdd5e(goalState);

						int currentCost = getCostForRule_531d6ab6(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_30515fa0(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_4befdd5e(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 74;
					}
					currentCost = getCostForRule_531d6ab6(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 75;
					}
					currentCost = getCostForRule_30515fa0(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 76;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_4befdd5e( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == ArrayIndexExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__expression_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_531d6ab6( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == MemberAccessExpressionID )
				return(normalizeCost((long)0 + (long) ( (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)factoredPath_1.getCost(__name_NT)))  + ((long)factoredPath_0.getCost(__expression_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_30515fa0( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__name_NT))) ));
		}
	}

	class JBurgAnnotation_Op_VoidID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_Op_VoidID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					return(1);
				}
				case __literal_NT:
				{
					return(1);
				}
				case __object_literal_NT:
				{
					return(1);
				}
				case __required_constant_value_NT:
				{
					return(268435457);
				}
				case __type_param_expression_NT:
				{
					return(1);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					return(208);
				}
				case __literal_NT:
				{
					return(206);
				}
				case __object_literal_NT:
				{
					return(196);
				}
				case __required_constant_value_NT:
				{
					return(11);
				}
				case __type_param_expression_NT:
				{
					return(205);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
	}

	class JBurgAnnotation_Op_VoidID_1 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		JBurgAnnotation_Op_VoidID_1(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		private int cachedCostFor_constant_value = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					if ( cachedCostFor_constant_value == -1 )
					{
						cachedCostFor_constant_value = getCostForRule_4b7c4c9(goalState);

					}
					return(cachedCostFor_constant_value);
				}
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_3107ec2c(goalState);

						int currentCost = getCost(__constant_value_NT);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					int bestCost;

					bestCost = getCost(__constant_value_NT);

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_4b7c4c9(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 197;
					}
					return(rule);
				}
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_3107ec2c(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 199;
					}
					currentCost = getCost(__constant_value_NT);
					if ( ( bestCost > currentCost )  )
					{
						rule = 22;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__constant_value_NT);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 212;
					}
					currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));
					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_4b7c4c9( int goalState)
		{

			return(normalizeCost((long)0 + (long)((long)this.getNthChild(0).getCost(__constant_value_NT))));
		}
		
		private int getCostForRule_3107ec2c( int goalState)
		{

			return(normalizeCost((long)1 + (long)((long)this.getNthChild(0).getCost(__expression_NT))));
		}
	}

	class JBurgAnnotation_QualifiedNamespaceExpressionID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_QualifiedNamespaceExpressionID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_name = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					return(normalizeCost((long)2000 + (long)getCost(__name_NT)));
				}
				case __name_NT:
				{
					if ( cachedCostFor_name == -1 )
					{
						cachedCostFor_name = getCostForRule_9776860(goalState);

					}
					return(cachedCostFor_name);
				}
				case __new_type_name_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)20 + (long)getCost(__type_name_NT));

					int currentCost = getCost(__name_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_name_NT:
				{
					return(normalizeCost((long)1 + (long)getCost(__name_NT)));
				}
				case __type_param_expression_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)getCostFunctionResult_a1e6528e() + (long)getCost(__name_NT));

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)2000 + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 5;
					}
					return(rule);
				}
				case __name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_9776860(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 172;
					}
					return(rule);
				}
				case __new_type_name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)20 + (long)getCost(__type_name_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 3;
					}
					currentCost = getCost(__name_NT);
					if ( ( bestCost > currentCost )  )
					{
						rule = 204;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)1 + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 2;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)getCostFunctionResult_a1e6528e() + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 4;
					}
					currentCost = getCost(__expression_NT);
					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		private int cachedCostFunctionResult_cab71592 = -1;
		
		private int getCostFunctionResult_a1e6528e( )
		{
			if ( cachedCostFunctionResult_cab71592 == -1 )
				cachedCostFunctionResult_cab71592 = isKnownType(m_node);
			return(cachedCostFunctionResult_cab71592);
		}
		
		private int getCostForRule_9776860( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__dottedNamePart_NT)) + ((long)this.getNthChild(0).getCost(__dottedNamePart_NT))) ));
		}
	}

	class JBurgAnnotation_RuntimeNameExpressionID_1 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		JBurgAnnotation_RuntimeNameExpressionID_1(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_33618ab1(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_33618ab1(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 175;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_33618ab1( int goalState)
		{

			return(normalizeCost((long)1 + (long)((long)this.getNthChild(0).getCost(__expression_NT))));
		}
	}

	class JBurgAnnotation_TernaryExpressionID_3 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		private JBurgAnnotation subtree2;
		JBurgAnnotation_TernaryExpressionID_3(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_94a9198(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_94a9198(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 185;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(3);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				case 2:
					return subtree2;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else if ( subtree2 == null )
				subtree2 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_94a9198( int goalState)
		{

			return(normalizeCost((long)1 + (long) ( (((long)this.getNthChild(2).getCost(__expression_NT)) + ((long)this.getNthChild(1).getCost(__expression_NT)))  + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_TypedExpressionID_2 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		JBurgAnnotation_TypedExpressionID_2(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_type_name = -1;
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_7a26a11(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __new_type_name_NT:
				{
					return(normalizeCost((long)20 + (long)getCost(__type_name_NT)));
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_name_NT:
				{
					if ( cachedCostFor_type_name == -1 )
					{
						cachedCostFor_type_name = getCostForRule_35a436ed(goalState);

					}
					return(cachedCostFor_type_name);
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_7a26a11(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 151;
					}
					return(rule);
				}
				case __new_type_name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)20 + (long)getCost(__type_name_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 3;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_35a436ed(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 150;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				throw new IllegalStateException("too many children");
		}
		
		private int getCostForRule_35a436ed( int goalState)
		{

			return(normalizeCost((long)cachedCost_ed91ae90() + (long) (((long)this.getNthChild(1).getCost(__type_name_NT)) + ((long)this.getNthChild(0).getCost(__name_NT))) ));
		}
		private int cachedCostFunctionResult_ecf57ce2 = -1;
		
		private int cachedCost_ed91ae90( )
		{
			if ( cachedCostFunctionResult_ecf57ce2 == -1 )
				cachedCostFunctionResult_ecf57ce2 = parameterTypeIsConstant(m_node);
			return(cachedCostFunctionResult_ecf57ce2);
		}
		
		private int getCostForRule_7a26a11( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__type_param_expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
	}

	class JBurgAnnotation_VariableExpressionID_1 extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		JBurgAnnotation_VariableExpressionID_1(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_name = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					return(normalizeCost((long)2000 + (long)getCost(__name_NT)));
				}
				case __name_NT:
				{
					if ( cachedCostFor_name == -1 )
					{
						cachedCostFor_name = getCostForRule_aaf06ea(goalState);

					}
					return(cachedCostFor_name);
				}
				case __new_type_name_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)20 + (long)getCost(__type_name_NT));

					int currentCost = getCost(__name_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_name_NT:
				{
					return(normalizeCost((long)1 + (long)getCost(__name_NT)));
				}
				case __type_param_expression_NT:
				{
					int bestCost;

					bestCost = normalizeCost((long)getCostFunctionResult_a1e6528e() + (long)getCost(__name_NT));

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
						bestCost = currentCost;
					return(bestCost);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)2000 + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 5;
					}
					return(rule);
				}
				case __name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_aaf06ea(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 186;
					}
					return(rule);
				}
				case __new_type_name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)20 + (long)getCost(__type_name_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 3;
					}
					currentCost = getCost(__name_NT);
					if ( ( bestCost > currentCost )  )
					{
						rule = 204;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_name_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)1 + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 2;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)getCostFunctionResult_a1e6528e() + (long)getCost(__name_NT));

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 4;
					}
					currentCost = getCost(__expression_NT);
					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1);
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					throw new IllegalStateException("Invalid index " + index);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				throw new IllegalStateException("too many children");
		}
		private int cachedCostFunctionResult_cab71592 = -1;
		
		private int getCostFunctionResult_a1e6528e( )
		{
			if ( cachedCostFunctionResult_cab71592 == -1 )
				cachedCostFunctionResult_cab71592 = isKnownType(m_node);
			return(cachedCostFunctionResult_cab71592);
		}
		
		private int getCostForRule_aaf06ea( int goalState)
		{
			JBurgAnnotation factoredPath_0 = (this.getNthChild(0).getArity() > 0? this.getNthChild(0).getNthChild(0): errorAnnotation);
			JBurgAnnotation factoredPath_1 = (this.getNthChild(0).getArity() > 1? this.getNthChild(0).getNthChild(1): errorAnnotation);

			if ( this.getNthChild(0).getArity() == 2 && this.getNthChild(0).getOperator() == VariableID )
				return(normalizeCost((long)0 + (long) (((long)factoredPath_1.getCost(__type_name_NT)) + ((long)factoredPath_0.getCost(__decl_name_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
	}

	class JBurgAnnotation_VectorLiteralID_2_n extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private JBurgAnnotation subtree1;
		private java.util.Vector narySubtrees = new java.util.Vector();
		JBurgAnnotation_VectorLiteralID_2_n(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_vector_literal = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __vector_literal_NT:
				{
					if ( cachedCostFor_vector_literal == -1 )
					{
						cachedCostFor_vector_literal = getCostForRule_57b49076(goalState);

					}
					return(cachedCostFor_vector_literal);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __vector_literal_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_57b49076(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 193;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(2 + narySubtrees.size());
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				case 1:
					return subtree1;
				default:
				{
					return narySubtrees.get(index - 2);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else if ( subtree1 == null )
				subtree1 = child;
			else
				narySubtrees.add(child);
		}
		
		private int getCostForRule_57b49076( int goalState)
		{

			if ( this.getArity() == 2 && this.getNthChild(1).getOperator() == ContainerID )
				return(normalizeCost((long)1 + (long) (((long)getNaryCost(this.getNthChild(1), __expression_NT, 0)) + ((long)this.getNthChild(0).getCost(__type_name_NT))) ));
			else
				return(Integer.MAX_VALUE);
		}
	}

	class JBurgAnnotation_VoidID_0 extends JBurgSpecializedAnnotation
	{
		JBurgAnnotation_VoidID_0(IASNode node)
		{
			super(node);
		}
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __new_type_name_NT:
				{
					return(20);
				}
				case __type_name_NT:
				{
					return(0);
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __new_type_name_NT:
				{
					return(3);
				}
				case __type_name_NT:
				{
					return(198);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(0);
		}
	}

	class JBurgAnnotation_XMLContentID_1_n extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private java.util.Vector narySubtrees = new java.util.Vector();
		JBurgAnnotation_XMLContentID_1_n(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_43529a73(goalState);

					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_43529a73(goalState);

					if ( ( bestCost > currentCost )  )
					{
						rule = 25;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1 + narySubtrees.size());
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					return narySubtrees.get(index - 1);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				narySubtrees.add(child);
		}
		
		private int getCostForRule_43529a73( int goalState)
		{

			if ( this.getArity() == 1 && (this.getNthChild(0).getArity() >= 1) && this.getNthChild(0).getOperator() == ContainerID )
				return(normalizeCost((long)1 + (long)((long)getNaryCost(this.getNthChild(0), __expression_NT, 0))));
			else
				return(Integer.MAX_VALUE);
		}
	}

	class JBurgAnnotation_XMLListContentID_1_n extends JBurgSpecializedAnnotation
	{
		private JBurgAnnotation subtree0;
		private java.util.Vector narySubtrees = new java.util.Vector();
		JBurgAnnotation_XMLListContentID_1_n(IASNode node)
		{
			super(node);
		}
		private int cachedCostFor_expression = -1;
		
		public int getCost( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_5755cfaa(goalState);

						int currentCost = getCostForRule_25bf1bfc(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
					}
					return(cachedCostFor_expression);
				}
				case __required_constant_value_NT:
				{
					return(normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT)));
				}
				case __type_param_expression_NT:
				{
					return(getCost(__expression_NT));
				}
			}
			return(Integer.MAX_VALUE);
		}
		
		public int getRule( int goalState)
		{
			switch( goalState )
			{
				case __expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_5755cfaa(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 26;
					}
					currentCost = getCostForRule_25bf1bfc(goalState);
					if ( ( bestCost > currentCost )  )
					{
						rule = 27;
					}
					return(rule);
				}
				case __required_constant_value_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = normalizeCost((long)ERROR_TRAP + (long)getCost(__expression_NT));

					if ( ( bestCost > currentCost )  )
					{
						rule = 11;
					}
					return(rule);
				}
				case __type_param_expression_NT:
				{
					int rule = -1;

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCost(__expression_NT);

					if ( ( bestCost > currentCost )  )
					{
						rule = 205;
					}
					return(rule);
				}
			}
			return(-1);
		}
		
		public int getArity( )
		{
			return(1 + narySubtrees.size());
		}
		
		public JBurgAnnotation getNthChild( int index)
		{
			switch( index )
			{
				case 0:
					return subtree0;
				default:
				{
					return narySubtrees.get(index - 1);
				}
			}
		}
		
		public void addChild( JBurgAnnotation child)
		{
			if ( subtree0 == null )
				subtree0 = child;
			else
				narySubtrees.add(child);
		}
		
		private int getCostForRule_5755cfaa( int goalState)
		{

			if ( this.getArity() == 1 && this.getNthChild(0).getOperator() == ContainerID )
				return(normalizeCost((long)2 + (long)((long)getNaryCost(this.getNthChild(0), __expression_NT, 0))));
			else
				return(Integer.MAX_VALUE);
		}
		
		private int getCostForRule_25bf1bfc( int goalState)
		{

			if ( this.getArity() == 1 && this.getNthChild(0).getOperator() == ContainerID )
				return(normalizeCost((long)1 + (long)((long)getNaryCost(this.getNthChild(0), __e4x_literal_NT, 0))));
			else
				return(Integer.MAX_VALUE);
		}
	}
	
	public JBurgAnnotation getJBurgAnnotation( IASNode node)
	{
		switch( node.getNodeID() )
		{
			case ArrayIndexExpressionID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_ArrayIndexExpressionID_2(node));
				break;
			}
			case ArrayLiteralID:
			{
				if ( SemanticUtils.getChildCount(node) >= 1 )
					return(new JBurgAnnotation_ArrayLiteralID_1_n(node));
				break;
			}
			case E4XFilterID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_E4XFilterID_2(node));
				break;
			}
			case EmbedID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_EmbedID_0(node));
				break;
			}
			case FoldedExpressionID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_FoldedExpressionID_0(node));
				break;
			}
			case FullNameID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_FullNameID_2(node));
				break;
			}
			case FunctionCallID:
			{
				if ( SemanticUtils.getChildCount(node) >= 2 )
					return(new JBurgAnnotation_FunctionCallID_2_n(node));
				break;
			}
			case IdentifierID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_IdentifierID_0(node));
				break;
			}
			case LiteralBooleanID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_LiteralBooleanID_0(node));
				break;
			}
			case LiteralDoubleID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_LiteralDoubleID_0(node));
				break;
			}
			case LiteralIntegerID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_LiteralIntegerID_0(node));
				break;
			}
			case LiteralIntegerZeroID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_LiteralIntegerZeroID_0(node));
				break;
			}
			case LiteralNullID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_LiteralNullID_0(node));
				break;
			}
			case LiteralNumberID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_LiteralNumberID_0(node));
				break;
			}
			case LiteralObjectID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_LiteralObjectID_0(node));
				break;
			}
			case LiteralRegexID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_LiteralRegexID_0(node));
				break;
			}
			case LiteralStringID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_LiteralStringID_0(node));
				break;
			}
			case LiteralXMLID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_LiteralXMLID_0(node));
				break;
			}
			case MemberAccessExpressionID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_MemberAccessExpressionID_2(node));
				break;
			}
			case NamespaceAccessExpressionID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_NamespaceAccessExpressionID_2(node));
				break;
			}
			case NamespaceIdentifierID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_NamespaceIdentifierID_0(node));
				break;
			}
			case NilID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_NilID_0(node));
				break;
			}
			case NonResolvingIdentifierID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_NonResolvingIdentifierID_0(node));
				break;
			}
			case ObjectLiteralExpressionID:
			{
				if ( SemanticUtils.getChildCount(node) >= 1 )
					return(new JBurgAnnotation_ObjectLiteralExpressionID_1_n(node));
				break;
			}
			case ObjectLiteralValuePairID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_ObjectLiteralValuePairID_2(node));
				break;
			}
			case Op_AddAssignID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_AddAssignID_2(node));
				break;
			}
			case Op_AddID:
			{
				if ( SemanticUtils.getChildCount(node) == 1 )
					return(new JBurgAnnotation_Op_AddID_1(node));
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_AddID_2(node));
				break;
			}
			case Op_AsID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_AsID_2(node));
				break;
			}
			case Op_AssignId:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_AssignId_2(node));
				break;
			}
			case Op_AtID:
			{
				if ( SemanticUtils.getChildCount(node) == 1 )
					return(new JBurgAnnotation_Op_AtID_1(node));
				break;
			}
			case Op_BitwiseAndAssignID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_BitwiseAndAssignID_2(node));
				break;
			}
			case Op_BitwiseAndID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_BitwiseAndID_2(node));
				break;
			}
			case Op_BitwiseNotID:
			{
				if ( SemanticUtils.getChildCount(node) == 1 )
					return(new JBurgAnnotation_Op_BitwiseNotID_1(node));
				break;
			}
			case Op_BitwiseOrAssignID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_BitwiseOrAssignID_2(node));
				break;
			}
			case Op_BitwiseOrID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_BitwiseOrID_2(node));
				break;
			}
			case Op_BitwiseXorAssignID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_BitwiseXorAssignID_2(node));
				break;
			}
			case Op_BitwiseXorID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_BitwiseXorID_2(node));
				break;
			}
			case Op_CommaID:
			{
				if ( SemanticUtils.getChildCount(node) >= 2 )
					return(new JBurgAnnotation_Op_CommaID_2_n(node));
				break;
			}
			case Op_DeleteID:
			{
				if ( SemanticUtils.getChildCount(node) == 1 )
					return(new JBurgAnnotation_Op_DeleteID_1(node));
				break;
			}
			case Op_DescendantsID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_DescendantsID_2(node));
				break;
			}
			case Op_DivideAssignID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_DivideAssignID_2(node));
				break;
			}
			case Op_DivideID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_DivideID_2(node));
				break;
			}
			case Op_EqualID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_EqualID_2(node));
				break;
			}
			case Op_GreaterThanEqualsID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_GreaterThanEqualsID_2(node));
				break;
			}
			case Op_GreaterThanID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_GreaterThanID_2(node));
				break;
			}
			case Op_InID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_InID_2(node));
				break;
			}
			case Op_InstanceOfID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_InstanceOfID_2(node));
				break;
			}
			case Op_IsID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_IsID_2(node));
				break;
			}
			case Op_LeftShiftAssignID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_LeftShiftAssignID_2(node));
				break;
			}
			case Op_LeftShiftID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_LeftShiftID_2(node));
				break;
			}
			case Op_LessThanEqualsID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_LessThanEqualsID_2(node));
				break;
			}
			case Op_LessThanID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_LessThanID_2(node));
				break;
			}
			case Op_LogicalAndID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_LogicalAndID_2(node));
				break;
			}
			case Op_LogicalNotID:
			{
				if ( SemanticUtils.getChildCount(node) == 1 )
					return(new JBurgAnnotation_Op_LogicalNotID_1(node));
				break;
			}
			case Op_LogicalOrID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_LogicalOrID_2(node));
				break;
			}
			case Op_ModuloAssignID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_ModuloAssignID_2(node));
				break;
			}
			case Op_ModuloID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_ModuloID_2(node));
				break;
			}
			case Op_MultiplyAssignID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_MultiplyAssignID_2(node));
				break;
			}
			case Op_MultiplyID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_MultiplyID_2(node));
				break;
			}
			case Op_NotEqualID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_NotEqualID_2(node));
				break;
			}
			case Op_PostDecrID:
			{
				if ( SemanticUtils.getChildCount(node) == 1 )
					return(new JBurgAnnotation_Op_PostDecrID_1(node));
				break;
			}
			case Op_PostIncrID:
			{
				if ( SemanticUtils.getChildCount(node) == 1 )
					return(new JBurgAnnotation_Op_PostIncrID_1(node));
				break;
			}
			case Op_PreDecrID:
			{
				if ( SemanticUtils.getChildCount(node) == 1 )
					return(new JBurgAnnotation_Op_PreDecrID_1(node));
				break;
			}
			case Op_PreIncrID:
			{
				if ( SemanticUtils.getChildCount(node) == 1 )
					return(new JBurgAnnotation_Op_PreIncrID_1(node));
				break;
			}
			case Op_RightShiftAssignID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_RightShiftAssignID_2(node));
				break;
			}
			case Op_RightShiftID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_RightShiftID_2(node));
				break;
			}
			case Op_StrictEqualID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_StrictEqualID_2(node));
				break;
			}
			case Op_StrictNotEqualID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_StrictNotEqualID_2(node));
				break;
			}
			case Op_SubtractAssignID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_SubtractAssignID_2(node));
				break;
			}
			case Op_SubtractID:
			{
				if ( SemanticUtils.getChildCount(node) == 1 )
					return(new JBurgAnnotation_Op_SubtractID_1(node));
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_SubtractID_2(node));
				break;
			}
			case Op_TypeOfID:
			{
				if ( SemanticUtils.getChildCount(node) == 1 )
					return(new JBurgAnnotation_Op_TypeOfID_1(node));
				break;
			}
			case Op_UnsignedRightShift:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_UnsignedRightShift_2(node));
				break;
			}
			case Op_UnsignedRightShiftAssignID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_Op_UnsignedRightShiftAssignID_2(node));
				break;
			}
			case Op_VoidID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_Op_VoidID_0(node));
				if ( SemanticUtils.getChildCount(node) == 1 )
					return(new JBurgAnnotation_Op_VoidID_1(node));
				break;
			}
			case QualifiedNamespaceExpressionID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_QualifiedNamespaceExpressionID_2(node));
				break;
			}
			case RuntimeNameExpressionID:
			{
				if ( SemanticUtils.getChildCount(node) == 1 )
					return(new JBurgAnnotation_RuntimeNameExpressionID_1(node));
				break;
			}
			case TernaryExpressionID:
			{
				if ( SemanticUtils.getChildCount(node) == 3 )
					return(new JBurgAnnotation_TernaryExpressionID_3(node));
				break;
			}
			case TypedExpressionID:
			{
				if ( SemanticUtils.getChildCount(node) == 2 )
					return(new JBurgAnnotation_TypedExpressionID_2(node));
				break;
			}
			case VariableExpressionID:
			{
				if ( SemanticUtils.getChildCount(node) == 1 )
					return(new JBurgAnnotation_VariableExpressionID_1(node));
				break;
			}
			case VectorLiteralID:
			{
				if ( SemanticUtils.getChildCount(node) >= 2 )
					return(new JBurgAnnotation_VectorLiteralID_2_n(node));
				break;
			}
			case VoidID:
			{
				if ( SemanticUtils.getChildCount(node) == 0 )
					return(new JBurgAnnotation_VoidID_0(node));
				break;
			}
			case XMLContentID:
			{
				if ( SemanticUtils.getChildCount(node) >= 1 )
					return(new JBurgAnnotation_XMLContentID_1_n(node));
				break;
			}
			case XMLListContentID:
			{
				if ( SemanticUtils.getChildCount(node) >= 1 )
					return(new JBurgAnnotation_XMLListContentID_1_n(node));
				break;
			}
		}
		return new JBurgAnnotationGeneral(node, nStates+1);
	}
	
	public void reduce( JBurgAnnotation p, int goalState) throws java.lang.Exception
	{
		reduceAntecedent(p,goalState);
		/* Release the annotation's data. */
		p.release();
	}
	
	public void reduceAntecedent( JBurgAnnotation p, int goalState) throws java.lang.Exception
	{int iRule = -1;
		if ( ( goalState > 0 )  )
		{iRule = p.getRule(goalState);
		}
		else
		{
			/* Find the minimum-cost path. */int minCost = Integer.MAX_VALUE;int i;for( i = 0;i <= nStates;i++ )
			{
				if ( ( minCost > p.getCost(i) )  )
				{iRule = p.getRule(i);minCost = p.getCost(i);goalState = i;
				}
			}
		}
		if ( ( iRule > 0 )  )
		{
			reduceSubgoals(p, iRule);
			dispatchAction(p, iRule );
		}
		else
		{
			{
    BURMAbortException.abort();
}
		}
	}
	
	private void reduceSubgoals( JBurgAnnotation p, int rule_num) throws java.lang.Exception
	{
		if ( ___subgoals_by_rule[rule_num] != null )
		{
			for ( JBurgSubgoal sg : ___subgoals_by_rule[rule_num] )
			{
				if ( !sg.isNary() )
				{
					reduce ( sg.getNode(p), sg.getGoalState());
				}
				else
				{
					/* Aggregate the operands of an n-ary operator into a single container. */
					JBurgAnnotation sub_parent = sg.getNode(p);
					java.util.Vector variadic_result = new java.util.Vector(sub_parent.getArity() - sg.startIndex);
					for ( int j = sg.startIndex; j < sub_parent.getArity(); j++ )
					{
						reduce(sub_parent.getNthChild(j), sg.getGoalState());
						variadic_result.add(__reducedValues.pop());
					}
					__reducedValues.push(variadic_result);
				}
			}
		}
	}
	
	private int getNaryCost( JBurgAnnotation node, int goalState, int start_index)
	{
		int accumCost = 0;
		for ( int i = start_index; i < node.getArity() && accumCost != Integer.MAX_VALUE; i++ )
		{
			int subCost = node.getNthChild(i).getCost(goalState);
			if ( subCost != Integer.MAX_VALUE )
				accumCost += subCost;
			else
				accumCost = Integer.MAX_VALUE;
		}
		return accumCost;
	}
	
	public void burm( IASNode root) throws java.lang.Exception
	{
		/* Use the least-cost goal state available. */
		burm(root, 0);
	}
	
	public void burm( IASNode root, int goal_state) throws java.lang.Exception
	{
		JBurgAnnotation annotatedTree = label(root);
		reduce ( annotatedTree, goal_state);
	}
	
	public Object getResult( )
	{
		return __reducedValues.pop();
	}
	/* @return the input cost, limited to Integer.MAX_VALUE to avoid overflow. */
	
	public int normalizeCost( long c)
	{
		return(c < Integer.MAX_VALUE? (int) c: Integer.MAX_VALUE);
	}

	/** JBurgAnnotation is a data structure internal to the
	 *  JBurg-generated BURM that annotates a JBurgNode with
	 *  information used for dynamic programming and reduction.
	 */
	abstract class JBurgAnnotation
	{
		/**  The INode we're annotating.  */
		IASNode m_node; 
		JBurgAnnotation ( IASNode newNode)
		{
			m_node = newNode;
		}
		/** @return this node's operator. */
		public ASTNodeID getOperator() 
		{
			return m_node.getNodeID(); 
		}
		/** @return this node's wrappedIASNode. */ 
		public IASNode getNode()  
		{
			return m_node; 
		}
		/** @return the nth child of this node.  */
		public abstract JBurgAnnotation getNthChild(int idx);
		/** @return this node's child count.  */
		public abstract int getArity();
		/** Add a new child to this node.  */
		public abstract void addChild(JBurgAnnotation new_child);
		/** Release this node's data.  */
		public abstract void release();
		/** @return the wrapped node's toString().  */
		public String toString() 
		{
			return m_node.toString(); 
		}
		/** @return the current best cost to reach a goal state.  */
		public abstract int getCost( int goalState ) ;
		 /** Set the cost/rule configuration of a goal state.
		 * @throws IllegalArgumentException if this node has a fixed cost/rule.*/
		 public abstract void reset ( int goalState, int cost, int rule );
		/** * @return the rule to fire for a specific goal state. */
		public abstract int getRule ( int goalState ) ;
		/**
		 *  A closure's transformation rule succeeded.
		 *  If this path is selected for reduction, then all the actions  must be run in sequence, beginning with the original;
		 *  so the order of the rules matters.  We disallow transformation rules with  cycles (a node should never 
		 *  transition back to a goal state that has already been reduced).*/
		public abstract void recordAntecedent ( int iGoalState, int newAntecedentState );
	
	}

	abstract class JBurgSpecializedAnnotation extends JBurgAnnotation
	{
		JBurgSpecializedAnnotation(IASNode node)
		{
			super(node);
		}
		public JBurgAnnotation getNthChild(int idx)
		{
			throw new IllegalStateException(this.getClass().getName() + " has no children.");
		}
		public void addChild(JBurgAnnotation new_child)
		{
			throw new IllegalStateException(this.getClass().getName() + " cannot have children.");
		}
		public void reset ( int goalState, int cost, int rule )
		{
			throw new IllegalStateException(this.getClass().getName() + " cannot be reset.");
		}
		public void release ()
		{
		}
		public void recordAntecedent ( int iGoalState, int newAntecedentState )
		{
			throw new IllegalStateException(this.getClass().getName() + " cannot record antecedents.");
		}
	}

	class ErrorAnnotation extends JBurgSpecializedAnnotation
	{
		ErrorAnnotation()
		{
			super(null);
		}
		public int getRule(int state) { return -1; }
		public int getCost(int state) { return Integer.MAX_VALUE; }
		public int getArity() { return 0; }
	}
	final JBurgAnnotation errorAnnotation = new ErrorAnnotation();

	/**  JBurgAnnotation implementation used for general-purpose computation. */
	class JBurgAnnotationGeneral extends JBurgAnnotation
	{
		/** cost/rule matrices used during dynamic programming to compute
		 *  the most economical rules that can reduce  the input node.
		 */
		private int cost[];
		private int rule[];
		/**  Transformation rules may have antecedents: other states whose
		 *  output the transformation rule is intended to transform.
		 *  All such antecedent states must be executed in sequence when the rule is reduced.
		 */
		private int[] antecedentState = null;
		/** *  This node's children (may be empty).  */
		private java.util.Vector m_children = null;
		JBurgAnnotationGeneral ( IASNode newNode, int nRules) 
		{
			super(newNode);
			rule   = new int[nRules];
			cost   = new int[nRules];
			//  Initial cost of all rules is "infinite"
			java.util.Arrays.fill ( cost, Integer.MAX_VALUE);
			//  Initial rule for every goal is zero -- the JVM has zero-filled the rules array.
		}
		/** @return this node's operator. */
		public ASTNodeID getOperator() 
		{
			return m_node.getNodeID(); 
		}
		/** @return this node's wrappedIASNode. */ 
		public IASNode getNode()  
		{
			return m_node; 
		}
		/** @return the nth child of this node.  */
		public JBurgAnnotation getNthChild(int idx)
		{
			if ( m_children != null && m_children.size() > idx)
			{
				return (JBurgAnnotation) m_children.elementAt(idx);
			}
			else
			{
				throw new IllegalArgumentException( String.format("Index %d out of range opcode %s:", idx, this.getOperator() ));
			}
		}
		/** @return this node's child count.  */
		public int getArity()
		{
			return m_children != null? m_children.size():0;
		}
		/** Add a new child to this node.  */
		public void addChild(JBurgAnnotation new_child)
		{
			if (m_children == null)
			m_children = new java.util.Vector();
			if (new_child != null)
			m_children.add(new_child);
		}
		/** Release this node's data.  */
		public void release()
		{
			m_children = null;
			cost = null;
			rule = null;
		}
		/** @return the wrapped node's toString().  */
		public String toString() 
		{
			return m_node.toString(); 
		}
		/** @return the current best cost to reach a goal state.  */
		public int getCost( int goalState ) 
		{
			return cost[goalState]; 
		}
		 /** Set the cost/rule configuration of a goal state.
		 * @throws IllegalArgumentException if this node has a fixed cost/rule.*/
		 public void reset ( int goalState, int cost, int rule )
		{
			this.cost[goalState] = cost;
			this.rule[goalState] = rule;
			//  We have a brand new rule, therefore it has no antecedents.
			if ( this.antecedentState != null )this.antecedentState[goalState] = 0;
		}
		/** * @return the rule to fire for a specific goal state. */
		public int getRule ( int goalState ) 
		{
			return rule[goalState]; 
		}
		/**
		 *  A closure's transformation rule succeeded.
		 *  If this path is selected for reduction, then all the actions  must be run in sequence, beginning with the original;
		 *  so the order of the rules matters.  We disallow transformation rules with  cycles (a node should never 
		 *  transition back to a goal state that has already been reduced).*/
		public void recordAntecedent ( int iGoalState, int newAntecedentState )
		{
			int antecedentRule = rule[newAntecedentState];
			//  Sanity-check: we shouldn't be asked to record an antecedent state that hasn't been labelled.
			if ( antecedentRule == 0 )
			throw new IllegalStateException ( "Attempting to record an unlabelled antecedent state." );
			if ( antecedentRule == 1 )
			{
				//  Rule 1 is the simple transformation rule; it doesn't run,  but if it has antecedents, then they must run.
				if ( antecedentState != null )
				antecedentState[iGoalState] = antecedentState[newAntecedentState];
			}
			else
			{
				if ( antecedentState == null )
				antecedentState = new int[rule.length];
				antecedentState[iGoalState] = newAntecedentState;
			}
		}
	
	}
	
	static class JBurgSubgoal
	{
		private int goalState;
		private boolean isNary;
		private int startIndex;
		private int[] accessPath;
		
		public JBurgSubgoal( int goal_state, boolean is_nary, int start_index, int... access_path)
		{
			this.goalState = goal_state;
			this.isNary = is_nary;
			this.startIndex = start_index;
			this.accessPath = access_path;
		}
		public int getGoalState() { return this.goalState; }
		public boolean isNary() { return this.isNary; }
		public JBurgAnnotation getNode(JBurgAnnotation root)
		{
			JBurgAnnotation result = root;
			for ( int idx: this.accessPath )
				result = result.getNthChild(idx);
			return result;
		}
	
	}

}