Source Code of org.formulacompiler.compiler.internal.bytecode.ExpressionCompilerForScaledBigDecimals_Generated

/**
 * DO NOT MODIFY! This file is generated automatically from org.formulacompiler.compiler.internal.templates.ExpressionTemplatesForScaledBigDecimals.
 * Generated using jdk-1.5.0_22.
 */
package org.formulacompiler.compiler.internal.bytecode;


import org.objectweb.asm.Label;
import org.objectweb.asm.Opcodes;
import org.objectweb.asm.Type;
import org.objectweb.asm.commons.GeneratorAdapter;


import org.formulacompiler.runtime.ComputationMode;
import org.formulacompiler.compiler.CompilerException;
import org.formulacompiler.compiler.Operator;
import org.formulacompiler.compiler.NumericType;
import org.formulacompiler.compiler.internal.expressions.ExpressionNode;
import org.formulacompiler.compiler.internal.expressions.ExpressionNodeForFunction;




@SuppressWarnings("unused")
abstract class ExpressionCompilerForScaledBigDecimals_Generated extends ExpressionCompilerForScaledBigDecimals_Base
{


  public ExpressionCompilerForScaledBigDecimals_Generated(MethodCompiler _methodCompiler, NumericType _numericType)
  {
    super( _methodCompiler, _numericType );
  }


