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

ex.flexjs.compiler.debugger.0.7.0.source-code.AS3DebuggerBURM Maven / Gradle / Ivy

The newest version!

/*  Generated Mon Sep 05 11:04:32 CEST 2016 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.flex.abc.ABCConstants.*;
    import static org.apache.flex.compiler.tree.ASTNodeID.*;

    import org.apache.flex.compiler.constants.IASLanguageConstants;
    import org.apache.flex.compiler.exceptions.BURMAbortException;
    import org.apache.flex.compiler.problems.*;
    import org.apache.flex.compiler.internal.semantics.SemanticUtils;
    import org.apache.flex.compiler.tree.ASTNodeID;
    import org.apache.flex.compiler.tree.as.IASNode;
    import org.apache.flex.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_54c9b40(goalState);

						int currentCost = getCostForRule_3a8b2f59(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_2c7fc237(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_54c9b40(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 30;
					}
					currentCost = getCostForRule_3a8b2f59(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 174;
					}
					currentCost = getCostForRule_2c7fc237(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_54c9b40( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
		
		private int getCostForRule_3a8b2f59( 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_2c7fc237( 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_e34cec4(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_e34cec4(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_e34cec4( 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_6f43d2d9(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_6f43d2d9(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_6f43d2d9( 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_c51c98f(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_5eedcc48(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_c51c98f(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_5eedcc48(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_5eedcc48( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__dottedNamePart_NT)) + ((long)this.getNthChild(0).getCost(__dottedNamePart_NT))) ));
		}
		
		private int getCostForRule_c51c98f( 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_76876bbf(goalState);

						int currentCost = getCostForRule_723aaac(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_53c0676(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_35830515(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_78144a89(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_6278f9ed(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_7924c62(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_2a145a28(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_708e0de1(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_559c258c(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_40789201(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_76876bbf(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 107;
					}
					currentCost = getCostForRule_723aaac(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 108;
					}
					currentCost = getCostForRule_53c0676(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 109;
					}
					currentCost = getCostForRule_35830515(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 110;
					}
					currentCost = getCostForRule_78144a89(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 111;
					}
					currentCost = getCostForRule_6278f9ed(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 112;
					}
					currentCost = getCostForRule_7924c62(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 113;
					}
					currentCost = getCostForRule_2a145a28(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 135;
					}
					currentCost = getCostForRule_708e0de1(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 136;
					}
					currentCost = getCostForRule_559c258c(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 137;
					}
					currentCost = getCostForRule_40789201(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_76876bbf( 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_723aaac( 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_53c0676( 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_35830515( 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_78144a89( 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_6278f9ed( 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_7924c62( 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_2a145a28( 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_708e0de1( 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_559c258c( 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_40789201( 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_48b5553c(goalState);

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

						int currentCost = getCostForRule_7cd0440d(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_783c290c(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_1a429f82(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_773d46dc(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_9b3841a(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_10dea869(goalState);

						int currentCost = getCostForRule_1eee8b7f(goalState);

						if ( ( cachedCostFor_name > currentCost )  )
							cachedCostFor_name = currentCost;
						currentCost = getCostForRule_3f825d8(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_48b5553c(goalState);

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

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_4854a8ce(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 124;
					}
					currentCost = getCostForRule_7cd0440d(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 164;
					}
					currentCost = getCostForRule_783c290c(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 165;
					}
					currentCost = getCostForRule_1a429f82(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 170;
					}
					currentCost = getCostForRule_773d46dc(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 171;
					}
					currentCost = getCostForRule_9b3841a(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_10dea869(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 98;
					}
					currentCost = getCostForRule_1eee8b7f(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 99;
					}
					currentCost = getCostForRule_3f825d8(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_48b5553c( int goalState)
		{

			return(normalizeCost((long)0 + (long) (((long)this.getNthChild(1).getCost(__dottedNamePart_NT)) + ((long)this.getNthChild(0).getCost(__dottedNamePart_NT))) ));
		}
		
		private int getCostForRule_10dea869( 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_1eee8b7f( 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_4854a8ce( int goalState)
		{

			return(normalizeCost((long)10 + (long) (((long)this.getNthChild(1).getCost(__name_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
		
		private int getCostForRule_7cd0440d( 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_783c290c( 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_1a429f82( 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_773d46dc( 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_3f825d8( 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_9b3841a( 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_167ee2e9(goalState);

						int currentCost = getCostForRule_73869daf(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_195955d3(goalState);

						int currentCost = getCostForRule_5b4d65c5(goalState);

						if ( ( cachedCostFor_runtime_name_expression > currentCost )  )
							cachedCostFor_runtime_name_expression = currentCost;
						currentCost = getCostForRule_3ac5bdef(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_167ee2e9(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 127;
					}
					currentCost = getCostForRule_73869daf(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_195955d3(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 131;
					}
					currentCost = getCostForRule_5b4d65c5(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 132;
					}
					currentCost = getCostForRule_3ac5bdef(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_167ee2e9( 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_73869daf( 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_195955d3( 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_5b4d65c5( int goalState)
		{

			return(normalizeCost((long)2000 + (long) (((long)this.getNthChild(1).getCost(__name_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
		
		private int getCostForRule_3ac5bdef( 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_7de934fd(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_7de934fd(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_7de934fd( 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_2ecd015e(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_2ecd015e(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_2ecd015e( 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_1e1e3a0f(goalState);

						int currentCost = getCostForRule_923d6e6(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_3d5945e3(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_1e1e3a0f(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 56;
					}
					currentCost = getCostForRule_923d6e6(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 57;
					}
					currentCost = getCostForRule_3d5945e3(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_1e1e3a0f( 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_923d6e6( 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_3d5945e3( 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_7b5874e7(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_7b5874e7(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_7b5874e7( 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_1479e7c1(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_1479e7c1(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_1479e7c1( 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_3fa974e(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_3fa974e(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_3fa974e( 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_747bbc8f(goalState);

						int currentCost = getCostForRule_4cbc11ab(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_1720a012(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_40b7055f(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_69014602(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_451c23c0(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_572e2b41(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_2fcb5106(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_4c1923ab(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_683f0bcb(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_4eed51ae(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_3b5b6a14(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_3eda12af(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_747bbc8f(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 1;
					}
					currentCost = getCostForRule_4cbc11ab(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 62;
					}
					currentCost = getCostForRule_1720a012(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 63;
					}
					currentCost = getCostForRule_40b7055f(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 64;
					}
					currentCost = getCostForRule_69014602(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 65;
					}
					currentCost = getCostForRule_451c23c0(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 66;
					}
					currentCost = getCostForRule_572e2b41(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 67;
					}
					currentCost = getCostForRule_2fcb5106(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 68;
					}
					currentCost = getCostForRule_4c1923ab(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 70;
					}
					currentCost = getCostForRule_683f0bcb(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 71;
					}
					currentCost = getCostForRule_4eed51ae(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 72;
					}
					currentCost = getCostForRule_3b5b6a14(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_3eda12af(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_747bbc8f( 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_4cbc11ab( 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_1720a012( 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_40b7055f( 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_69014602( int goalState)
		{

			return(normalizeCost((long)2 + (long) (((long)this.getNthChild(1).getCost(__expression_NT)) + ((long)this.getNthChild(0).getCost(__name_NT))) ));
		}
		
		private int getCostForRule_451c23c0( 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_572e2b41( 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_2fcb5106( 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_3eda12af( 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_4c1923ab( 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_683f0bcb( 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_4eed51ae( 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_3b5b6a14( 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_2e2b37ec(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_2e2b37ec(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_2e2b37ec( 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_aef73a6(goalState);

						int currentCost = getCostForRule_6a04a325(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_4258ba0(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_aef73a6(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 32;
					}
					currentCost = getCostForRule_6a04a325(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 33;
					}
					currentCost = getCostForRule_4258ba0(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_aef73a6( 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_6a04a325( 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_4258ba0( 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_73c6489f(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_73c6489f(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_73c6489f( 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_2457702(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_2457702(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_2457702( 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_4d17f1e4(goalState);

						int currentCost = getCostForRule_65471b6d(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_248435ea(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_4d17f1e4(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 35;
					}
					currentCost = getCostForRule_65471b6d(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 36;
					}
					currentCost = getCostForRule_248435ea(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_4d17f1e4( 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_65471b6d( 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_248435ea( 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_dd0bb1f(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_dd0bb1f(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_dd0bb1f( 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_7f3af390(goalState);

						int currentCost = getCostForRule_227b1369(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_27d549a9(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_7f3af390(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 38;
					}
					currentCost = getCostForRule_227b1369(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 39;
					}
					currentCost = getCostForRule_27d549a9(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_7f3af390( 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_227b1369( 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_27d549a9( 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_2f55060f(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_2f55060f(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_2f55060f( 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_75bc606(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_75bc606(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_75bc606( 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_7dc17ddf(goalState);

						int currentCost = getCostForRule_70d4ebcf(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_77b6eea4(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_2e046da2(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_585dc238(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_f80d06f(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_4f03dcf5(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_7dc17ddf(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 88;
					}
					currentCost = getCostForRule_70d4ebcf(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 89;
					}
					currentCost = getCostForRule_77b6eea4(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 90;
					}
					currentCost = getCostForRule_2e046da2(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 91;
					}
					currentCost = getCostForRule_585dc238(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 92;
					}
					currentCost = getCostForRule_f80d06f(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 93;
					}
					currentCost = getCostForRule_4f03dcf5(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_7dc17ddf( int goalState)
		{

			return(normalizeCost((long)2000 + (long)((long)this.getNthChild(0).getCost(__expression_NT))));
		}
		
		private int getCostForRule_70d4ebcf( 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_77b6eea4( 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_2e046da2( 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_585dc238( 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_f80d06f( int goalState)
		{

			return(normalizeCost((long)2 + (long)((long)this.getNthChild(0).getCost(__name_NT))));
		}
		
		private int getCostForRule_4f03dcf5( 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_4267c1ca(goalState);

						int currentCost = getCostForRule_749d87bc(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_7d9732e8(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_2c22bddb(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_50375004(goalState);
						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_488f8dd9(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_4267c1ca(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 95;
					}
					currentCost = getCostForRule_749d87bc(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 166;
					}
					currentCost = getCostForRule_7d9732e8(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 167;
					}
					currentCost = getCostForRule_2c22bddb(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 168;
					}
					currentCost = getCostForRule_50375004(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 169;
					}
					currentCost = getCostForRule_488f8dd9(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_4267c1ca( int goalState)
		{

			return(normalizeCost((long)1 + (long) (((long)this.getNthChild(1).getCost(__name_NT)) + ((long)this.getNthChild(0).getCost(__expression_NT))) ));
		}
		
		private int getCostForRule_749d87bc( 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_7d9732e8( 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_2c22bddb( 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_50375004( 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_488f8dd9( 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_ccbe652(goalState);

						int currentCost = getCostForRule_35be5e75(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_5f639fb6(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_ccbe652(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 41;
					}
					currentCost = getCostForRule_35be5e75(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 42;
					}
					currentCost = getCostForRule_5f639fb6(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_ccbe652( 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_35be5e75( 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_5f639fb6( 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_6b3630c6(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_6b3630c6(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_6b3630c6( 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_381ca284(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_381ca284(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_381ca284( 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_7f961e04(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_7f961e04(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_7f961e04( 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_3c4bb06f(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_3c4bb06f(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_3c4bb06f( 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_66a11720(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_66a11720(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_66a11720( 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_3b7481f2(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_3b7481f2(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_3b7481f2( 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_745ddea6(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_745ddea6(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_745ddea6( 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_1574d08a(goalState);

						int currentCost = getCostForRule_7b82cd13(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_6466a880(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_1574d08a(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 44;
					}
					currentCost = getCostForRule_7b82cd13(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 45;
					}
					currentCost = getCostForRule_6466a880(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_1574d08a( 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_7b82cd13( 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_6466a880( 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_7e54f244(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_7e54f244(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_7e54f244( 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_4d978d84(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_4d978d84(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_4d978d84( 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_20103b70(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_20103b70(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_20103b70( 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_71e3b55a(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_71e3b55a(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_71e3b55a( 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_28fcbff0(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_28fcbff0(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_28fcbff0( 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_59f6ecc6(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_59f6ecc6(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_59f6ecc6( 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_789c8733(goalState);

						int currentCost = getCostForRule_1439a41f(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_59f78a57(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_789c8733(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 50;
					}
					currentCost = getCostForRule_1439a41f(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 51;
					}
					currentCost = getCostForRule_59f78a57(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_789c8733( 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_1439a41f( 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_59f78a57( 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_3709cd73(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_3709cd73(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_3709cd73( 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_2b3071be(goalState);

						int currentCost = getCostForRule_7270219b(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_1730a8b0(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_2b3071be(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 53;
					}
					currentCost = getCostForRule_7270219b(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 54;
					}
					currentCost = getCostForRule_1730a8b0(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_2b3071be( 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_7270219b( 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_1730a8b0( 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_6e2b9d70(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_6e2b9d70(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_6e2b9d70( 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_46beac8a(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_46beac8a(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_46beac8a( 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_35b1213f(goalState);

						int currentCost = getCostForRule_27567a11(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_15a4b396(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_35b1213f(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 152;
					}
					currentCost = getCostForRule_27567a11(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 153;
					}
					currentCost = getCostForRule_15a4b396(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_35b1213f( 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_27567a11( 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_15a4b396( 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_26cd8754(goalState);

						int currentCost = getCostForRule_1ac9e26b(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_e5b85d1(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_26cd8754(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 155;
					}
					currentCost = getCostForRule_1ac9e26b(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 156;
					}
					currentCost = getCostForRule_e5b85d1(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_26cd8754( 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_1ac9e26b( 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_e5b85d1( 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_3ed3af8f(goalState);

						int currentCost = getCostForRule_746e7826(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_2161167a(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_3ed3af8f(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 158;
					}
					currentCost = getCostForRule_746e7826(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 159;
					}
					currentCost = getCostForRule_2161167a(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_3ed3af8f( 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_746e7826( 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_2161167a( 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_73467a8a(goalState);

						int currentCost = getCostForRule_504a1cba(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_57e2f1dd(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_73467a8a(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 161;
					}
					currentCost = getCostForRule_504a1cba(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 162;
					}
					currentCost = getCostForRule_57e2f1dd(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_73467a8a( 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_504a1cba( 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_57e2f1dd( 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_7e99ef9d(goalState);

						int currentCost = getCostForRule_3ecb48ee(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_3e642c41(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_7e99ef9d(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 59;
					}
					currentCost = getCostForRule_3ecb48ee(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 60;
					}
					currentCost = getCostForRule_3e642c41(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_7e99ef9d( 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_3ecb48ee( 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_3e642c41( 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_7e485e49(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_7e485e49(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_7e485e49( 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_4f9cb31a(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_4f9cb31a(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_4f9cb31a( 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_2b740e3f(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_2b740e3f(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_2b740e3f( 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_346d2934(goalState);

						int currentCost = getCostForRule_8eb83e6(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_2245e582(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_346d2934(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 47;
					}
					currentCost = getCostForRule_8eb83e6(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 48;
					}
					currentCost = getCostForRule_2245e582(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_346d2934( 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_8eb83e6( 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_2245e582( 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_29cb0203(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_29cb0203(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_29cb0203( 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_74b2aa87(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_74b2aa87(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_74b2aa87( 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_2012e344(goalState);

						int currentCost = getCostForRule_2df67b31(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_2012e344(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 187;
					}
					currentCost = getCostForRule_2df67b31(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_2012e344( int goalState)
		{

			return(normalizeCost((long)10 + (long)((long)this.getNthChild(0).getCost(__expression_NT))));
		}
		
		private int getCostForRule_2df67b31( 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_5c5caf96(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_5c5caf96(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_5c5caf96( 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_3d5bc008(goalState);

						int currentCost = getCostForRule_ae40c24(goalState);

						if ( ( cachedCostFor_expression > currentCost )  )
							cachedCostFor_expression = currentCost;
						currentCost = getCostForRule_14d5c1ba(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_3d5bc008(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 74;
					}
					currentCost = getCostForRule_ae40c24(goalState);
					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 75;
					}
					currentCost = getCostForRule_14d5c1ba(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_3d5bc008( 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_ae40c24( 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_14d5c1ba( 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_2dcceca9(goalState);

					}
					return(cachedCostFor_constant_value);
				}
				case __expression_NT:
				{
					if ( cachedCostFor_expression == -1 )
					{
						cachedCostFor_expression = getCostForRule_4e742298(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_2dcceca9(goalState);

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

					int bestCost = Integer.MAX_VALUE;

					int currentCost = getCostForRule_4e742298(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_2dcceca9( int goalState)
		{

			return(normalizeCost((long)0 + (long)((long)this.getNthChild(0).getCost(__constant_value_NT))));
		}
		
		private int getCostForRule_4e742298( 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_645b825e(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_645b825e(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_645b825e( 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_5eb9577e(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_5eb9577e(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_5eb9577e( 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_14da41a4(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_14da41a4(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_14da41a4( 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_7b55c145(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_4324e503(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_7b55c145(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_4324e503(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_4324e503( 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_7b55c145( 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_573258be(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_573258be(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_573258be( 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_1123f49d(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_1123f49d(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_1123f49d( 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_44294015(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_44294015(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_44294015( 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_20c1b96e(goalState);

						int currentCost = getCostForRule_6573f260(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_20c1b96e(goalState);

					if ( ( bestCost > currentCost )  )
					{
						bestCost = currentCost;
						rule = 26;
					}
					currentCost = getCostForRule_6573f260(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_20c1b96e( 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_6573f260( 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;
		}
	
	}

}