  protected final void compile_util_adjustValue() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile_fixedScale();
    compile_roundingMode();
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "setScale", "(II)Ljava/math/BigDecimal;" );
  }


  private final void compile_op_PLUS( ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _b );
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "add", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
  }


  private final void compile_op_MINUS( ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _b );
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "subtract", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
  }


  private final void compile_op_TIMES( ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _b );
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "multiply", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_op_DIV__if_needsValueAdjustment( ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _b );
    compile_fixedScale();
    compile_roundingMode();
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "divide", "(Ljava/math/BigDecimal;II)Ljava/math/BigDecimal;" );
  }


  private final void compile_op_DIV( ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _b );
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "divide", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
  }


  private final void compile_op_EXP( ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _b );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "UNLIMITED", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "fun_POWER", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_op_PERCENT() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitInsn( Opcodes.ICONST_2 );
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "movePointLeft", "(I)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_DEGREES( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "fun_DEGREES", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_RADIANS( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "fun_RADIANS", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_CEILING__for_EXCEL( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "HIGHPREC", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_CEILING", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_CEILING__for_OPEN_OFFICE_CALC( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "HIGHPREC", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_CEILING_OOo", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_FLOOR__for_EXCEL( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "HIGHPREC", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_FLOOR", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_FLOOR__for_OPEN_OFFICE_CALC( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "HIGHPREC", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_FLOOR_OOo", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_POWER( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "UNLIMITED", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "fun_POWER", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_SQRT( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "HIGHPREC", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "fun_SQRT", "(Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_FACT( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "UNLIMITED", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "fun_FACT", "(Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_IRR( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compileArray( _a );
    compile( _b );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "HIGHPREC", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "fun_IRR", "([Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_DB( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c, ExpressionNode _d, ExpressionNode _e ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    compile( _d );
    compile( _e );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "HIGHPREC", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "fun_DB", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_DB( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c, ExpressionNode _d ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    compile( _d );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "TWELVE", "Ljava/math/BigDecimal;" );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "HIGHPREC", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "fun_DB", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_DDB( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c, ExpressionNode _d, ExpressionNode _e ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    compile( _d );
    compile( _e );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "HIGHPREC", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "fun_DDB", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_DDB( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c, ExpressionNode _d ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    compile( _d );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "TWO", "Ljava/math/BigDecimal;" );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "HIGHPREC", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "fun_DDB", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_VDB( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c, ExpressionNode _d, ExpressionNode _e, ExpressionNode _f, ExpressionNode _g ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    incLocalsOffset( 1 );
    Label l_0 = new Label();
    Label l_1 = new Label();
    compile( _g );
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "intValue", "()I" );
    mv.visitJumpInsn( Opcodes.IFEQ, l_0 );
    mv.visitInsn( Opcodes.ICONST_1 );
    mv.visitJumpInsn( Opcodes.GOTO, l_1 );
    mv.visitLabel( l_0 );
    mv.visitInsn( Opcodes.ICONST_0 );
    mv.visitLabel( l_1 );
    mv.visitVarInsn( Opcodes.ISTORE, 0 + loc );
    compile( _a );
    compile( _b );
    compile( _c );
    compile( _d );
    compile( _e );
    compile( _f );
    mv.visitVarInsn( Opcodes.ILOAD, 0 + loc );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "HIGHPREC", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "fun_VDB", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;ZLjava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_RATE( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c, ExpressionNode _d, ExpressionNode _e, ExpressionNode _f ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    compile( _d );
    compile( _e );
    compile( _f );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "HIGHPREC", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "fun_RATE", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_RATE( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c, ExpressionNode _d, ExpressionNode _e ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    compile( _d );
    compile( _e );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "TENTH", "Ljava/math/BigDecimal;" );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "HIGHPREC", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "fun_RATE", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_RATE( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c, ExpressionNode _d ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    compile( _d );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "ZERO", "Ljava/math/BigDecimal;" );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "TENTH", "Ljava/math/BigDecimal;" );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "HIGHPREC", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "fun_RATE", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_RATE( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "ZERO", "Ljava/math/BigDecimal;" );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "ZERO", "Ljava/math/BigDecimal;" );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "TENTH", "Ljava/math/BigDecimal;" );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "HIGHPREC", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "fun_RATE", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_TIME__for_EXCEL( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "HIGHPREC", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_TIME", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_TIME__for_OPEN_OFFICE_CALC( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeScaledBigDecimal_v2", "HIGHPREC", "Ljava/math/MathContext;" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_TIME_OOo", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/MathContext;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  protected final void compile_util_round( int _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.push( _b );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "round", "(Ljava/math/BigDecimal;I)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  protected final void compile_util_fromInt() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitInsn( Opcodes.I2L );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "java/math/BigDecimal", "valueOf", "(J)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  protected final void compile_util_fromLong() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "java/math/BigDecimal", "valueOf", "(J)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  protected final void compile_util_fromDouble() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "java/math/BigDecimal", "valueOf", "(D)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  protected final void compile_util_fromFloat() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitInsn( Opcodes.F2D );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "java/math/BigDecimal", "valueOf", "(D)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  protected final void compile_util_fromBigDecimal() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "toNum", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  protected final void compile_util_fromBigInteger() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    Label l_0 = new Label();
    Label l_1 = new Label();
    mv.visitInsn( Opcodes.DUP );
    mv.visitVarInsn( Opcodes.ASTORE, 0 + loc );
    mv.visitJumpInsn( Opcodes.IFNONNULL, l_0 );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "java/math/BigDecimal", "ZERO", "Ljava/math/BigDecimal;" );
    mv.visitJumpInsn( Opcodes.GOTO, l_1 );
    mv.visitLabel( l_0 );
    mv.visitTypeInsn( Opcodes.NEW, "java/math/BigDecimal" );
    mv.visitInsn( Opcodes.DUP );
    mv.visitVarInsn( Opcodes.ALOAD, 0 + loc );
    mv.visitMethodInsn( Opcodes.INVOKESPECIAL, "java/math/BigDecimal", "<init>", "(Ljava/math/BigInteger;)V" );
    mv.visitLabel( l_1 );
    compileValueAdjustment();
  }


  protected final void compile_util_fromNumber() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    Label l_0 = new Label();
    Label l_1 = new Label();
    mv.visitInsn( Opcodes.DUP );
    mv.visitVarInsn( Opcodes.ASTORE, 0 + loc );
    mv.visitJumpInsn( Opcodes.IFNONNULL, l_0 );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "java/math/BigDecimal", "ZERO", "Ljava/math/BigDecimal;" );
    mv.visitJumpInsn( Opcodes.GOTO, l_1 );
    mv.visitLabel( l_0 );
    mv.visitTypeInsn( Opcodes.NEW, "java/math/BigDecimal" );
    mv.visitInsn( Opcodes.DUP );
    mv.visitVarInsn( Opcodes.ALOAD, 0 + loc );
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/lang/Object", "toString", "()Ljava/lang/String;" );
    mv.visitMethodInsn( Opcodes.INVOKESPECIAL, "java/math/BigDecimal", "<init>", "(Ljava/lang/String;)V" );
    mv.visitLabel( l_1 );
    compileValueAdjustment();
  }


  protected final void compile_util_fromBoolean() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "booleanToNum", "(Z)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  protected final void compile_util_fromDate() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile_environment();
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "org/formulacompiler/runtime/internal/Environment", "timeZone", "()Ljava/util/TimeZone;" );
    compile_computationMode();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "dateToNum", "(Ljava/util/Date;Ljava/util/TimeZone;Lorg/formulacompiler/runtime/ComputationMode;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  protected final void compile_util_fromMsSinceUTC1970() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile_environment();
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "org/formulacompiler/runtime/internal/Environment", "timeZone", "()Ljava/util/TimeZone;" );
    compile_computationMode();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeDouble_v2", "msSinceUTC1970ToNum", "(JLjava/util/TimeZone;Lorg/formulacompiler/runtime/ComputationMode;)D" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "java/math/BigDecimal", "valueOf", "(D)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  protected final void compile_util_fromMs() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeDouble_v2", "msToNum", "(J)D" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "java/math/BigDecimal", "valueOf", "(D)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  protected final void compile_util_toByte() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "byteValue", "()B" );
  }


  protected final void compile_util_toShort() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "shortValue", "()S" );
  }


  protected final void compile_util_toInt() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "intValue", "()I" );
  }


  protected final void compile_util_toLong() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "longValue", "()J" );
  }


  protected final void compile_util_toDouble() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "doubleValue", "()D" );
  }


  protected final void compile_util_toFloat() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "floatValue", "()F" );
  }


  protected final void compile_util_toBigInteger() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "toBigInteger", "()Ljava/math/BigInteger;" );
  }


  protected final void compile_util_toBigDecimal() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
  }


  protected final void compile_util_toBoolean() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "booleanFromNum", "(Ljava/math/BigDecimal;)Z" );
  }


  protected final void compile_util_toCharacter() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "intValue", "()I" );
    mv.visitInsn( Opcodes.I2C );
  }


  protected final void compile_util_toDate() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile_environment();
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "org/formulacompiler/runtime/internal/Environment", "timeZone", "()Ljava/util/TimeZone;" );
    compile_computationMode();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "dateFromNum", "(Ljava/math/BigDecimal;Ljava/util/TimeZone;Lorg/formulacompiler/runtime/ComputationMode;)Ljava/util/Date;" );
  }


  protected final void compile_util_toMsSinceUTC1970() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "doubleValue", "()D" );
    compile_environment();
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "org/formulacompiler/runtime/internal/Environment", "timeZone", "()Ljava/util/TimeZone;" );
    compile_computationMode();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeDouble_v2", "msSinceUTC1970FromNum", "(DLjava/util/TimeZone;Lorg/formulacompiler/runtime/ComputationMode;)J" );
  }


  protected final void compile_util_toMs() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "doubleValue", "()D" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeDouble_v2", "msFromNum", "(D)J" );
  }


  protected final void compile_util_toString() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile_environment();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "toExcelString", "(Ljava/math/BigDecimal;Lorg/formulacompiler/runtime/internal/Environment;)Ljava/lang/String;" );
  }


  protected final void compile_util_toNumber() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compileValueAdjustment();
  }


  protected final void compile_util_fromScaledLong( int _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.push( _b );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fromScaledLong", "(JI)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  protected final void compile_util_toScaledLong( int _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.push( _b );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "toScaledLong", "(Ljava/math/BigDecimal;I)J" );
  }


  private final void compile_op_MINUS() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "negate", "()Ljava/math/BigDecimal;" );
  }


  private final void compile_op_INTERNAL_MIN( ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _b );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "min", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
  }


  private final void compile_op_INTERNAL_MAX( ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _b );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "max", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
  }


  private final void compile_fun_ABS( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "abs", "()Ljava/math/BigDecimal;" );
  }


  private final void compile_fun_ACOS( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_ACOS", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_ACOSH( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_ACOSH", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_ASIN( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_ASIN", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_ASINH( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_ASINH", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_ATAN( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_ATAN", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_ATANH( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_ATANH", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_ATAN2( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_ATAN2", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_COS( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_COS", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_COSH( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_COSH", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_SIN( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_SIN", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_SINH( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_SINH", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_SIGN( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "signum", "()I" );
    mv.visitInsn( Opcodes.I2L );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "java/math/BigDecimal", "valueOf", "(J)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_TAN( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_TAN", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_TANH( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_TANH", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_PI() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_PI", "()Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_RAND() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_RAND", "()Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_ROUND( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_ROUND", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_ROUNDDOWN( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_ROUNDDOWN", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_ROUNDUP( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_ROUNDUP", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_TRUNC( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_TRUNC", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_TRUNC( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_TRUNC", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_EVEN( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_EVEN", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_ODD( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_ODD", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_INT( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_INT", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_EXP( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "doubleValue", "()D" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "java/lang/Math", "exp", "(D)D" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "java/math/BigDecimal", "valueOf", "(D)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_LN( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_LN", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_LOG( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_LOG10", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_LOG( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_LOG", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_LOG10( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_LOG10", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_ERF( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_ERF", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_ERFC( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_ERFC", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_BETADIST( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_BETADIST", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_BETAINV( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_BETAINV", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_BINOMDIST( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c, ExpressionNode _d ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    Label l_0 = new Label();
    Label l_1 = new Label();
    compile( _a );
    compile( _b );
    compile( _c );
    compile( _d );
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "signum", "()I" );
    mv.visitJumpInsn( Opcodes.IFEQ, l_0 );
    mv.visitInsn( Opcodes.ICONST_1 );
    mv.visitJumpInsn( Opcodes.GOTO, l_1 );
    mv.visitLabel( l_0 );
    mv.visitInsn( Opcodes.ICONST_0 );
    mv.visitLabel( l_1 );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_BINOMDIST", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Z)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_CHIDIST( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_CHIDIST", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_CHIINV( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_CHIINV", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_CRITBINOM( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_CRITBINOM", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_FINV( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_FINV", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_GAMMADIST( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c, ExpressionNode _d ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    Label l_0 = new Label();
    Label l_1 = new Label();
    compile( _a );
    compile( _b );
    compile( _c );
    compile( _d );
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "signum", "()I" );
    mv.visitJumpInsn( Opcodes.IFEQ, l_0 );
    mv.visitInsn( Opcodes.ICONST_1 );
    mv.visitJumpInsn( Opcodes.GOTO, l_1 );
    mv.visitLabel( l_0 );
    mv.visitInsn( Opcodes.ICONST_0 );
    mv.visitLabel( l_1 );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_GAMMADIST", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Z)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_GAMMAINV( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_GAMMAINV", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_GAMMALN( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_GAMMALN", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_POISSON( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    Label l_0 = new Label();
    Label l_1 = new Label();
    compile( _a );
    compile( _b );
    compile( _c );
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "signum", "()I" );
    mv.visitJumpInsn( Opcodes.IFEQ, l_0 );
    mv.visitInsn( Opcodes.ICONST_1 );
    mv.visitJumpInsn( Opcodes.GOTO, l_1 );
    mv.visitLabel( l_0 );
    mv.visitInsn( Opcodes.ICONST_0 );
    mv.visitLabel( l_1 );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_POISSON", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Z)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_TDIST( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    mv.visitInsn( Opcodes.ICONST_0 );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_TDIST", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Z)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_TDIST( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c, ExpressionNode _d ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    compile( _d );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "booleanFromNum", "(Ljava/math/BigDecimal;)Z" );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_TDIST", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Z)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_TINV( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_TINV", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_MOD( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_MOD", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_WEIBULL( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c, ExpressionNode _d ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    Label l_0 = new Label();
    Label l_1 = new Label();
    compile( _a );
    compile( _b );
    compile( _c );
    compile( _d );
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "signum", "()I" );
    mv.visitJumpInsn( Opcodes.IFEQ, l_0 );
    mv.visitInsn( Opcodes.ICONST_1 );
    mv.visitJumpInsn( Opcodes.GOTO, l_1 );
    mv.visitLabel( l_0 );
    mv.visitInsn( Opcodes.ICONST_0 );
    mv.visitLabel( l_1 );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_WEIBULL", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Z)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_MDETERM( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compileArray( _a );
    compile( _b );
    compileConversionTo( Integer.TYPE );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_MDETERM", "([Ljava/math/BigDecimal;I)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_DATE( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    compile_computationMode();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_DATE", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Lorg/formulacompiler/runtime/ComputationMode;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_SECOND( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_SECOND", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_MINUTE( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_MINUTE", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_HOUR( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_HOUR", "(Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_HYPGEOMDIST( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c, ExpressionNode _d ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile( _c );
    compile( _d );
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_HYPGEOMDIST", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;Ljava/math/BigDecimal;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_WEEKDAY( ExpressionNode _a, ExpressionNode _b ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile( _b );
    compile_computationMode();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_WEEKDAY", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Lorg/formulacompiler/runtime/ComputationMode;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_WEEKDAY( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    mv.visitFieldInsn( Opcodes.GETSTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "ONE", "Ljava/math/BigDecimal;" );
    compile_computationMode();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_WEEKDAY", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;Lorg/formulacompiler/runtime/ComputationMode;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_DAY( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile_computationMode();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_DAY", "(Ljava/math/BigDecimal;Lorg/formulacompiler/runtime/ComputationMode;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_DAYS360( ExpressionNode _a, ExpressionNode _b, ExpressionNode _c ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    Label l_0 = new Label();
    Label l_1 = new Label();
    compile( _a );
    compile( _b );
    compile( _c );
    mv.visitMethodInsn( Opcodes.INVOKEVIRTUAL, "java/math/BigDecimal", "signum", "()I" );
    mv.visitJumpInsn( Opcodes.IFEQ, l_0 );
    mv.visitInsn( Opcodes.ICONST_1 );
    mv.visitJumpInsn( Opcodes.GOTO, l_1 );
    mv.visitLabel( l_0 );
    mv.visitInsn( Opcodes.ICONST_0 );
    mv.visitLabel( l_1 );
    compile_computationMode();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_DAYS360", "(Ljava/math/BigDecimal;Ljava/math/BigDecimal;ZLorg/formulacompiler/runtime/ComputationMode;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_MONTH( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile_computationMode();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_MONTH", "(Ljava/math/BigDecimal;Lorg/formulacompiler/runtime/ComputationMode;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_YEAR( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile( _a );
    compile_computationMode();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_YEAR", "(Ljava/math/BigDecimal;Lorg/formulacompiler/runtime/ComputationMode;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_NOW() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile_environment();
    compile_computationTime();
    compile_computationMode();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_NOW", "(Lorg/formulacompiler/runtime/internal/Environment;Lorg/formulacompiler/runtime/internal/ComputationTime;Lorg/formulacompiler/runtime/ComputationMode;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_TODAY() throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    compile_environment();
    compile_computationTime();
    compile_computationMode();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_TODAY", "(Lorg/formulacompiler/runtime/internal/Environment;Lorg/formulacompiler/runtime/internal/ComputationTime;Lorg/formulacompiler/runtime/ComputationMode;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_VALUE( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    final ExpressionCompilerForStrings str = method().stringCompiler();
    str.compile( _a );
    compile_environment();
    compile_computationMode();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_VALUE", "(Ljava/lang/String;Lorg/formulacompiler/runtime/internal/Environment;Lorg/formulacompiler/runtime/ComputationMode;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_DATEVALUE( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    final ExpressionCompilerForStrings str = method().stringCompiler();
    str.compile( _a );
    compile_environment();
    compile_computationMode();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_DATEVALUE", "(Ljava/lang/String;Lorg/formulacompiler/runtime/internal/Environment;Lorg/formulacompiler/runtime/ComputationMode;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  private final void compile_fun_TIMEVALUE( ExpressionNode _a ) throws CompilerException
  {
    final GeneratorAdapter mv = mv();
    final int loc = localsOffset();
    final ExpressionCompilerForStrings str = method().stringCompiler();
    str.compile( _a );
    compile_environment();
    compile_computationMode();
    mv.visitMethodInsn( Opcodes.INVOKESTATIC, "org/formulacompiler/runtime/internal/RuntimeBigDecimal_v2", "fun_TIMEVALUE", "(Ljava/lang/String;Lorg/formulacompiler/runtime/internal/Environment;Lorg/formulacompiler/runtime/ComputationMode;)Ljava/math/BigDecimal;" );
    compileValueAdjustment();
  }


  @Override
  protected void compileOperatorWithFirstArgOnStack( Operator _operator, ExpressionNode _secondArg ) throws CompilerException
  {
    if (null == _secondArg) {
      switch (_operator) {
        case PERCENT:
          compile_op_PERCENT();
          return;
        case MINUS:
          compile_op_MINUS();
          return;
      }
    }
    else {
      switch (_operator) {
        case PLUS:
          compile_op_PLUS( _secondArg );
          return;
        case MINUS:
          compile_op_MINUS( _secondArg );
          return;
        case TIMES:
          compile_op_TIMES( _secondArg );
          return;
        case DIV:
          if (needsValueAdjustment()) {
            compile_op_DIV__if_needsValueAdjustment( _secondArg );
            return;
          }
          compile_op_DIV( _secondArg );
          return;
        case EXP:
          compile_op_EXP( _secondArg );
          return;
        case INTERNAL_MIN:
          compile_op_INTERNAL_MIN( _secondArg );
          return;
        case INTERNAL_MAX:
          compile_op_INTERNAL_MAX( _secondArg );
          return;
      }
    }
    super.compileOperatorWithFirstArgOnStack( _operator, _secondArg );
  }


  @Override
  protected void compileFunction( ExpressionNodeForFunction _node ) throws CompilerException
  {
    final int c = _node.cardinality();
    switch (_node.getFunction()) {
      case DEGREES:
        if (1 == c ) {
          compile_fun_DEGREES( _node.argument( 0 ) );
          return;
        }
         break;
      case RADIANS:
        if (1 == c ) {
          compile_fun_RADIANS( _node.argument( 0 ) );
          return;
        }
         break;
      case CEILING:
        if (2 == c && ComputationMode.EXCEL == getComputationMode() ) {
          compile_fun_CEILING__for_EXCEL( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
        if (2 == c && ComputationMode.OPEN_OFFICE_CALC == getComputationMode() ) {
          compile_fun_CEILING__for_OPEN_OFFICE_CALC( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
         break;
      case FLOOR:
        if (2 == c && ComputationMode.EXCEL == getComputationMode() ) {
          compile_fun_FLOOR__for_EXCEL( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
        if (2 == c && ComputationMode.OPEN_OFFICE_CALC == getComputationMode() ) {
          compile_fun_FLOOR__for_OPEN_OFFICE_CALC( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
         break;
      case POWER:
        if (2 == c ) {
          compile_fun_POWER( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
         break;
      case SQRT:
        if (1 == c ) {
          compile_fun_SQRT( _node.argument( 0 ) );
          return;
        }
         break;
      case FACT:
        if (1 == c ) {
          compile_fun_FACT( _node.argument( 0 ) );
          return;
        }
         break;
      case IRR:
        if (2 == c ) {
          compile_fun_IRR( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
         break;
      case DB:
        if (5 == c ) {
          compile_fun_DB( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ), _node.argument( 3 ), _node.argument( 4 ) );
          return;
        }
        if (4 == c ) {
          compile_fun_DB( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ), _node.argument( 3 ) );
          return;
        }
         break;
      case DDB:
        if (5 == c ) {
          compile_fun_DDB( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ), _node.argument( 3 ), _node.argument( 4 ) );
          return;
        }
        if (4 == c ) {
          compile_fun_DDB( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ), _node.argument( 3 ) );
          return;
        }
         break;
      case VDB:
        if (7 == c ) {
          compile_fun_VDB( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ), _node.argument( 3 ), _node.argument( 4 ), _node.argument( 5 ), _node.argument( 6 ) );
          return;
        }
         break;
      case RATE:
        if (6 == c ) {
          compile_fun_RATE( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ), _node.argument( 3 ), _node.argument( 4 ), _node.argument( 5 ) );
          return;
        }
        if (5 == c ) {
          compile_fun_RATE( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ), _node.argument( 3 ), _node.argument( 4 ) );
          return;
        }
        if (4 == c ) {
          compile_fun_RATE( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ), _node.argument( 3 ) );
          return;
        }
        if (3 == c ) {
          compile_fun_RATE( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ) );
          return;
        }
         break;
      case TIME:
        if (3 == c && ComputationMode.EXCEL == getComputationMode() ) {
          compile_fun_TIME__for_EXCEL( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ) );
          return;
        }
        if (3 == c && ComputationMode.OPEN_OFFICE_CALC == getComputationMode() ) {
          compile_fun_TIME__for_OPEN_OFFICE_CALC( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ) );
          return;
        }
         break;
      case ABS:
        if (1 == c ) {
          compile_fun_ABS( _node.argument( 0 ) );
          return;
        }
         break;
      case ACOS:
        if (1 == c ) {
          compile_fun_ACOS( _node.argument( 0 ) );
          return;
        }
         break;
      case ACOSH:
        if (1 == c ) {
          compile_fun_ACOSH( _node.argument( 0 ) );
          return;
        }
         break;
      case ASIN:
        if (1 == c ) {
          compile_fun_ASIN( _node.argument( 0 ) );
          return;
        }
         break;
      case ASINH:
        if (1 == c ) {
          compile_fun_ASINH( _node.argument( 0 ) );
          return;
        }
         break;
      case ATAN:
        if (1 == c ) {
          compile_fun_ATAN( _node.argument( 0 ) );
          return;
        }
         break;
      case ATANH:
        if (1 == c ) {
          compile_fun_ATANH( _node.argument( 0 ) );
          return;
        }
         break;
      case ATAN2:
        if (2 == c ) {
          compile_fun_ATAN2( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
         break;
      case COS:
        if (1 == c ) {
          compile_fun_COS( _node.argument( 0 ) );
          return;
        }
         break;
      case COSH:
        if (1 == c ) {
          compile_fun_COSH( _node.argument( 0 ) );
          return;
        }
         break;
      case SIN:
        if (1 == c ) {
          compile_fun_SIN( _node.argument( 0 ) );
          return;
        }
         break;
      case SINH:
        if (1 == c ) {
          compile_fun_SINH( _node.argument( 0 ) );
          return;
        }
         break;
      case SIGN:
        if (1 == c ) {
          compile_fun_SIGN( _node.argument( 0 ) );
          return;
        }
         break;
      case TAN:
        if (1 == c ) {
          compile_fun_TAN( _node.argument( 0 ) );
          return;
        }
         break;
      case TANH:
        if (1 == c ) {
          compile_fun_TANH( _node.argument( 0 ) );
          return;
        }
         break;
      case PI:
        if (0 == c ) {
          compile_fun_PI();
          return;
        }
         break;
      case RAND:
        if (0 == c ) {
          compile_fun_RAND();
          return;
        }
         break;
      case ROUND:
        if (2 == c ) {
          compile_fun_ROUND( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
         break;
      case ROUNDDOWN:
        if (2 == c ) {
          compile_fun_ROUNDDOWN( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
         break;
      case ROUNDUP:
        if (2 == c ) {
          compile_fun_ROUNDUP( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
         break;
      case TRUNC:
        if (2 == c ) {
          compile_fun_TRUNC( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
        if (1 == c ) {
          compile_fun_TRUNC( _node.argument( 0 ) );
          return;
        }
         break;
      case EVEN:
        if (1 == c ) {
          compile_fun_EVEN( _node.argument( 0 ) );
          return;
        }
         break;
      case ODD:
        if (1 == c ) {
          compile_fun_ODD( _node.argument( 0 ) );
          return;
        }
         break;
      case INT:
        if (1 == c ) {
          compile_fun_INT( _node.argument( 0 ) );
          return;
        }
         break;
      case EXP:
        if (1 == c ) {
          compile_fun_EXP( _node.argument( 0 ) );
          return;
        }
         break;
      case LN:
        if (1 == c ) {
          compile_fun_LN( _node.argument( 0 ) );
          return;
        }
         break;
      case LOG:
        if (1 == c ) {
          compile_fun_LOG( _node.argument( 0 ) );
          return;
        }
        if (2 == c ) {
          compile_fun_LOG( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
         break;
      case LOG10:
        if (1 == c ) {
          compile_fun_LOG10( _node.argument( 0 ) );
          return;
        }
         break;
      case ERF:
        if (1 == c ) {
          compile_fun_ERF( _node.argument( 0 ) );
          return;
        }
         break;
      case ERFC:
        if (1 == c ) {
          compile_fun_ERFC( _node.argument( 0 ) );
          return;
        }
         break;
      case BETADIST:
        if (3 == c ) {
          compile_fun_BETADIST( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ) );
          return;
        }
         break;
      case BETAINV:
        if (3 == c ) {
          compile_fun_BETAINV( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ) );
          return;
        }
         break;
      case BINOMDIST:
        if (4 == c ) {
          compile_fun_BINOMDIST( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ), _node.argument( 3 ) );
          return;
        }
         break;
      case CHIDIST:
        if (2 == c ) {
          compile_fun_CHIDIST( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
         break;
      case CHIINV:
        if (2 == c ) {
          compile_fun_CHIINV( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
         break;
      case CRITBINOM:
        if (3 == c ) {
          compile_fun_CRITBINOM( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ) );
          return;
        }
         break;
      case FINV:
        if (3 == c ) {
          compile_fun_FINV( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ) );
          return;
        }
         break;
      case GAMMADIST:
        if (4 == c ) {
          compile_fun_GAMMADIST( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ), _node.argument( 3 ) );
          return;
        }
         break;
      case GAMMAINV:
        if (3 == c ) {
          compile_fun_GAMMAINV( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ) );
          return;
        }
         break;
      case GAMMALN:
        if (1 == c ) {
          compile_fun_GAMMALN( _node.argument( 0 ) );
          return;
        }
         break;
      case POISSON:
        if (3 == c ) {
          compile_fun_POISSON( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ) );
          return;
        }
         break;
      case TDIST:
        if (3 == c ) {
          compile_fun_TDIST( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ) );
          return;
        }
        if (4 == c ) {
          compile_fun_TDIST( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ), _node.argument( 3 ) );
          return;
        }
         break;
      case TINV:
        if (2 == c ) {
          compile_fun_TINV( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
         break;
      case MOD:
        if (2 == c ) {
          compile_fun_MOD( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
         break;
      case WEIBULL:
        if (4 == c ) {
          compile_fun_WEIBULL( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ), _node.argument( 3 ) );
          return;
        }
         break;
      case MDETERM:
        if (2 == c ) {
          compile_fun_MDETERM( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
         break;
      case DATE:
        if (3 == c ) {
          compile_fun_DATE( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ) );
          return;
        }
         break;
      case SECOND:
        if (1 == c ) {
          compile_fun_SECOND( _node.argument( 0 ) );
          return;
        }
         break;
      case MINUTE:
        if (1 == c ) {
          compile_fun_MINUTE( _node.argument( 0 ) );
          return;
        }
         break;
      case HOUR:
        if (1 == c ) {
          compile_fun_HOUR( _node.argument( 0 ) );
          return;
        }
         break;
      case HYPGEOMDIST:
        if (4 == c ) {
          compile_fun_HYPGEOMDIST( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ), _node.argument( 3 ) );
          return;
        }
         break;
      case WEEKDAY:
        if (2 == c ) {
          compile_fun_WEEKDAY( _node.argument( 0 ), _node.argument( 1 ) );
          return;
        }
        if (1 == c ) {
          compile_fun_WEEKDAY( _node.argument( 0 ) );
          return;
        }
         break;
      case DAY:
        if (1 == c ) {
          compile_fun_DAY( _node.argument( 0 ) );
          return;
        }
         break;
      case DAYS360:
        if (3 == c ) {
          compile_fun_DAYS360( _node.argument( 0 ), _node.argument( 1 ), _node.argument( 2 ) );
          return;
        }
         break;
      case MONTH:
        if (1 == c ) {
          compile_fun_MONTH( _node.argument( 0 ) );
          return;
        }
         break;
      case YEAR:
        if (1 == c ) {
          compile_fun_YEAR( _node.argument( 0 ) );
          return;
        }
         break;
      case NOW:
        if (0 == c ) {
          compile_fun_NOW();
          return;
        }
         break;
      case TODAY:
        if (0 == c ) {
          compile_fun_TODAY();
          return;
        }
         break;
      case VALUE:
        if (1 == c ) {
          compile_fun_VALUE( _node.argument( 0 ) );
          return;
        }
         break;
      case DATEVALUE:
        if (1 == c ) {
          compile_fun_DATEVALUE( _node.argument( 0 ) );
          return;
        }
         break;
      case TIMEVALUE:
        if (1 == c ) {
          compile_fun_TIMEVALUE( _node.argument( 0 ) );
          return;
        }
         break;
    }
    super.compileFunction( _node );
  }


}
Source Code of org.formulacompiler.compiler.internal.bytecode.ExpressionCompilerForScaledBigDecimals_Generated

Related Classes of org.formulacompiler.compiler.internal.bytecode.ExpressionCompilerForScaledBigDecimals_Generated
