/**
 * This class is automatically generated by mig. DO NOT EDIT THIS FILE.
 * This class implements a Java interface to the 'QueryMsg'
 * message type.
 */
/*
whj redesign:

qid: 4 bits.


*/
package net.tinyos.tinydb;

public class QueryMsgCompact extends net.tinyos.message.Message {

    /** The default size of this message type in bytes. */
    public static final int DEFAULT_MESSAGE_SIZE = 49;

    /** The Active Message type associated with this message. */
    public static final int AM_TYPE = 101;
    ///////////////////////////////////////////////////////////////
    private static int qid_offset_bits = 0;
    private static int qid_size_bits = 8;

	private static int fwdNode_offset_bits = qid_offset_bits + qid_size_bits;
	private static int fwdNode_size_bits = 16;
    
    private static int msgType_offset_bits = fwdNode_offset_bits + fwdNode_size_bits;
    private static int msgType_size_bits = 8;
    
    //2 bytes now
    // 4 bytes now
    private static int numFields_offset_bits = msgType_offset_bits + msgType_size_bits;
    private static int numFields_size_bits = 4;
    
    private static int numExps_offset_bits = numFields_offset_bits + numFields_size_bits;
    private static int numExps_size_bits = 4;
    //4 bytes now
    private static int fromBuffer_offset_bits = numExps_offset_bits + numExps_size_bits;
    private static int fromBuffer_size_bits = 8;
    
    private static int fromCatalog_offset_bits = fromBuffer_offset_bits + fromBuffer_size_bits;
    private static int fromCatalog_size_bits = 1;
    
    private static int hasEvent_offset_bits = fromCatalog_offset_bits + fromCatalog_size_bits;
    private static int hasEvent_size_bits = 1;
    
    private static int hasForClause_offset_bits = hasEvent_offset_bits + hasEvent_size_bits;
    private static int hasForClause_size_bits = 1;
    
    private static int bufferType_offset_bits = hasForClause_offset_bits + hasForClause_size_bits;
    private static int bufferType_size_bits = 5;
    //5 bytes now
    private static int epochDuration_offset_bits = bufferType_offset_bits + bufferType_size_bits;
    private static int epochDuration_size_bits = 16;
    //7
    private static int type_offset_bits = epochDuration_offset_bits + epochDuration_size_bits;
    private static int type_size_bits = 4;
    //
    private static int idx_offset_bits = type_offset_bits + type_size_bits;
    private static int idx_size_bits = 4;
    //
//    private static int timeSyncData_offset_bits = idx_offset_bits + idx_size_bits;
//    private static int timeSyncData_size_bits = 8;
    
    private static int timeSyncData_offset_bits = idx_offset_bits + idx_size_bits;
    private static int timeSyncData_size_bits = 8;
	public static int numTimeSyncData=5;
    private static int totalTimeSyncData_size_bits = timeSyncData_size_bits*numTimeSyncData; //total 5 timesyncdata
    
    private static int clockCount_offset_bits = timeSyncData_offset_bits + totalTimeSyncData_size_bits;
    private static int clockCount_size_bits = 16;
    
	private static int totalSize_u_field_name_str = 8;
    
    private static int fieldNo_offset_bits = clockCount_offset_bits + clockCount_size_bits;
    private static int fieldNo_size_bits = 32;

    private static int fieldName_offset_bits = fieldNo_offset_bits + fieldNo_size_bits;
    private static int fieldName_size_bits = 0;
    
    private static int fieldOp_offset_bits = fieldName_offset_bits + fieldName_size_bits;
    private static int fieldOp_size_bits = 0;

    private static int fieldType_offset_bits = fieldOp_offset_bits + fieldOp_size_bits;
    private static int fieldType_size_bits = 0;
    
    // expressions:
    
    private static int exprOpType_offset_bits = fieldType_offset_bits + fieldType_size_bits;
    private static int exprOpType_size_bits =2;
    public static final int maxExprs = 3;
    private static int totalExprOpType_size_bits = 8;

	private static int expStart_offset_bits = exprOpType_offset_bits + totalExprOpType_size_bits;
	private static int expr_size_bits = 7*8;

	//////////////////////////////////////////////////////////////////////////////////////    
    //pure expr:+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	private static int isStringExp_offset_bits = 0; //relative 0
    private static int isStringExp_size_bits = 1;
    //
    private static int exprSuccess_offset_bits = isStringExp_offset_bits + isStringExp_size_bits;
    private static int exprSuccess_size_bits = 1;
    //21 
    //EXPRESSION share values and markers:
    //22	
	//expropval
    private static int exOpValField_offset_bits = exprSuccess_offset_bits + exprSuccess_size_bits;
    private static int exOpValField_size_bits = 6;//16;
    // private static int totalExOpValField_size_bits = exOpValField_size_bits*maxExprs;//64;

 	private static int exOpValOp_offset_bits = exOpValField_offset_bits+exOpValField_size_bits;
    private static int exOpValOp_size_bits = 8;
    //private static int totalExOpValOp_size_bits =exOpValOp_size_bits * maxExprs;
    private static int exOpValVal_offset_bits = exOpValOp_offset_bits + exOpValOp_size_bits;
	private static int exOpValVal_size_bits = 16;
//	private static int totalExOpValVal_size_bits =exOpValVal_size_bits * maxExprs;
	//20 bytes now
	private static int exprUExprFieldOp_offset_bits = exOpValField_offset_bits + exOpValField_size_bits;
	private static int exprUExprFieldOp_size_bits = 0;
		
	private static int exprUExprFieldConst_offset_bits = exprUExprFieldOp_offset_bits + exprUExprFieldOp_size_bits;
	private static int exprUExprFieldConst_size_bits = 0;
	private static int totalExprUExprFieldConst_size_bits = exprUExprFieldConst_size_bits;//temp
	
	private static int exprIdx_offset_bits = exprUExprFieldConst_offset_bits + totalExprUExprFieldConst_size_bits;
    private static int exprIdx_size_bits = 0;//16;
    private static int totalExprIdx_size_bits = exprIdx_size_bits*maxExprs;//temp
	
	//: start expression
	    
    //str exps---------------------------------------
	private static int exprExSexpField_offset_bits = exprSuccess_offset_bits + exprSuccess_size_bits;
	private static int exprExSexpField_size_bits  = 6;
	
	private static int exprExSexpOp_offset_bits = exprExSexpField_offset_bits+exprExSexpField_size_bits;
    private static int exprExSexpOp_size_bits = 8;
    
    private static int exprExSexpStr_offset_bits = exprExSexpOp_offset_bits + exprExSexpOp_size_bits;
	private static int exprExSexpStr_size_bits = 24;
	
	//-------------
	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	
	
	//agg exprs: ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
    private static int aggField_offset_bits = exprSuccess_offset_bits + exprSuccess_size_bits;
    private static int aggField_size_bits = 6;
    //private static int maxAggs = 4;
    //private static int totalaggField_size_bits = aggField_size_bits*maxExprs;//64;
    //
    //35
    private static int aggOp_offset_bits = aggField_offset_bits + aggField_size_bits;
    private static int aggOp_size_bits = 8;
	private static int exprExAgg_size_bits = aggOp_size_bits;
    //private static int totalAggOp_size_bits = aggOp_size_bits*maxAggs;
    //37
    private static int aggGroupingField_offset_bits = aggOp_offset_bits + aggOp_size_bits;
    private static int aggGroupingField_size_bits = 5;
    
    //38
    private static int aggGroupFieldOP_offset_bits = aggGroupingField_offset_bits + aggGroupingField_size_bits;
    private static int aggGroupFieldOP_size_bits = 3;
    //39
    private static int aggGroupFieldConst_offset_bits = aggGroupFieldOP_offset_bits + aggGroupFieldOP_size_bits;
    private static int aggGroupFieldConst_size_bits = 16;

	private static int exprExTaggArgs_offset_bits = aggGroupFieldConst_offset_bits + aggGroupFieldConst_size_bits;
	private static int exprExTaggArgs_size_bits = 0;
	
	private static int uttl_offset_bits = expStart_offset_bits +expr_size_bits*maxExprs;
	private static int uttl_size_bits =8;
	
	private static int relOps_offset_bits = uttl_offset_bits + uttl_size_bits;
	private static int relOps_size_bits = 2;

    //41
    //////-------------------------------------------------------------------------
//    private static int totalExprExTaggArgs_size_bits = exprExTaggArgs_size_bits*maxAggs;
	//-------------------------------------------------------
    
	//+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
	
	//total : 
	
	//Decode:
    public static final int maxFieldLen=16;
	public static final int maxExOpFieldNum=64;
	
	public String []g_FieldName = {"nodeid","light","temp","parent","posi_x","posi_y","accel_x","accel_y","mag_x",
					"mag_y","noise","tones","voltage","rawtone","rawmic","qual","depth","freeram",
					"name","content","attrlog","","","","","","","","","","","","","","","",""};
	public String []g_AggName ={"NOOP","SUM","MIN","MAX","CNT","AVG","EXPAVG","WINAVG","WINSUM","WINMIN","WINMAX",
				   "WINCNT","DELTA","TREND","WINRAND","ADPDELTA","WAVELET","","","","",};
    public byte g_FieldType[]= new byte[fieldNo_size_bits];
	public short g_ExOpField[]= new short[maxExOpFieldNum];
	public short g_AggField[]= new short[maxExOpFieldNum];


    
    
    
    ////////////////////////////////////////////////////////////////
    

    /** Create a new QueryMsg of size 40. */
    public QueryMsgCompact() {
        super(DEFAULT_MESSAGE_SIZE);
        amTypeSet(AM_TYPE);
    }

    /** Create a new QueryMsg of the given data_length. */
    public QueryMsgCompact(int data_length) {
        super(data_length);
        amTypeSet(AM_TYPE);
    }

    /**
     * Create a new QueryMsg with the given data_length
     * and base offset.
     */
    public QueryMsgCompact(int data_length, int base_offset) {
        super(data_length, base_offset);
        amTypeSet(AM_TYPE);
    }

    /**
     * Create a new QueryMsg using the given byte array
     * as backing store.
     */
    public QueryMsgCompact(byte[] data) {
        super(data);
        amTypeSet(AM_TYPE);
    }

    /**
     * Create a new QueryMsg using the given byte array
     * as backing store, with the given base offset.
     */
    public QueryMsgCompact(byte[] data, int base_offset) {
        super(data, base_offset);
        amTypeSet(AM_TYPE);
    }

    /**
     * Create a new QueryMsg using the given byte array
     * as backing store, with the given base offset and data length.
     */
    public QueryMsgCompact(byte[] data, int base_offset, int data_length) {
        super(data, base_offset, data_length);
        amTypeSet(AM_TYPE);
    }

    /**
     * Create a new QueryMsg embedded in the given message
     * at the given base offset.
     */
    public QueryMsgCompact(net.tinyos.message.Message msg, int base_offset) {
        super(msg, base_offset, DEFAULT_MESSAGE_SIZE);
        amTypeSet(AM_TYPE);
    }

    /**
     * Create a new QueryMsg embedded in the given message
     * at the given base offset and length.
     */
    public QueryMsgCompact(net.tinyos.message.Message msg, int base_offset, int data_length) {
        super(msg, base_offset, data_length);
        amTypeSet(AM_TYPE);
    }

    /**
    /* Return a String representation of this message. Includes the
     * message type name and the non-indexed field values.
     */
    public String toString() {
      String s = "Message <QueryMsg> \n";
      try {
        s += "  [qid=0x"+Long.toHexString(get_qid())+"addr:"+Long.toHexString(offsetBits_qid())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [fwdNode=0x"+Long.toHexString(get_fwdNode())+"addr:"+Long.toHexString(offsetBits_fwdNode())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [msgType=0x"+Long.toHexString(get_msgType())+"addr:"+Long.toHexString(offsetBits_msgType())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [numFields=0x"+Long.toHexString(get_numFields())+"addr:"+Long.toHexString(offsetBits_numFields())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [numExprs=0x"+Long.toHexString(get_numExprs())+"addr:"+Long.toHexString(offsetBits_numExprs())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [fromBuffer=0x"+Long.toHexString(get_fromBuffer())+"addr:"+Long.toHexString(offsetBits_fromBuffer())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [fromCatalogBuffer=0x"+Long.toHexString(get_fromCatalogBuffer())+"addr:"+Long.toHexString(offsetBits_fromCatalogBuffer())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [hasEvent=0x"+Long.toHexString(get_hasEvent())+"addr:"+Long.toHexString(offsetBits_hasEvent())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [hasForClause=0x"+Long.toHexString(get_hasForClause())+"addr:"+Long.toHexString(offsetBits_hasForClause())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [bufferType=0x"+Long.toHexString(get_bufferType())+"addr:"+Long.toHexString(offsetBits_bufferType())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [epochDuration=0x"+Long.toHexString(get_epochDuration())+"addr:"+Long.toHexString(offsetBits_epochDuration())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [type=0x"+Long.toHexString(get_type())+"addr:"+Long.toHexString(offsetBits_type())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [idx=0x"+Long.toHexString(get_idx())+"addr:"+Long.toHexString(offsetBits_idx())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [timeSyncData=";
        for (int i = 0; i < 5; i++) {
          s += "0x"+Long.toHexString(getElement_timeSyncData(i) & 0xff)+" ";
        }
        s += "]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [clockCount=0x"+Long.toHexString(get_clockCount())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.field.name=";
	  for(int k=0;k<fieldNo_size_bits;k++){
		if(getElement_u_field(k)==1)
		{	
			s += g_FieldName[k];
			s += ",  ";
		}
	  }
        /*for (int i = 0; i < 8; i++) {
          s += "0x"+Long.toHexString(getElement_u_field_name(k,i) & 0xff)+" ";
        }*/
        s += "]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.field.op=0x"+Long.toHexString(get_u_field_op())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      // whj temporariely remove try {
//        s += "  [u.field.type=0x"+Long.toHexString(get_u_field_type())+"]\n";
  //    } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
       for(int k=0;k<maxExprs;k++)
        s += "  [u.expr.opType=0x"+Long.toHexString(get_u_expr_opType(k))+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
      for(int k=0;k<maxExprs;k++)
        s += "  [u.expr.isStringExp=0x"+Long.toHexString(get_u_expr_isStringExp(k))+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
      for(int k=0;k<maxExprs;k++)
        s += "  [u.expr.success=0x"+Long.toHexString(get_u_expr_success(k))+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
      for(int k=0;k<maxExprs;k++)
        s += "  [u.expr.idx=0x"+Long.toHexString(get_u_expr_idx(k))+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
      for(int k=0;k<maxExprs;k++)
        s += "  [u.expr.ex.opval.field=0x"+Long.toHexString(get_u_expr_ex_opval_field(k))+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
      for(int k=0;k<maxExprs;k++)
        s += "  [u.expr.ex.opval.op=0x"+Long.toHexString(get_u_expr_ex_opval_op(k))+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
      for(int k=0;k<maxExprs;k++)
        s += "  [u.expr.ex.opval.value=0x"+Long.toHexString(get_u_expr_ex_opval_value(k))+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
      for(int k=0;k<maxExprs;k++)
        s += "  [u.expr.ex.agg.field=0x"+Long.toHexString(get_u_expr_ex_agg_field(k))+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
	  for(int k=0;k<maxExprs;k++)
        s += "  [u.expr.ex.agg.groupingField=0x"+Long.toHexString(get_u_expr_ex_agg_groupingField(k))+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
	  for(int k=0;k<maxExprs;k++)
        s += "  [u.expr.ex.agg.groupFieldOp=0x"+Long.toHexString(get_u_expr_ex_agg_groupFieldOp(k))+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
	  for(int k=0;k<maxExprs;k++)
        s += "  [u.expr.ex.agg.groupFieldConst=0x"+Long.toHexString(get_u_expr_ex_agg_groupFieldConst(k))+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
      for(int k=0;k<maxExprs;k++)
        s += "  [u.expr.ex.agg.op=0x"+Long.toHexString(get_u_expr_ex_agg_op(k))+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      
//	try {
//        s += "  [u.expr.ex.tagg.agg.field=0x"+Long.toHexString(get_u_expr_ex_tagg_agg_field())+"]\n";
//	    } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
//	  try {
//	  s += "  [u.expr.ex.tagg.agg.groupingField=0x"+Long.toHexString(get_u_expr_ex_tagg_agg_groupingField())+"]\n";
//      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
//      try {
//        s += "  [u.expr.ex.tagg.agg.groupFieldOp=0x"+Long.toHexString(get_u_expr_ex_tagg_agg_groupFieldOp())+"]\n";
//      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
//      try {
//        s += "  [u.expr.ex.tagg.agg.groupFieldConst=0x"+Long.toHexString(get_u_expr_ex_tagg_agg_groupFieldConst())+"]\n";
//      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
//      try {
//        s += "  [u.expr.ex.tagg.agg.op=0x"+Long.toHexString(get_u_expr_ex_tagg_agg_op())+"]\n";
//      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
//      try {
//        s += "  [u.expr.ex.tagg.args=";
//        for (int i = 0; i < 4; i++) {
//          s += "0x"+Long.toHexString(getElement_u_expr_ex_tagg_args(i) & 0xff)+" ";
//        }
//        s += "]\n";
//      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
//      try {
//        s += "  [u.expr.ex.sexp.op=0x"+Long.toHexString(get_u_expr_ex_sexp_op())+"]\n";
//      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
//      try {
//        s += "  [u.expr.ex.sexp.field=0x"+Long.toHexString(get_u_expr_ex_sexp_field())+"]\n";
//      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
//      try {
//        s += "  [u.expr.ex.sexp.s=";
//        for (int i = 0; i < 8; i++) {
//          s += "0x"+Long.toHexString(getElement_u_expr_ex_sexp_s(i) & 0xff)+" ";
//        }
//        s += "]\n";
//      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
	  for(int k=0;k<maxExprs;k++)
        s += "  [u.expr.fieldOp=0x"+Long.toHexString(get_u_expr_fieldOp(k))+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
	  for(int k=0;k<maxExprs;k++)
        s += "  [u.expr.fieldConst=0x"+Long.toHexString(get_u_expr_fieldConst(k))+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.expr.opState=0x"+Long.toHexString(get_u_expr_opState())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
//      try {
//        s += "  [u.buf.cmd.name=";
//        for (int i = 0; i < 8; i++) {
//          s += "0x"+Long.toHexString(getElement_u_buf_cmd_name(i) & 0xff)+" ";
//        }
//        s += "]\n";
//      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.buf.cmd.hasParam=0x"+Long.toHexString(get_u_buf_cmd_hasParam())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.buf.cmd.param=0x"+Long.toHexString(get_u_buf_cmd_param())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.buf.ram.hasOutput=0x"+Long.toHexString(get_u_buf_ram_hasOutput())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.buf.ram.hasInput=0x"+Long.toHexString(get_u_buf_ram_hasInput())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.buf.ram.create=0x"+Long.toHexString(get_u_buf_ram_create())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.buf.ram.numRows=0x"+Long.toHexString(get_u_buf_ram_numRows())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.buf.ram.outBufName=";
        for (int i = 0; i < 8; i++) {
          s += "0x"+Long.toHexString(getElement_u_buf_ram_outBufName(i) & 0xff)+" ";
        }
        s += "]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.buf.ram.inBufName=";
        for (int i = 0; i < 8; i++) {
          s += "0x"+Long.toHexString(getElement_u_buf_ram_inBufName(i) & 0xff)+" ";
        }
        s += "]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.buf.ram.policy=0x"+Long.toHexString(get_u_buf_ram_policy())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.eventName=";
        for (int i = 0; i < 8; i++) {
          s += "0x"+Long.toHexString(getElement_u_eventName(i) & 0xff)+" ";
        }
        s += "]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.numEpochs=0x"+Long.toHexString(get_u_numEpochs())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.ttl=0x"+Long.toHexString(get_u_ttl())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      return s;
    }

    // Message-type-specific access methods appear below.

    /////////////////////////////////////////////////////////
    // Accessor methods for field: qid
    //   Field type: short
    //   Offset (bits): 0
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'qid' is signed (false).
     */
    public static boolean isSigned_qid() {
        return false;
    }

    /**
     * Return whether the field 'qid' is an array (false).
     */
    public static boolean isArray_qid() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'qid'
     */
    public static int offset_qid() {
        return (qid_offset_bits / 8);
    }

    /**
     * Return the offset (in bits) of the field 'qid'
     */
    public static int offsetBits_qid() {
        return qid_offset_bits;
    }

    /**
     * Return the value (as a short) of the field 'qid'
     */
    public short get_qid() {
        return (short)getUIntElement(offsetBits_qid(), qid_size_bits);
    }

    /**
     * Set the value of the field 'qid'
     */
    public void set_qid(short value) {
        setUIntElement(offsetBits_qid(),qid_size_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'qid'
     */
    public static int size_qid() {
        return (qid_size_bits / 8);
    }

    /**
     * Return the size, in bits, of the field 'qid'
     */
    public static int sizeBits_qid() {
        return qid_size_bits;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: fwdNode
    //   Field type: int
    //   Offset (bits): 8
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'fwdNode' is signed (false).
     */
    public static boolean isSigned_fwdNode() {
        return false;
    }

    /**
     * Return whether the field 'fwdNode' is an array (false).
     */
    public static boolean isArray_fwdNode() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'fwdNode'
     */
    public static int offset_fwdNode() {
        return (fwdNode_offset_bits / 8);
    }

    /**
     * Return the offset (in bits) of the field 'fwdNode'
     */
    public static int offsetBits_fwdNode() {
        return fwdNode_offset_bits;
    }

    /**
     * Return the value (as a int) of the field 'fwdNode'
     */
    public int get_fwdNode() {
        return (int)getUIntElement(offsetBits_fwdNode(), fwdNode_size_bits);
    }

    /**
     * Set the value of the field 'fwdNode'
     */
    public void set_fwdNode(int value) {
        setUIntElement(offsetBits_fwdNode(), fwdNode_offset_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'fwdNode'
     */
    public static int size_fwdNode() {
        return (fwdNode_size_bits / 8);
    }

    /**
     * Return the size, in bits, of the field 'fwdNode'
     */
    public static int sizeBits_fwdNode() {
        return fwdNode_size_bits;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: msgType
    //   Field type: byte
    //   Offset (bits): 24
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'msgType' is signed (false).
     */
    public static boolean isSigned_msgType() {
        return false;
    }

    /**
     * Return whether the field 'msgType' is an array (false).
     */
    public static boolean isArray_msgType() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'msgType'
     */
    public static int offset_msgType() {
        return (msgType_offset_bits / 8);
    }

    /**
     * Return the offset (in bits) of the field 'msgType'
     */
    public static int offsetBits_msgType() {
        return msgType_offset_bits;
    }

    /**
     * Return the value (as a byte) of the field 'msgType'
     */
    public byte get_msgType() {
        return (byte)getSIntElement(offsetBits_msgType(), msgType_size_bits);
    }

    /**
     * Set the value of the field 'msgType'
     */
    public void set_msgType(byte value) {
        setSIntElement(offsetBits_msgType(), msgType_size_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'msgType'
     */
    public static int size_msgType() {
        return (msgType_size_bits / 8);
    }

    /**
     * Return the size, in bits, of the field 'msgType'
     */
    public static int sizeBits_msgType() {
        return msgType_size_bits;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: numFields
    //   Field type: byte
    //   Offset (bits): 32
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'numFields' is signed (false).
     */
    public static boolean isSigned_numFields() {
        return false;
    }

    /**
     * Return whether the field 'numFields' is an array (false).
     */
    public static boolean isArray_numFields() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'numFields'
     */
    public static int offset_numFields() {
        return (numFields_offset_bits / 8);
    }

    /**
     * Return the offset (in bits) of the field 'numFields'
     */
    public static int offsetBits_numFields() {
        return numFields_offset_bits;
    }

    /**
     * Return the value (as a byte) of the field 'numFields'
     */
    public byte get_numFields() {
        return (byte)getSIntElement(offsetBits_numFields(), numFields_size_bits);    }

    /**
     * Set the value of the field 'numFields'
     */
    public void set_numFields(byte value) {
        setSIntElement(offsetBits_numFields(), numFields_size_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'numFields'
     */
    public static int size_numFields() {
        return (numFields_size_bits / 8);
    }

    /**
     * Return the size, in bits, of the field 'numFields'
     */
    public static int sizeBits_numFields() {
        return numFields_size_bits;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: numExprs
    //   Field type: byte
    //   Offset (bits): 40
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'numExprs' is signed (false).
     */
    public static boolean isSigned_numExprs() {
        return false;
    }

    /**
     * Return whether the field 'numExprs' is an array (false).
     */
    public static boolean isArray_numExprs() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'numExprs'
     */
    public static int offset_numExprs() {
        return (numExps_offset_bits / 8);
    }

    /**
     * Return the offset (in bits) of the field 'numExprs'
     */
    public static int offsetBits_numExprs() {
        return numExps_offset_bits;
    }

    /**
     * Return the value (as a byte) of the field 'numExprs'
     */
    public byte get_numExprs() {
        return (byte)getSIntElement(offsetBits_numExprs(), numExps_size_bits);
    }

    /**
     * Set the value of the field 'numExprs'
     */
    public void set_numExprs(byte value) {
        setSIntElement(offsetBits_numExprs(), numExps_size_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'numExprs'
     */
    public static int size_numExprs() {
        return (numExps_size_bits / 8);
    }

    /**
     * Return the size, in bits, of the field 'numExprs'
     */
    public static int sizeBits_numExprs() {
        return numExps_size_bits;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: fromBuffer
    //   Field type: byte
    //   Offset (bits): 48
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'fromBuffer' is signed (false).
     */
    public static boolean isSigned_fromBuffer() {
        return false;
    }

    /**
     * Return whether the field 'fromBuffer' is an array (false).
     */
    public static boolean isArray_fromBuffer() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'fromBuffer'
     */
    public static int offset_fromBuffer() {
        return (fromBuffer_offset_bits / 8);
    }

    /**
     * Return the offset (in bits) of the field 'fromBuffer'
     */
    public static int offsetBits_fromBuffer() {
        return fromBuffer_offset_bits;
    }

    /**
     * Return the value (as a byte) of the field 'fromBuffer'
     */
    public byte get_fromBuffer() {
        return (byte)getSIntElement(offsetBits_fromBuffer(), fromBuffer_size_bits);
    }

    /**
     * Set the value of the field 'fromBuffer'
     */
    public void set_fromBuffer(byte value) {
        setSIntElement(offsetBits_fromBuffer(), fromBuffer_size_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'fromBuffer'
     */
    public static int size_fromBuffer() {
        return (fromBuffer_size_bits / 8);
    }

    /**
     * Return the size, in bits, of the field 'fromBuffer'
     */
    public static int sizeBits_fromBuffer() {
        return fromBuffer_size_bits;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: fromCatalogBuffer
    //   Field type: byte
    //   Offset (bits): 56
    //   Size (bits): 1
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'fromCatalogBuffer' is signed (false).
     */
    public static boolean isSigned_fromCatalogBuffer() {
        return false;
    }

    /**
     * Return whether the field 'fromCatalogBuffer' is an array (false).
     */
    public static boolean isArray_fromCatalogBuffer() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'fromCatalogBuffer'
     */
    public static int offset_fromCatalogBuffer() {
        return (fromCatalog_offset_bits / 8);
    }

    /**
     * Return the offset (in bits) of the field 'fromCatalogBuffer'
     */
    public static int offsetBits_fromCatalogBuffer() {
        return fromCatalog_offset_bits;
    }

    /**
     * Return the value (as a byte) of the field 'fromCatalogBuffer'
     */
    public byte get_fromCatalogBuffer() {
        return (byte)getUIntElement(offsetBits_fromCatalogBuffer(), 1);
    }

    /**
     * Set the value of the field 'fromCatalogBuffer'
     */
    public void set_fromCatalogBuffer(byte value) {
        setUIntElement(offsetBits_fromCatalogBuffer(), 1, value);
    }

    /**
     * Return the size, in bytes, of the field 'fromCatalogBuffer'
     * WARNING: This field is not an even-sized number of bytes (1 bits).
     */
    public static int size_fromCatalogBuffer() {
        return (fromCatalog_size_bits / 8) + 1;
    }

    /**
     * Return the size, in bits, of the field 'fromCatalogBuffer'
     */
    public static int sizeBits_fromCatalogBuffer() {
        return fromCatalog_size_bits;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: hasEvent
    //   Field type: byte
    //   Offset (bits): 57
    //   Size (bits): 1
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'hasEvent' is signed (false).
     */
    public static boolean isSigned_hasEvent() {
        return false;
    }

    /**
     * Return whether the field 'hasEvent' is an array (false).
     */
    public static boolean isArray_hasEvent() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'hasEvent'
     * WARNING: This field is not byte-aligned (bit offset 57).
     */
    public static int offset_hasEvent() {
        return (hasEvent_offset_bits / 8);
    }

    /**
     * Return the offset (in bits) of the field 'hasEvent'
     */
    public static int offsetBits_hasEvent() {
        return hasEvent_offset_bits;
    }

    /**
     * Return the value (as a byte) of the field 'hasEvent'
     */
    public byte get_hasEvent() {
        return (byte)getUIntElement(offsetBits_hasEvent(), hasEvent_size_bits);
    }

    /**
     * Set the value of the field 'hasEvent'
     */
    public void set_hasEvent(byte value) {
        setUIntElement(offsetBits_hasEvent(), hasEvent_size_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'hasEvent'
     * WARNING: This field is not an even-sized number of bytes (1 bits).
     */
    public static int size_hasEvent() {
        return (hasEvent_size_bits / 8) + 1;
    }

    /**
     * Return the size, in bits, of the field 'hasEvent'
     */
    public static int sizeBits_hasEvent() {
        return hasEvent_size_bits;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: hasForClause
    //   Field type: byte
    //   Offset (bits): 58
    //   Size (bits): 1
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'hasForClause' is signed (false).
     */
    public static boolean isSigned_hasForClause() {
        return false;
    }

    /**
     * Return whether the field 'hasForClause' is an array (false).
     */
    public static boolean isArray_hasForClause() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'hasForClause'
     * WARNING: This field is not byte-aligned (bit offset 58).
     */
    public static int offset_hasForClause() {
        return (hasForClause_offset_bits / 8);
    }

    /**
     * Return the offset (in bits) of the field 'hasForClause'
     */
    public static int offsetBits_hasForClause() {
        return hasForClause_offset_bits;
    }

    /**
     * Return the value (as a byte) of the field 'hasForClause'
     */
    public byte get_hasForClause() {
        return (byte)getUIntElement(offsetBits_hasForClause(), hasForClause_size_bits);
    }

    /**
     * Set the value of the field 'hasForClause'
     */
    public void set_hasForClause(byte value) {
        setUIntElement(offsetBits_hasForClause(), hasForClause_size_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'hasForClause'
     * WARNING: This field is not an even-sized number of bytes (1 bits).
     */
    public static int size_hasForClause() {
        return (hasForClause_size_bits / 8) + 1;
    }

    /**
     * Return the size, in bits, of the field 'hasForClause'
     */
    public static int sizeBits_hasForClause() {
        return hasForClause_size_bits;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: bufferType
    //   Field type: byte
    //   Offset (bits): 59
    //   Size (bits): 5
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'bufferType' is signed (false).
     */
    public static boolean isSigned_bufferType() {
        return false;
    }

    /**
     * Return whether the field 'bufferType' is an array (false).
     */
    public static boolean isArray_bufferType() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'bufferType'
     * WARNING: This field is not byte-aligned (bit offset 59).
     */
    public static int offset_bufferType() {
        return (bufferType_offset_bits / 8);
    }

    /**
     * Return the offset (in bits) of the field 'bufferType'
     */
    public static int offsetBits_bufferType() {
        return bufferType_offset_bits;
    }

    /**
     * Return the value (as a byte) of the field 'bufferType'
     */
    public byte get_bufferType() {
        return (byte)getUIntElement(offsetBits_bufferType(), bufferType_size_bits);
    }

    /**
     * Set the value of the field 'bufferType'
     */
    public void set_bufferType(byte value) {
        setUIntElement(offsetBits_bufferType(), bufferType_size_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'bufferType'
     * WARNING: This field is not an even-sized number of bytes (5 bits).
     */
    public static int size_bufferType() {
        return (bufferType_size_bits / 8) + 1;
    }

    /**
     * Return the size, in bits, of the field 'bufferType'
     */
    public static int sizeBits_bufferType() {
        return bufferType_size_bits;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: epochDuration
    //   Field type: short
    //   Offset (bits): 64
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'epochDuration' is signed (false).
     */
    public static boolean isSigned_epochDuration() {
        return false;
    }

    /**
     * Return whether the field 'epochDuration' is an array (false).
     */
    public static boolean isArray_epochDuration() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'epochDuration'
     */
    public static int offset_epochDuration() {
        return (epochDuration_offset_bits / 8);
    }

    /**
     * Return the offset (in bits) of the field 'epochDuration'
     */
    public static int offsetBits_epochDuration() {
        return epochDuration_offset_bits;
    }

    /**
     * Return the value (as a short) of the field 'epochDuration'
     */
    public short get_epochDuration() {
        return (short)getSIntElement(offsetBits_epochDuration(), epochDuration_size_bits);
    }

    /**
     * Set the value of the field 'epochDuration'
     */
    public void set_epochDuration(short value) {
        setSIntElement(offsetBits_epochDuration(), epochDuration_size_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'epochDuration'
     */
    public static int size_epochDuration() {
        return (epochDuration_size_bits / 8);
    }

    /**
     * Return the size, in bits, of the field 'epochDuration'
     */
    public static int sizeBits_epochDuration() {
        return epochDuration_size_bits;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: type
    //   Field type: byte
    //   Offset (bits): 80
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'type' is signed (false).
     */
    public static boolean isSigned_type() {
        return false;
    }

    /**
     * Return whether the field 'type' is an array (false).
     */
    public static boolean isArray_type() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'type'
     */
    public static int offset_type() {
        return (type_offset_bits / 8);
    }

    /**
     * Return the offset (in bits) of the field 'type'
     */
    public static int offsetBits_type() {
        return type_offset_bits;
    }

    /**
     * Return the value (as a byte) of the field 'type'
     */
    public byte get_type() {
        return (byte)getSIntElement(offsetBits_type(), type_size_bits);
    }

    /**
     * Set the value of the field 'type'
     */
    public void set_type(byte value) {
        setSIntElement(offsetBits_type(), type_size_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'type'
     */
    public static int size_type() {
        return (type_size_bits / 8);
    }

    /**
     * Return the size, in bits, of the field 'type'
     */
    public static int sizeBits_type() {
        return type_size_bits;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: idx
    //   Field type: byte
    //   Offset (bits): 88
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'idx' is signed (false).
     */
    public static boolean isSigned_idx() {
        return false;
    }

    /**
     * Return whether the field 'idx' is an array (false).
     */
    public static boolean isArray_idx() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'idx'
     */
    public static int offset_idx() {
        return (idx_offset_bits / 8);
    }

    /**
     * Return the offset (in bits) of the field 'idx'
     */
    public static int offsetBits_idx() {
        return idx_offset_bits;
    }

    /**
     * Return the value (as a byte) of the field 'idx'
     */
    public byte get_idx() {
        return (byte)getSIntElement(offsetBits_idx(), idx_size_bits);
    }

    /**
     * Set the value of the field 'idx'
     */
    public void set_idx(byte value) {
        setSIntElement(offsetBits_idx(), idx_size_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'idx'
     */
    public static int size_idx() {
        return (idx_size_bits / 8);
    }

    /**
     * Return the size, in bits, of the field 'idx'
     */
    public static int sizeBits_idx() {
        return idx_size_bits;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: timeSyncData
    //   Field type: short[]
    //   Offset (bits): 96
    //   Size of each element (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'timeSyncData' is signed (false).
     */
    public static boolean isSigned_timeSyncData() {
        return false;
    }

    /**
     * Return whether the field 'timeSyncData' is an array (true).
     */
    public static boolean isArray_timeSyncData() {
        return true;
    }

    /**
     * Return the offset (in bytes) of the field 'timeSyncData'
     */
    public static int offset_timeSyncData(int index1) {
        int offset = 96;
        if (index1 < 0 || index1 >= 5) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * 8;
        return (offset / 8);
    }

    /**
     * Return the offset (in bits) of the field 'timeSyncData'
     */
    public static int offsetBits_timeSyncData(int index1) {
        int offset = timeSyncData_offset_bits;
        if (index1 < 0 || index1 >= 5) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * timeSyncData_size_bits;
        return offset;
    }

    /**
     * Return the entire array 'timeSyncData' as a short[]
     */
    public short[] get_timeSyncData() {
        short[] tmp = new short[numTimeSyncData];
        for (int index0 = 0; index0 < numElements_timeSyncData(0); index0++) {
            tmp[index0] = getElement_timeSyncData(index0);
        }
        return tmp;
    }

    /**
     * Set the contents of the array 'timeSyncData' from the given short[]
     */
    public void set_timeSyncData(short[] value) {
        for (int index0 = 0; index0 < value.length; index0++) {
            setElement_timeSyncData(index0, value[index0]);
        }
    }

    /**
     * Return an element (as a short) of the array 'timeSyncData'
     */
    public short getElement_timeSyncData(int index1) {
        return (short)getUIntElement(offsetBits_timeSyncData(index1), timeSyncData_size_bits);
    }

    /**
     * Set an element of the array 'timeSyncData'
     */
    public void setElement_timeSyncData(int index1, short value) {
        setUIntElement(offsetBits_timeSyncData(index1), timeSyncData_size_bits, value);
    }

    /**
     * Return the total size, in bytes, of the array 'timeSyncData'
     */
    public static int totalSize_timeSyncData() {
        return (totalTimeSyncData_size_bits / 8);
    }

    /**
     * Return the total size, in bits, of the array 'timeSyncData'
     */
    public static int totalSizeBits_timeSyncData() {
        return totalTimeSyncData_size_bits;
    }

    /**
     * Return the size, in bytes, of each element of the array 'timeSyncData'
     */
    public static int elementSize_timeSyncData() {
        return (timeSyncData_size_bits / 8);
    }

    /**
     * Return the size, in bits, of each element of the array 'timeSyncData'
     */
    public static int elementSizeBits_timeSyncData() {
        return timeSyncData_size_bits;
    }

    /**
     * Return the number of dimensions in the array 'timeSyncData'
     */
    public static int numDimensions_timeSyncData() {
        return 1;
    }

    /**
     * Return the number of elements in the array 'timeSyncData'
     */
    public static int numElements_timeSyncData() {
        return numTimeSyncData;
    }

    /**
     * Return the number of elements in the array 'timeSyncData'
     * for the given dimension.
     */
    public static int numElements_timeSyncData(int dimension) {
      int array_dims[] = { 5,  };
        if (dimension < 0 || dimension >= 1) throw new ArrayIndexOutOfBoundsException();
        if (array_dims[dimension] == 0) throw new IllegalArgumentException("Array dimension "+dimension+" has unknown size");
        return array_dims[dimension];
    }

    /**
     * Fill in the array 'timeSyncData' with a String
     */
    public void setString_timeSyncData(String s) { 
         int len = s.length();
         int i;
         for (i = 0; i < len; i++) {
             setElement_timeSyncData(i, (short)s.charAt(i));
         }
         setElement_timeSyncData(i, (short)0); //null terminate
    }

    /**
     * Read the array 'timeSyncData' as a String
     */
    public String getString_timeSyncData() { 
         char carr[] = new char[Math.min(net.tinyos.message.Message.MAX_CONVERTED_STRING_LENGTH,5)];
         int i;
         for (i = 0; i < carr.length; i++) {
             if ((char)getElement_timeSyncData(i) == (char)0) break;
             carr[i] = (char)getElement_timeSyncData(i);
         }
         return new String(carr,0,i);
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: clockCount
    //   Field type: short
    //   Offset (bits): 136
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'clockCount' is signed (false).
     */
    public static boolean isSigned_clockCount() {
        return false;
    }

    /**
     * Return whether the field 'clockCount' is an array (false).
     */
    public static boolean isArray_clockCount() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'clockCount'
     */
    public static int offset_clockCount() {
        return (clockCount_offset_bits / 8);
    }

    /**
     * Return the offset (in bits) of the field 'clockCount'
     */
    public static int offsetBits_clockCount() {
        return clockCount_offset_bits;
    }

    /**
     * Return the value (as a short) of the field 'clockCount'
     */
    public short get_clockCount() {
        return (short)getSIntElement(offsetBits_clockCount(), clockCount_size_bits);
    }

    /**
     * Set the value of the field 'clockCount'
     */
    public void set_clockCount(short value) {
        setSIntElement(offsetBits_clockCount(), clockCount_size_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'clockCount'
     */
    public static int size_clockCount() {
        return (clockCount_size_bits / 8);
    }

    /**
     * Return the size, in bits, of the field 'clockCount'
     */
    public static int sizeBits_clockCount() {
        return clockCount_size_bits;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.field.name
    //   Field type: byte[]
    //   Offset (bits): 152
    //   Size of each element (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.field.name' is signed (false).
     */
    public static boolean isSigned_u_field_name() {
        return false;
    }

    /**
     * Return whether the field 'u.field.name' is an array (true).
     */
    public static boolean isArray_u_field_name() {
        return true;
    }

    /**
     * Return the offset (in bytes) of the field 'u.field.name'
     */
    public static int offset_u_field_name(int index1) {
        int offset = 0; //whj modified pre: 152;
        if (index1 < 0 || index1 >= 8) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * 8;
        return 0; //whj modified pre: (offset / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.field.name'
     */
    public static int offsetBits_u_field_name(int index1) {
        int offset = 0; //whj modified pre: 152;
        if (index1 < 0 || index1 >= 8) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * 8;
        return 0; //whj modified pre: offset;
    }

    /**
     * Return the entire array 'u.field.name' as a byte[]
     */
    	//whj removed for compact msg:
    	/*  
    public byte[] get_u_field_name() {
        byte[] tmp = new byte[8];
        for (int index0 = 0; index0 < numElements_u_field_name(0); index0++) {
            tmp[index0] = getElement_u_field_name(index0);
        }
        return tmp;
        byte[] tmp = new byte[8];
        
    }*/
    public byte[] get_u_field_name(int numField) {
    	
        byte[] tmp = new byte[8];
        for (int index0 = 0; index0 < numElements_u_field_name(0); index0++) {
            tmp[index0] = (byte)g_FieldName[numField].charAt(index0);
        }
        return tmp;
    }

    /**
     * Set the contents of the array 'u.field.name' from the given byte[]
     */
     //whj removed for compact msg:
    	/*
    public void set_u_field_name(byte[] value) {
        for (int index0 = 0; index0 < value.length; index0++) {
            setElement_u_field_name(index0, value[index0]);
        }
    }*/
	public void set_u_field_name(byte[] value) {
  //      for (int index0 = 0; index0 < value.length; index0++) {
//            g_FieldName[numField][index0]= value[index0];
        //}
    }
    //2005-1-17 15:03
    /**
     * Return an element (as a byte) of the array 'u.field.name'
     */
	//whj removed for compact msg:
	/* public byte getElement_u_field_name(int index1) {
        return (byte)getSIntElement(offsetBits_u_field_name(index1), 8);
    }*/
	public byte getElement_u_field_name(int numField, int index1) 
	{
		if(index1<g_FieldName[numField].length())
			return (byte)g_FieldName[numField].charAt(index1);		//getSIntElement(offsetBits_u_field_name(index1), 8);
		else 
			return 0;
	}
    /**
     * Set an element of the array 'u.field.name'
     */
	//whj removed for compact msg:
	/*public void setElement_u_field_name(int index1, byte value) 
	{
        setSIntElement(offsetBits_u_field_name(index1), 8, value);
    }*/
	public byte getElement_u_field(int numField) 
	{
		if(numField<fieldNo_size_bits)
			return (byte)getUIntElement(fieldNo_offset_bits+numField,1);
		else 
		{
			System.out.println("Fatal error, out bound u_field");
			return 0;
		}
		//g_FieldName[numField][index1]= value;// setSIntElement(offsetBits_u_field_name(index1), 8, value);
	}

	public void setElement_u_field(int numField) 
	{
		if(numField<fieldNo_size_bits)
			setUIntElement(fieldNo_offset_bits+numField,1,1);
		else 
			System.out.println("Fatal error, out bound u_field");
		//g_FieldName[numField][index1]= value;// setSIntElement(offsetBits_u_field_name(index1), 8, value);
	}

	public void setGlobalElement_u_field_name(int numField,int index1, byte value) 
	{
//		g_FieldName[numField][index1]= value;// setSIntElement(offsetBits_u_field_name(index1), 8, value);
	}

    /**
     * Return the total size, in bytes, of the array 'u.field.name'
     */
    public static int totalSize_u_field_name() 
	{
        return totalSize_u_field_name_str;//(64 / 8);
    }

    /**
     * Return the total size, in bits, of the array 'u.field.name'
     */
    public static int totalSizeBits_u_field_name() {
        return totalSize_u_field_name_str*8;//64;
    }

    /**
     * Return the size, in bytes, of each element of the array 'u.field.name'
     */
    public static int elementSize_u_field_name() {
        return 0;//(8 / 8);
    }

    /**
     * Return the size, in bits, of each element of the array 'u.field.name'
     */
    public static int elementSizeBits_u_field_name() {
        return 1;//8;
    }

    /**
     * Return the number of dimensions in the array 'u.field.name'
     */
    public static int numDimensions_u_field_name() {
        return 1;
    }

    /**
     * Return the number of elements in the array 'u.field.name'
     */
    public static int numElements_u_field_name() {
        return fieldNo_size_bits;
    }

    /**
     * Return the number of elements in the array 'u.field.name'
     * for the given dimension.
     */
    public static int numElements_u_field_name(int dimension) {
      int array_dims[] = { 8,  };
        if (dimension < 0 || dimension >= 1) throw new ArrayIndexOutOfBoundsException();
        if (array_dims[dimension] == 0) throw new IllegalArgumentException("Array dimension "+dimension+" has unknown size");
        return fieldNo_size_bits;//array_dims[dimension];
    }

    /**
     * Fill in the array 'u.field.name' with a String
     */
    public void setString_u_field_name(String s) { 
		 
         int len = s.length();
         int i;
         if(len>(maxFieldLen-1))len=maxFieldLen-1;//whj
		for (i=0; i<fieldNo_size_bits;i++)
		{
			if(s.compareTo(g_FieldName[i])==0)
			{
				setElement_u_field(i);
				}
		}
         /*for (i = 0; i < len; i++) {
             setElement_u_field_name(i, (byte)s.charAt(i));
         }
         setElement_u_field_name(i, (byte)0); //null terminate*/
    }

    /**
     * Read the array 'u.field.name' as a String
     */
    public String getString_u_field_name(int numField) { 
         char carr[] = new char[Math.min(net.tinyos.message.Message.MAX_CONVERTED_STRING_LENGTH,8)];
         int i;
         for (i = 0; i < carr.length; i++) {
             if ((char)getElement_u_field_name(numField, i) == (char)0) break;
             carr[i] = (char)getElement_u_field_name(numField,i);
         }
         return new String(carr,0,i);
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.field.op
    //   Field type: short
    //   Offset (bits): 216
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.field.op' is signed (false).
     */
    public static boolean isSigned_u_field_op() {
        return false;
    }

    /**
     * Return whether the field 'u.field.op' is an array (false).
     */
    public static boolean isArray_u_field_op() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.field.op'
     */
    public static int offset_u_field_op() {
        return (fieldOp_offset_bits / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.field.op'
     */
    public static int offsetBits_u_field_op() {
        return fieldOp_offset_bits;
    }

    /**
     * Return the value (as a short) of the field 'u.field.op'
     */
    public short get_u_field_op() {
        return (short)getUIntElement(offsetBits_u_field_op(),fieldOp_size_bits);
    }

    /**
     * Set the value of the field 'u.field.op'
     */
    public void set_u_field_op(short value) {
        setUIntElement(offsetBits_u_field_op(),fieldOp_size_bits , value);
    }

    /**
     * Return the size, in bytes, of the field 'u.field.op'
     */
    public static int size_u_field_op() {
        return (fieldOp_size_bits / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.field.op'
     */
    public static int sizeBits_u_field_op() {
        return fieldOp_size_bits;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.field.type
    //   Field type: short
    //   Offset (bits): 224
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.field.type' is signed (false).
     */
    public static boolean isSigned_u_field_type() {
        return false;
    }

    /**
     * Return whether the field 'u.field.type' is an array (false).
     */
    public static boolean isArray_u_field_type() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.field.type'
     */
    public static int offset_u_field_type() {
        return fieldOp_offset_bits/8;//(224 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.field.type'
     */
    public static int offsetBits_u_field_type() {
        return fieldOp_offset_bits;//224;
    }

    /**
     * Return the value (as a short) of the field 'u.field.type'
     */
    public short get_u_field_type(int numField) {
        return (short)g_FieldType[numField];//(short)getUIntElement(offsetBits_u_field_type(), 8);
    }
   
    /**
     * Set the value of the field 'u.field.type'
     */
    public void set_u_field_type(int numField, short value) {
        g_FieldType[numField]=(byte)value; //setUIntElement(offsetBits_u_field_type(), 8, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.field.type'
     */
    public static int size_u_field_type() {
        return (8 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.field.type'
     */
    public static int sizeBits_u_field_type() {
        return 8;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.opType
    //   Field type: byte
    //   Offset (bits): 152
    //   Size (bits): 6
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.opType' is signed (false).
     */
    public static boolean isSigned_u_expr_opType() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.opType' is an array (false).
     */
    public static boolean isArray_u_expr_opType() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.opType'
     */
    public static int offset_u_expr_opType() {
        return (exprOpType_offset_bits/8);//(152 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.opType'
     */
    public static int offsetBits_u_expr_opType() {
        return exprOpType_offset_bits;//152;
    }

    /**
     * Return the value (as a byte) of the field 'u.expr.opType'
     */
    public byte get_u_expr_opType(int numExpr) {
    	if(numExpr<maxExprs)
        	return (byte)getSIntElement(offsetBits_u_expr_opType()+exprOpType_size_bits*numExpr, exprOpType_size_bits);
	else 
		return 0;
        //(byte)getSIntElement(offsetBits_u_expr_opType(), 6);
    }

    /**
     * Set the value of the field 'u.expr.opType'
     */
    public void set_u_expr_opType(int numExpr, byte value) {
        setSIntElement(offsetBits_u_expr_opType()+exprOpType_size_bits*numExpr, exprOpType_size_bits,value);
        //setSIntElement(offsetBits_u_expr_opType(), 6, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.opType'
     * WARNING: This field is not an even-sized number of bytes (6 bits).
     */
    public static int size_u_expr_opType() {
        return (exOpValField_size_bits/8 + 1);//(6 / 8) + 1;
    }

    /**
     * Return the size, in bits, of the field 'u.expr.opType'
     */
    public static int sizeBits_u_expr_opType() {
        return exOpValField_size_bits;//6;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.isStringExp
    //   Field type: byte
    //   Offset (bits): 158
    //   Size (bits): 1
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.isStringExp' is signed (false).
     */
    public static boolean isSigned_u_expr_isStringExp() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.isStringExp' is an array (false).
     */
    public static boolean isArray_u_expr_isStringExp() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.isStringExp'
     * WARNING: This field is not byte-aligned (bit offset 158).
     */
    public static int offset_u_expr_isStringExp(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + isStringExp_offset_bits)/8;//(158 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.isStringExp'
     */
    public static int offsetBits_u_expr_isStringExp(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + isStringExp_offset_bits);//158;
    }

    /**
     * Return the value (as a byte) of the field 'u.expr.isStringExp'
     */
    public byte get_u_expr_isStringExp(int numExpr) {
    	if(numExpr<maxExprs)
        	return (byte)getUIntElement(offsetBits_u_expr_isStringExp(numExpr) , isStringExp_size_bits);
        else
        	return 0;
    }

    /**
     * Set the value of the field 'u.expr.isStringExp'
     */
    public void set_u_expr_isStringExp(int numExpr, byte value) {
    	if(numExpr<maxExprs)
        	setUIntElement(offsetBits_u_expr_isStringExp(numExpr), isStringExp_size_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.isStringExp'
     * WARNING: This field is not an even-sized number of bytes (1 bits).
     */
    public static int size_u_expr_isStringExp() {
        return (isStringExp_size_bits / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.isStringExp'
     */
    public static int sizeBits_u_expr_isStringExp() {
        return isStringExp_size_bits;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.success
    //   Field type: byte
    //   Offset (bits): 159
    //   Size (bits): 1
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.success' is signed (false).
     */
    public static boolean isSigned_u_expr_success() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.success' is an array (false).
     */
    public static boolean isArray_u_expr_success() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.success'
     * WARNING: This field is not byte-aligned (bit offset 159).
     */
    public static int offset_u_expr_success(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + exprSuccess_offset_bits)/8;//exprSuccess_offset_bits/8;//(159 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.success'
     */
    public static int offsetBits_u_expr_success(int numExpr) {
		if(numExpr>=maxExprs)
			numExpr = maxExprs-1;
	    return (expStart_offset_bits + numExpr*expr_size_bits + exprSuccess_offset_bits);
        //159;
    }

    /**
     * Return the value (as a byte) of the field 'u.expr.success'
     */
    public byte get_u_expr_success(int numExpr) {
	
    	if(numExpr<maxExprs)
        	return (byte)getUIntElement(offsetBits_u_expr_success(numExpr), exprSuccess_size_bits);//(byte)getUIntElement(offsetBits_u_expr_success(), 1);
        else return 0;
    }

    /**
     * Set the value of the field 'u.expr.success'
     */
    public void set_u_expr_success(int numExpr,byte value) {
    	
        if(numExpr<maxExprs)
			setUIntElement(offsetBits_u_expr_success(numExpr), exprSuccess_size_bits,value);
        	//setUIntElement(offsetBits_u_expr_success()+ numExpr, 1, value);//setUIntElement(offsetBits_u_expr_success(), 1, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.success'
     * WARNING: This field is not an even-sized number of bytes (1 bits).
     */
    public static int size_u_expr_success() {
        return (exprSuccess_size_bits / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.success'
     */
    public static int sizeBits_u_expr_success() {
        return exprSuccess_size_bits;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.idx
    //   Field type: byte
    //   Offset (bits): 160
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.idx' is signed (false).
     */
    public static boolean isSigned_u_expr_idx() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.idx' is an array (false).
     */
    public static boolean isArray_u_expr_idx() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.idx'
     */
    public static int offset_u_expr_idx() {
        return exprIdx_offset_bits/8;//(160 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.idx'
     */
    public static int offsetBits_u_expr_idx() {
        return exprIdx_offset_bits;//160;
    }

    /**
     * Return the value (as a byte) of the field 'u.expr.idx'
     */
    public byte get_u_expr_idx(int numExpr) {
    	//whj
        return (byte)numExpr;//(byte)getSIntElement(offsetBits_u_expr_idx(), 8);
    }

    /**
     * Set the value of the field 'u.expr.idx'
     */
    public void set_u_expr_idx(int numExpr,byte value) {
    	//whj
        return;//setSIntElement(offsetBits_u_expr_idx(), 8, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.idx'
     */
    public static int size_u_expr_idx() {
        return (8 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.idx'
     */
    public static int sizeBits_u_expr_idx() {
        return 8;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.opval.field
    //   Field type: short
    //   Offset (bits): 168
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.ex.opval.field' is signed (false).
     */
    public static boolean isSigned_u_expr_ex_opval_field() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.ex.opval.field' is an array (false).
     */
    public static boolean isArray_u_expr_ex_opval_field() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.ex.opval.field'
     */
    public static int offset_u_expr_ex_opval_field(int numExpr) {
	    return (expStart_offset_bits + numExpr*expr_size_bits + exOpValField_offset_bits)/8;//(168 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.opval.field'
     */
    public static int offsetBits_u_expr_ex_opval_field(int numExpr ) {
        return (expStart_offset_bits + numExpr*expr_size_bits + exOpValField_offset_bits);//168;
    }

    /**
     * Return the value (as a short) of the field 'u.expr.ex.opval.field'
     */
    public short get_u_expr_ex_opval_field(int numExpr) {
    	if(numExpr<maxExprs)
        	return (short)getUIntElement(offsetBits_u_expr_ex_opval_field(numExpr),exOpValField_size_bits);// 16 getS
        else return 0;
    }

    /**
     * Set the value of the field 'u.expr.ex.opval.field'
     */
    public void set_u_expr_ex_opval_field(int numExpr,short value) {
    	if(numExpr<maxExprs)
        	setUIntElement(offsetBits_u_expr_ex_opval_field(numExpr), exOpValField_size_bits, value); //pre 16 cur 6.
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.opval.field'
     */
    public static int size_u_expr_ex_opval_field() {
        return exOpValField_size_bits/8+1; //(16 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.ex.opval.field'
     */
    public static int sizeBits_u_expr_ex_opval_field() {
        return exOpValField_size_bits;//16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.opval.op
    //   Field type: byte
    //   Offset (bits): 184
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.ex.opval.op' is signed (false).
     */
    public static boolean isSigned_u_expr_ex_opval_op() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.ex.opval.op' is an array (false).
     */
    public static boolean isArray_u_expr_ex_opval_op() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.ex.opval.op'
     */
    public static int offset_u_expr_ex_opval_op(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + exOpValOp_offset_bits)/8;//(184 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.opval.op'
     */
    public static int offsetBits_u_expr_ex_opval_op(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + exOpValOp_offset_bits);//184;
    }

    /**
     * Return the value (as a byte) of the field 'u.expr.ex.opval.op'
     */
    public byte get_u_expr_ex_opval_op(int numExpr) {
		if(numExpr<maxExprs)
			return (byte)getUIntElement(offsetBits_u_expr_ex_opval_op(numExpr), exOpValOp_size_bits);//getS
		else 
			return 0;
    }

    /**
     * Set the value of the field 'u.expr.ex.opval.op'
     */
    public void set_u_expr_ex_opval_op(int numExpr,byte value) {
		if(numExpr<maxExprs)
			setUIntElement(offsetBits_u_expr_ex_opval_op(numExpr), exOpValOp_size_bits, value);//setS
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.opval.op'
     */
    public static int size_u_expr_ex_opval_op() {
        return exOpValOp_size_bits/8;//(8 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.ex.opval.op'
     */
    public static int sizeBits_u_expr_ex_opval_op() {
        return exOpValOp_size_bits;//8;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.opval.value
    //   Field type: short
    //   Offset (bits): 192
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.ex.opval.value' is signed (false).
     */
    public static boolean isSigned_u_expr_ex_opval_value() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.ex.opval.value' is an array (false).
     */
    public static boolean isArray_u_expr_ex_opval_value() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.ex.opval.value'
     */
    public static int offset_u_expr_ex_opval_value(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + exOpValVal_offset_bits)/8;//(192 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.opval.value'
     */
    public static int offsetBits_u_expr_ex_opval_value(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + exOpValVal_offset_bits);//192;
    }

    /**
     * Return the value (as a short) of the field 'u.expr.ex.opval.value'
     */
    public short get_u_expr_ex_opval_value(int numExpr) {
		if(numExpr<maxExprs)
			return (short)getSIntElement(offsetBits_u_expr_ex_opval_value(numExpr), exOpValVal_size_bits);
		else
			return 0;
    }

    /**
     * Set the value of the field 'u.expr.ex.opval.value'
     */
    public void set_u_expr_ex_opval_value(int numExpr, short value) {
		if(numExpr<maxExprs)
			setSIntElement(offsetBits_u_expr_ex_opval_value(numExpr),exOpValVal_size_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.opval.value'
     */
    public static int size_u_expr_ex_opval_value() {
        return exOpValVal_size_bits/8;//(16 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.ex.opval.value'
     */
    public static int sizeBits_u_expr_ex_opval_value() {
        return exOpValVal_size_bits;//16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.agg.field
    //   Field type: short
    //   Offset (bits): 168
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.ex.agg.field' is signed (false).
     */
    public static boolean isSigned_u_expr_ex_agg_field() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.ex.agg.field' is an array (false).
     */
    public static boolean isArray_u_expr_ex_agg_field() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.ex.agg.field'
     */
    public static int offset_u_expr_ex_agg_field(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + aggField_offset_bits)/8;//(168 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.agg.field'
     */
    public static int offsetBits_u_expr_ex_agg_field(int numExpr) {
        return  (expStart_offset_bits + numExpr*expr_size_bits + aggField_offset_bits);//168;
    }

    /**
     * Return the value (as a short) of the field 'u.expr.ex.agg.field'
     */
    public short get_u_expr_ex_agg_field(int numExpr) {
        return (short)getUIntElement(offsetBits_u_expr_ex_agg_field(numExpr), aggField_size_bits);//16);
    }

    /**
     * Set the value of the field 'u.expr.ex.agg.field'
     */
    public void set_u_expr_ex_agg_field(int numExpr,short value) {
        setUIntElement(offsetBits_u_expr_ex_agg_field(numExpr), aggField_size_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.agg.field'
     */
    public static int size_u_expr_ex_agg_field() {
        return aggField_size_bits/8;//(16 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.ex.agg.field'
     */
    public static int sizeBits_u_expr_ex_agg_field() {
        return aggField_size_bits;//16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.agg.groupingField
    //   Field type: short
    //   Offset (bits): 184
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.ex.agg.groupingField' is signed (false).
     */
    public static boolean isSigned_u_expr_ex_agg_groupingField() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.ex.agg.groupingField' is an array (false).
     */
    public static boolean isArray_u_expr_ex_agg_groupingField() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.ex.agg.groupingField'
     */
    public static int offset_u_expr_ex_agg_groupingField(int numExpr) {
        return  (expStart_offset_bits + numExpr*expr_size_bits + aggGroupingField_offset_bits)/8;//(184 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.agg.groupingField'
     */
    public static int offsetBits_u_expr_ex_agg_groupingField(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + aggGroupingField_offset_bits);//184;
    }

    /**
     * Return the value (as a short) of the field 'u.expr.ex.agg.groupingField'
     */
    public short get_u_expr_ex_agg_groupingField(int numExpr) {
    	if(numExpr<maxExprs)
        	return (short)getUIntElement(offsetBits_u_expr_ex_agg_groupingField(numExpr), aggGroupingField_size_bits);
        else
        	return 0;
		//(short)getSIntElement(offsetBits_u_expr_ex_agg_groupingField(), 16);
    }

    /**
     * Set the value of the field 'u.expr.ex.agg.groupingField'
     */
    public void set_u_expr_ex_agg_groupingField(int numExpr,short value) {
    	if(numExpr<maxExprs)
        	setUIntElement(offsetBits_u_expr_ex_agg_groupingField(numExpr), aggGroupingField_size_bits, value);//16
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.agg.groupingField'
     */
    public static int size_u_expr_ex_agg_groupingField() {
        return aggGroupingField_size_bits/8;//(16 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.ex.agg.groupingField'
     */
    public static int sizeBits_u_expr_ex_agg_groupingField() {
        return aggGroupingField_size_bits;//16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.agg.groupFieldOp
    //   Field type: short
    //   Offset (bits): 200
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.ex.agg.groupFieldOp' is signed (false).
     */
    public static boolean isSigned_u_expr_ex_agg_groupFieldOp() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.ex.agg.groupFieldOp' is an array (false).
     */
    public static boolean isArray_u_expr_ex_agg_groupFieldOp() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.ex.agg.groupFieldOp'
     */
    public static int offset_u_expr_ex_agg_groupFieldOp(int numExpr) {
        return  (expStart_offset_bits + numExpr*expr_size_bits + aggGroupFieldOP_offset_bits)/8;//(200 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.agg.groupFieldOp'
     */
    public static int offsetBits_u_expr_ex_agg_groupFieldOp(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + aggGroupFieldOP_offset_bits);//200;
    }

    /**
     * Return the value (as a short) of the field 'u.expr.ex.agg.groupFieldOp'
     */
    public short get_u_expr_ex_agg_groupFieldOp(int numExpr) {
    	if(numExpr<maxExprs)
        	return (short)getUIntElement(offsetBits_u_expr_ex_agg_groupFieldOp(numExpr), aggGroupFieldOP_size_bits);//16);
        return 0;
    }

    /**
     * Set the value of the field 'u.expr.ex.agg.groupFieldOp'
     */
    public void set_u_expr_ex_agg_groupFieldOp(int numExpr,short value) {
    	if(numExpr<maxExprs)
        	setUIntElement(offsetBits_u_expr_ex_agg_groupFieldOp(numExpr), aggGroupFieldOP_size_bits, value);//16
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.agg.groupFieldOp'
     */
    public static int size_u_expr_ex_agg_groupFieldOp() {
        return (aggGroupFieldOP_size_bits/8);//(16 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.ex.agg.groupFieldOp'
     */
    public static int sizeBits_u_expr_ex_agg_groupFieldOp() {
        return aggGroupFieldOP_size_bits;//16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.agg.groupFieldConst
    //   Field type: short
    //   Offset (bits): 216
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.ex.agg.groupFieldConst' is signed (false).
     */
    public static boolean isSigned_u_expr_ex_agg_groupFieldConst() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.ex.agg.groupFieldConst' is an array (false).
     */
    public static boolean isArray_u_expr_ex_agg_groupFieldConst() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.ex.agg.groupFieldConst'
     */
    public static int offset_u_expr_ex_agg_groupFieldConst(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + aggGroupFieldConst_offset_bits)/8;//(216 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.agg.groupFieldConst'
     */
    public static int offsetBits_u_expr_ex_agg_groupFieldConst(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + aggGroupFieldConst_offset_bits);//216;
    }

    /**
     * Return the value (as a short) of the field 'u.expr.ex.agg.groupFieldConst'
     */
    public short get_u_expr_ex_agg_groupFieldConst(int numExpr) {
        return (short)getSIntElement(offsetBits_u_expr_ex_agg_groupFieldConst(numExpr),aggGroupFieldConst_size_bits);// 16);
    }

    /**
     * Set the value of the field 'u.expr.ex.agg.groupFieldConst'
     */
    public void set_u_expr_ex_agg_groupFieldConst(int numExpr,short value) {
        setSIntElement(offsetBits_u_expr_ex_agg_groupFieldConst(numExpr), aggGroupFieldConst_size_bits, value);//16
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.agg.groupFieldConst'
     */
    public static int size_u_expr_ex_agg_groupFieldConst() {
        return aggGroupFieldConst_size_bits/8;//(16 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.ex.agg.groupFieldConst'
     */
    public static int sizeBits_u_expr_ex_agg_groupFieldConst() {
        return aggGroupFieldConst_size_bits;//16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.agg.op
    //   Field type: byte
    //   Offset (bits): 232
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.ex.agg.op' is signed (false).
     */
    public static boolean isSigned_u_expr_ex_agg_op() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.ex.agg.op' is an array (false).
     */
    public static boolean isArray_u_expr_ex_agg_op() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.ex.agg.op'
     */
    public static int offset_u_expr_ex_agg_op(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + aggOp_offset_bits)/8;//(232 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.agg.op'
     */
    public static int offsetBits_u_expr_ex_agg_op(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + aggOp_offset_bits);//232;
    }

    /**
     * Return the value (as a byte) of the field 'u.expr.ex.agg.op'
     */
    public byte get_u_expr_ex_agg_op(int numExpr) {
		if(numExpr<maxExprs)
			return (byte)getUIntElement(offsetBits_u_expr_ex_agg_op(numExpr), exprExAgg_size_bits);//;8);
		else
			return 0;
    }

    /**
     * Set the value of the field 'u.expr.ex.agg.op'
     */
    public void set_u_expr_ex_agg_op(int numExpr, byte value) {
		if(numExpr<maxExprs)
			setUIntElement(offsetBits_u_expr_ex_agg_op(numExpr),exprExAgg_size_bits , value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.agg.op'
     */
    public static int size_u_expr_ex_agg_op() {
        return (exprExAgg_size_bits / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.ex.agg.op'
     */
    public static int sizeBits_u_expr_ex_agg_op() {
        return exprExAgg_size_bits;//8;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.tagg.agg.field
    //   Field type: short
    //   Offset (bits): 168
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.ex.tagg.agg.field' is signed (false).
     */
    public static boolean isSigned_u_expr_ex_tagg_agg_field() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.ex.tagg.agg.field' is an array (false).
     */
    public static boolean isArray_u_expr_ex_tagg_agg_field() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.ex.tagg.agg.field'
     */
    public static int offset_u_expr_ex_tagg_agg_field() {
        return (168 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.tagg.agg.field'
     */
    public static int offsetBits_u_expr_ex_tagg_agg_field() {
        return 168;
    }

    /**
     * Return the value (as a short) of the field 'u.expr.ex.tagg.agg.field'
     */
    public short get_u_expr_ex_tagg_agg_field() {
        return (short)getSIntElement(offsetBits_u_expr_ex_tagg_agg_field(), 16);
    }

    /**
     * Set the value of the field 'u.expr.ex.tagg.agg.field'
     */
    public void set_u_expr_ex_tagg_agg_field(short value) {
        setSIntElement(offsetBits_u_expr_ex_tagg_agg_field(), 16, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.tagg.agg.field'
     */
    public static int size_u_expr_ex_tagg_agg_field() {
        return (16 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.ex.tagg.agg.field'
     */
    public static int sizeBits_u_expr_ex_tagg_agg_field() {
        return 16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.tagg.agg.groupingField
    //   Field type: short
    //   Offset (bits): 184
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.ex.tagg.agg.groupingField' is signed (false).
     */
    public static boolean isSigned_u_expr_ex_tagg_agg_groupingField() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.ex.tagg.agg.groupingField' is an array (false).
     */
    public static boolean isArray_u_expr_ex_tagg_agg_groupingField() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.ex.tagg.agg.groupingField'
     */
    public static int offset_u_expr_ex_tagg_agg_groupingField() {
        return (184 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.tagg.agg.groupingField'
     */
    public static int offsetBits_u_expr_ex_tagg_agg_groupingField() {
        return 184;
    }

    /**
     * Return the value (as a short) of the field 'u.expr.ex.tagg.agg.groupingField'
     */
    public short get_u_expr_ex_tagg_agg_groupingField() {
        return (short)getSIntElement(offsetBits_u_expr_ex_tagg_agg_groupingField(), 16);
    }

    /**
     * Set the value of the field 'u.expr.ex.tagg.agg.groupingField'
     */
    public void set_u_expr_ex_tagg_agg_groupingField(short value) {
        setSIntElement(offsetBits_u_expr_ex_tagg_agg_groupingField(), 16, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.tagg.agg.groupingField'
     */
    public static int size_u_expr_ex_tagg_agg_groupingField() {
        return (16 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.ex.tagg.agg.groupingField'
     */
    public static int sizeBits_u_expr_ex_tagg_agg_groupingField() {
        return 16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.tagg.agg.groupFieldOp
    //   Field type: short
    //   Offset (bits): 200
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.ex.tagg.agg.groupFieldOp' is signed (false).
     */
    public static boolean isSigned_u_expr_ex_tagg_agg_groupFieldOp() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.ex.tagg.agg.groupFieldOp' is an array (false).
     */
    public static boolean isArray_u_expr_ex_tagg_agg_groupFieldOp() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.ex.tagg.agg.groupFieldOp'
     */
    public static int offset_u_expr_ex_tagg_agg_groupFieldOp() {
        return (200 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.tagg.agg.groupFieldOp'
     */
    public static int offsetBits_u_expr_ex_tagg_agg_groupFieldOp() {
        return 200;
    }

    /**
     * Return the value (as a short) of the field 'u.expr.ex.tagg.agg.groupFieldOp'
     */
    public short get_u_expr_ex_tagg_agg_groupFieldOp() {
        return (short)getSIntElement(offsetBits_u_expr_ex_tagg_agg_groupFieldOp(), 16);
    }

    /**
     * Set the value of the field 'u.expr.ex.tagg.agg.groupFieldOp'
     */
    public void set_u_expr_ex_tagg_agg_groupFieldOp(short value) {
        setSIntElement(offsetBits_u_expr_ex_tagg_agg_groupFieldOp(), 16, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.tagg.agg.groupFieldOp'
     */
    public static int size_u_expr_ex_tagg_agg_groupFieldOp() {
        return (16 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.ex.tagg.agg.groupFieldOp'
     */
    public static int sizeBits_u_expr_ex_tagg_agg_groupFieldOp() {
        return 16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.tagg.agg.groupFieldConst
    //   Field type: short
    //   Offset (bits): 216
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.ex.tagg.agg.groupFieldConst' is signed (false).
     */
    public static boolean isSigned_u_expr_ex_tagg_agg_groupFieldConst() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.ex.tagg.agg.groupFieldConst' is an array (false).
     */
    public static boolean isArray_u_expr_ex_tagg_agg_groupFieldConst() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.ex.tagg.agg.groupFieldConst'
     */
    public static int offset_u_expr_ex_tagg_agg_groupFieldConst() {
        return (216 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.tagg.agg.groupFieldConst'
     */
    public static int offsetBits_u_expr_ex_tagg_agg_groupFieldConst() {
        return 216;
    }

    /**
     * Return the value (as a short) of the field 'u.expr.ex.tagg.agg.groupFieldConst'
     */
    public short get_u_expr_ex_tagg_agg_groupFieldConst() {
        return (short)getSIntElement(offsetBits_u_expr_ex_tagg_agg_groupFieldConst(), 16);
    }

    /**
     * Set the value of the field 'u.expr.ex.tagg.agg.groupFieldConst'
     */
    public void set_u_expr_ex_tagg_agg_groupFieldConst(short value) {
        setSIntElement(offsetBits_u_expr_ex_tagg_agg_groupFieldConst(), 16, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.tagg.agg.groupFieldConst'
     */
    public static int size_u_expr_ex_tagg_agg_groupFieldConst() {
        return (16 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.ex.tagg.agg.groupFieldConst'
     */
    public static int sizeBits_u_expr_ex_tagg_agg_groupFieldConst() {
        return 16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.tagg.agg.op
    //   Field type: byte
    //   Offset (bits): 232
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.ex.tagg.agg.op' is signed (false).
     */
    public static boolean isSigned_u_expr_ex_tagg_agg_op() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.ex.tagg.agg.op' is an array (false).
     */
    public static boolean isArray_u_expr_ex_tagg_agg_op() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.ex.tagg.agg.op'
     */
    public static int offset_u_expr_ex_tagg_agg_op() {
        return (232 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.tagg.agg.op'
     */
    public static int offsetBits_u_expr_ex_tagg_agg_op() {
        return 232;
    }

    /**
     * Return the value (as a byte) of the field 'u.expr.ex.tagg.agg.op'
     */
    public byte get_u_expr_ex_tagg_agg_op() {
        return (byte)getSIntElement(offsetBits_u_expr_ex_tagg_agg_op(), 8);
    }

    /**
     * Set the value of the field 'u.expr.ex.tagg.agg.op'
     */
    public void set_u_expr_ex_tagg_agg_op(byte value) {
        setSIntElement(offsetBits_u_expr_ex_tagg_agg_op(), 8, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.tagg.agg.op'
     */
    public static int size_u_expr_ex_tagg_agg_op() {
        return (8 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.ex.tagg.agg.op'
     */
    public static int sizeBits_u_expr_ex_tagg_agg_op() {
        return 8;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.tagg.args
    //   Field type: short[]
    //   Offset (bits): 240
    //   Size of each element (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.ex.tagg.args' is signed (false).
     */
    public static boolean isSigned_u_expr_ex_tagg_args() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.ex.tagg.args' is an array (true).
     */
    public static boolean isArray_u_expr_ex_tagg_args() {
        return true;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.ex.tagg.args'
     */
    public static int offset_u_expr_ex_tagg_args(int index1) {
    	
        int offset;
        if (index1 < 0 || index1 >= maxExprs) throw new ArrayIndexOutOfBoundsException();
        //offset += 0 + index1 * 8;
        offset = expStart_offset_bits + expr_size_bits* index1 +exprExTaggArgs_offset_bits;//240;
        return (offset / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.tagg.args'
     */
    public static int offsetBits_u_expr_ex_tagg_args(int index1) {
        int offset ;//240;
        if (index1 < 0 || index1 >= 4) throw new ArrayIndexOutOfBoundsException();
        //offset += 0 + index1 * 8;
        offset = expStart_offset_bits + expr_size_bits* index1 +exprExTaggArgs_offset_bits;//240;
        return offset;
    }

    /**
     * Return the entire array 'u.expr.ex.tagg.args' as a short[]
     */
    public short[] get_u_expr_ex_tagg_args() {
        short[] tmp = new short[4];
        for (int index0 = 0; index0 < numElements_u_expr_ex_tagg_args(0); index0++) {
            tmp[index0] = getElement_u_expr_ex_tagg_args(index0);
        }
        return tmp;
    }

    /**
     * Set the contents of the array 'u.expr.ex.tagg.args' from the given short[]
     */
    public void set_u_expr_ex_tagg_args( short[] value) {
        for (int index0 = 0; index0 < value.length; index0++) {
            setElement_u_expr_ex_tagg_args(index0, value[index0]);
        }
    }

    /**
     * Return an element (as a short) of the array 'u.expr.ex.tagg.args'
     */
    public short getElement_u_expr_ex_tagg_args(int index1) {
        return (short)getUIntElement(offsetBits_u_expr_ex_tagg_args(index1), exprExTaggArgs_size_bits);
    }

    /**
     * Set an element of the array 'u.expr.ex.tagg.args'
     */
    public void setElement_u_expr_ex_tagg_args(int index1, short value) {
        setUIntElement(offsetBits_u_expr_ex_tagg_args(index1), exprExTaggArgs_size_bits, value);
    }

    /**
     * Return the total size, in bytes, of the array 'u.expr.ex.tagg.args'
     */
    public static int totalSize_u_expr_ex_tagg_args() {
        return maxExprs;//(32 / 8);
    }

    /**
     * Return the total size, in bits, of the array 'u.expr.ex.tagg.args'
     */
    public static int totalSizeBits_u_expr_ex_tagg_args() {
        return exprExTaggArgs_size_bits;//32;
    }

    /**
     * Return the size, in bytes, of each element of the array 'u.expr.ex.tagg.args'
     */
    public static int elementSize_u_expr_ex_tagg_args() {
        return (exprExTaggArgs_size_bits / 8);
    }

    /**
     * Return the size, in bits, of each element of the array 'u.expr.ex.tagg.args'
     */
    public static int elementSizeBits_u_expr_ex_tagg_args() {
        return exprExTaggArgs_size_bits;
    }

    /**
     * Return the number of dimensions in the array 'u.expr.ex.tagg.args'
     */
    public static int numDimensions_u_expr_ex_tagg_args() {
        return 1;
    }

    /**
     * Return the number of elements in the array 'u.expr.ex.tagg.args'
     */
    public static int numElements_u_expr_ex_tagg_args() {
        return maxExprs;//4;
    }

    /**
     * Return the number of elements in the array 'u.expr.ex.tagg.args'
     * for the given dimension.
     */
    public static int numElements_u_expr_ex_tagg_args(int dimension) {
      int array_dims[] = { maxExprs,  };
        if (dimension < 0 || dimension >= 1) throw new ArrayIndexOutOfBoundsException();
        if (array_dims[dimension] == 0) throw new IllegalArgumentException("Array dimension "+dimension+" has unknown size");
        return array_dims[dimension];
    }

    /**
     * Fill in the array 'u.expr.ex.tagg.args' with a String
     */
    public void setString_u_expr_ex_tagg_args(String s) { 
         int len = s.length();
         int i;
         for (i = 0; i < len; i++) {
             setElement_u_expr_ex_tagg_args(i, (short)s.charAt(i));
         }
         setElement_u_expr_ex_tagg_args(i, (short)0); //null terminate
    }

    /**
     * Read the array 'u.expr.ex.tagg.args' as a String
     */
    public String getString_u_expr_ex_tagg_args() { 
         char carr[] = new char[Math.min(net.tinyos.message.Message.MAX_CONVERTED_STRING_LENGTH,4)];
         int i;
         for (i = 0; i < carr.length; i++) {
             if ((char)getElement_u_expr_ex_tagg_args(i) == (char)0) break;
             carr[i] = (char)getElement_u_expr_ex_tagg_args(i);
         }
         return new String(carr,0,i);
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.sexp.op
    //   Field type: byte
    //   Offset (bits): 168
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.ex.sexp.op' is signed (false).
     */
    public static boolean isSigned_u_expr_ex_sexp_op() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.ex.sexp.op' is an array (false).
     */
    public static boolean isArray_u_expr_ex_sexp_op() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.ex.sexp.op'
     */
    public static int offset_u_expr_ex_sexp_op(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + exprExSexpOp_offset_bits)/8;//(168 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.sexp.op'
     */
    public static int offsetBits_u_expr_ex_sexp_op(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + exprExSexpOp_offset_bits);//168;
    }

    /**
     * Return the value (as a byte) of the field 'u.expr.ex.sexp.op'
     */
    public byte get_u_expr_ex_sexp_op(int numExpr) {
        return (byte)getUIntElement(offsetBits_u_expr_ex_sexp_op(numExpr), exprExSexpOp_size_bits);
    }

    /**
     * Set the value of the field 'u.expr.ex.sexp.op'
     */
    public void set_u_expr_ex_sexp_op(int numExpr, byte value) {
        setUIntElement(offsetBits_u_expr_ex_sexp_op(numExpr), exprExSexpOp_size_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.sexp.op'
     */
    public static int size_u_expr_ex_sexp_op() {
        return (8 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.ex.sexp.op'
     */
    public static int sizeBits_u_expr_ex_sexp_op() {
        return 8;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.sexp.field
    //   Field type: short
    //   Offset (bits): 176
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.ex.sexp.field' is signed (false).
     */
    public static boolean isSigned_u_expr_ex_sexp_field() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.ex.sexp.field' is an array (false).
     */
    public static boolean isArray_u_expr_ex_sexp_field() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.ex.sexp.field'
     */
    public static int offset_u_expr_ex_sexp_field(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + exprExSexpField_offset_bits)/8;//(176 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.sexp.field'
     */
    public static int offsetBits_u_expr_ex_sexp_field(int numExpr) {
        return (expStart_offset_bits + numExpr*expr_size_bits + exprExSexpField_offset_bits);//176;
    }

    /**
     * Return the value (as a short) of the field 'u.expr.ex.sexp.field'
     */
    public short get_u_expr_ex_sexp_field(int numExpr) {
        return (short)getUIntElement(offsetBits_u_expr_ex_sexp_field(numExpr), exprExSexpField_size_bits);
    }

    /**
     * Set the value of the field 'u.expr.ex.sexp.field'
     */
    public void set_u_expr_ex_sexp_field(int numExpr,short value) {
        setUIntElement(offsetBits_u_expr_ex_sexp_field(numExpr), exprExSexpField_size_bits, value);//16
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.sexp.field'
     */
    public static int size_u_expr_ex_sexp_field() {
        return exprExSexpField_size_bits/8; //(16 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.ex.sexp.field'
     */
    public static int sizeBits_u_expr_ex_sexp_field() {
        return exprExSexpField_size_bits;//16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.sexp.s
    //   Field type: byte[]
    //   Offset (bits): 192
    //   Size of each element (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.ex.sexp.s' is signed (false).
     */
    public static boolean isSigned_u_expr_ex_sexp_s() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.ex.sexp.s' is an array (true).
     */
    public static boolean isArray_u_expr_ex_sexp_s() {
        return true;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.ex.sexp.s'
     */
    public static int offset_u_expr_ex_sexp_s(int numExpr, int index1) {
    	if(index1>exprExSexpStr_size_bits/8)
    		index1 = exprExSexpStr_size_bits/8;
	    return (expStart_offset_bits + numExpr*expr_size_bits + exprExSexpStr_offset_bits + index1*8)/8;
    	/*
        int offset = 192;
        if (index1 < 0 || index1 >= 8) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * 8;
        return (offset / 8);*/
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.sexp.s'
     */
    public static int offsetBits_u_expr_ex_sexp_s(int numExpr,int index1) {
    	if(index1>exprExSexpStr_size_bits/8)
    		index1 = exprExSexpStr_size_bits/8;
	    return (expStart_offset_bits + numExpr*expr_size_bits + exprExSexpStr_offset_bits + index1*8);
	    /*
        int offset = 192;
        if (index1 < 0 || index1 >= 8) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * 8;
        return offset;*/
    }

    /**
     * Return the entire array 'u.expr.ex.sexp.s' as a byte[]
     */
    public byte[] get_u_expr_ex_sexp_s(int numExpr) {
        byte[] tmp = new byte[8];
        for (int index0 = 0; index0 < numElements_u_expr_ex_sexp_s(0); index0++) {
            tmp[index0] = getElement_u_expr_ex_sexp_s(numExpr,index0);
        }
        return tmp;
    }

    /**
     * Set the contents of the array 'u.expr.ex.sexp.s' from the given byte[]
     */
    public void set_u_expr_ex_sexp_s(int numExpr,byte[] value) {
        for (int index0 = 0; index0 < value.length; index0++) {
            setElement_u_expr_ex_sexp_s(numExpr,index0, value[index0]);
        }
    }

    /**
     * Return an element (as a byte) of the array 'u.expr.ex.sexp.s'
     */
    public byte getElement_u_expr_ex_sexp_s(int numExpr,int index1) {
        return (byte)getSIntElement(offsetBits_u_expr_ex_sexp_s(numExpr,index1), 8);
    }

    /**
     * Set an element of the array 'u.expr.ex.sexp.s'
     */
    public void setElement_u_expr_ex_sexp_s(int numExpr,int index1, byte value) {
        setSIntElement(offsetBits_u_expr_ex_sexp_s(numExpr,index1), 8, value);
    }

    /**
     * Return the total size, in bytes, of the array 'u.expr.ex.sexp.s'
     */
    public static int totalSize_u_expr_ex_sexp_s() {
        return exprExSexpStr_size_bits/8;//8;(64 / 8);
    }

    /**
     * Return the total size, in bits, of the array 'u.expr.ex.sexp.s'
     */
    public static int totalSizeBits_u_expr_ex_sexp_s() {
        return exprExSexpStr_size_bits;//64;
    }

    /**
     * Return the size, in bytes, of each element of the array 'u.expr.ex.sexp.s'
     */
    public static int elementSize_u_expr_ex_sexp_s() {
        return (8 / 8);
    }

    /**
     * Return the size, in bits, of each element of the array 'u.expr.ex.sexp.s'
     */
    public static int elementSizeBits_u_expr_ex_sexp_s() {
        return 8;
    }

    /**
     * Return the number of dimensions in the array 'u.expr.ex.sexp.s'
     */
    public static int numDimensions_u_expr_ex_sexp_s() {
        return 1;
    }

    /**
     * Return the number of elements in the array 'u.expr.ex.sexp.s'
     */
    public static int numElements_u_expr_ex_sexp_s() {
        return exprExSexpStr_size_bits/8;//8;
    }

    /**
     * Return the number of elements in the array 'u.expr.ex.sexp.s'
     * for the given dimension.
     */
    public static int numElements_u_expr_ex_sexp_s(int dimension) {
    	
      int array_dims[] = { exprExSexpStr_size_bits/8,  };//8
        if (dimension < 0 || dimension >= 1) throw new ArrayIndexOutOfBoundsException();
        if (array_dims[dimension] == 0) throw new IllegalArgumentException("Array dimension "+dimension+" has unknown size");
        return array_dims[dimension];
    }

    /**
     * Fill in the array 'u.expr.ex.sexp.s' with a String
     */
    public void setString_u_expr_ex_sexp_s(int numExpr,String s) { 
         int len = s.length();
         int i;
         for (i = 0; i < len; i++) {
             setElement_u_expr_ex_sexp_s(numExpr,i, (byte)s.charAt(i));
         }
         setElement_u_expr_ex_sexp_s(numExpr,i, (byte)0); //null terminate
    }

    /**
     * Read the array 'u.expr.ex.sexp.s' as a String
     */
    public String getString_u_expr_ex_sexp_s(int numExpr) { 
         char carr[] = new char[Math.min(net.tinyos.message.Message.MAX_CONVERTED_STRING_LENGTH,8)];
         int i;
         for (i = 0; i < carr.length; i++) {
             if ((char)getElement_u_expr_ex_sexp_s( numExpr,i) == (char)0) break;
             carr[i] = (char)getElement_u_expr_ex_sexp_s(numExpr,i);
         }
         return new String(carr,0,i);
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.fieldOp
    //   Field type: short
    //   Offset (bits): 272
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.fieldOp' is signed (false).
     */
    public static boolean isSigned_u_expr_fieldOp() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.fieldOp' is an array (false).
     */
    public static boolean isArray_u_expr_fieldOp() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.fieldOp'
     */
    public static int offset_u_expr_fieldOp() {
        return exprUExprFieldOp_offset_bits/8;//(272 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.fieldOp'
     */
    public static int offsetBits_u_expr_fieldOp() {
        return exprUExprFieldOp_offset_bits;//272;
    }

    /**
     * Return the value (as a short) of the field 'u.expr.fieldOp'
     */
    public short get_u_expr_fieldOp(int numExpr) {
    	if(numExpr<maxExprs)
        	return (short)getSIntElement(offsetBits_u_expr_fieldOp()+ numExpr*exprUExprFieldOp_size_bits, exprUExprFieldOp_size_bits);
        else 
        	return 0;
    }

    /**
     * Set the value of the field 'u.expr.fieldOp'
     */
    public void set_u_expr_fieldOp(int numExpr, short value) {
    	if(numExpr<maxExprs)
        	setSIntElement(offsetBits_u_expr_fieldOp()+ numExpr*exprUExprFieldOp_size_bits, exprUExprFieldOp_size_bits, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.fieldOp'
     */
    public static int size_u_expr_fieldOp() {
        return (exprUExprFieldOp_size_bits / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.fieldOp'
     */
    public static int sizeBits_u_expr_fieldOp() {
        return exprUExprFieldOp_size_bits;//16
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.fieldConst
    //   Field type: short
    //   Offset (bits): 288
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.fieldConst' is signed (false).
     */
    public static boolean isSigned_u_expr_fieldConst() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.fieldConst' is an array (false).
     */
    public static boolean isArray_u_expr_fieldConst() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.fieldConst'
     */
    public static int offset_u_expr_fieldConst() {
        return exprUExprFieldConst_offset_bits/8;//(288 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.fieldConst'
     */
    public static int offsetBits_u_expr_fieldConst() {
        return exprUExprFieldConst_offset_bits;//288;
    }

    /**
     * Return the value (as a short) of the field 'u.expr.fieldConst'
     */
    public short get_u_expr_fieldConst(int numExpr) {
        return (short)getSIntElement(offsetBits_u_expr_fieldConst(), exprUExprFieldConst_size_bits);//temp this way
    }

    /**
     * Set the value of the field 'u.expr.fieldConst'
     */
    public void set_u_expr_fieldConst(short value) {
        setSIntElement(offsetBits_u_expr_fieldConst(), exprUExprFieldConst_size_bits, value);//temp this way
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.fieldConst'
     */
    public static int size_u_expr_fieldConst() {
        return (16 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.fieldConst'
     */
    public static int sizeBits_u_expr_fieldConst() {
        return 16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.opState
    //   Field type: int
    //   Offset (bits): 304
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.expr.opState' is signed (false).
     */
    public static boolean isSigned_u_expr_opState() {
        return false;
    }

    /**
     * Return whether the field 'u.expr.opState' is an array (false).
     */
    public static boolean isArray_u_expr_opState() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.expr.opState'
     */
    public static int offset_u_expr_opState() {
        return (304 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.opState'
     */
    public static int offsetBits_u_expr_opState() {
        return 304;
    }

    /**
     * Return the value (as a int) of the field 'u.expr.opState'
     */
    public int get_u_expr_opState() {
        return (int)getUIntElement(offsetBits_u_expr_opState(), 16);
    }

    /**
     * Set the value of the field 'u.expr.opState'
     */
    public void set_u_expr_opState(int value) {
        setUIntElement(offsetBits_u_expr_opState(), 16, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.opState'
     */
    public static int size_u_expr_opState() {
        return (16 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.expr.opState'
     */
    public static int sizeBits_u_expr_opState() {
        return 16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.buf.cmd.name
    //   Field type: byte[]
    //   Offset (bits): 152
    //   Size of each element (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.buf.cmd.name' is signed (false).
     */
    public static boolean isSigned_u_buf_cmd_name() {
        return false;
    }

    /**
     * Return whether the field 'u.buf.cmd.name' is an array (true).
     */
    public static boolean isArray_u_buf_cmd_name() {
        return true;
    }

    /**
     * Return the offset (in bytes) of the field 'u.buf.cmd.name'
     */
    public static int offset_u_buf_cmd_name(int index1) {
        int offset = 152;
        if (index1 < 0 || index1 >= 8) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * 8;
        return (offset / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.buf.cmd.name'
     */
    public static int offsetBits_u_buf_cmd_name(int index1) {
        int offset = 152;
        if (index1 < 0 || index1 >= 8) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * 8;
        return offset;
    }

    /**
     * Return the entire array 'u.buf.cmd.name' as a byte[]
     */
    public byte[] get_u_buf_cmd_name() {
        byte[] tmp = new byte[8];
        for (int index0 = 0; index0 < numElements_u_buf_cmd_name(0); index0++) {
            tmp[index0] = getElement_u_buf_cmd_name(index0);
        }
        return tmp;
    }

    /**
     * Set the contents of the array 'u.buf.cmd.name' from the given byte[]
     */
    public void set_u_buf_cmd_name(byte[] value) {
        for (int index0 = 0; index0 < value.length; index0++) {
            setElement_u_buf_cmd_name(index0, value[index0]);
        }
    }

    /**
     * Return an element (as a byte) of the array 'u.buf.cmd.name'
     */
    public byte getElement_u_buf_cmd_name(int index1) {
        return (byte)getSIntElement(offsetBits_u_buf_cmd_name(index1), 8);
    }

    /**
     * Set an element of the array 'u.buf.cmd.name'
     */
    public void setElement_u_buf_cmd_name(int index1, byte value) {
        setSIntElement(offsetBits_u_buf_cmd_name(index1), 8, value);
    }

    /**
     * Return the total size, in bytes, of the array 'u.buf.cmd.name'
     */
    public static int totalSize_u_buf_cmd_name() {
        return (64 / 8);
    }

    /**
     * Return the total size, in bits, of the array 'u.buf.cmd.name'
     */
    public static int totalSizeBits_u_buf_cmd_name() {
        return 64;
    }

    /**
     * Return the size, in bytes, of each element of the array 'u.buf.cmd.name'
     */
    public static int elementSize_u_buf_cmd_name() {
        return (8 / 8);
    }

    /**
     * Return the size, in bits, of each element of the array 'u.buf.cmd.name'
     */
    public static int elementSizeBits_u_buf_cmd_name() {
        return 8;
    }

    /**
     * Return the number of dimensions in the array 'u.buf.cmd.name'
     */
    public static int numDimensions_u_buf_cmd_name() {
        return 1;
    }

    /**
     * Return the number of elements in the array 'u.buf.cmd.name'
     */
    public static int numElements_u_buf_cmd_name() {
        return 8;
    }

    /**
     * Return the number of elements in the array 'u.buf.cmd.name'
     * for the given dimension.
     */
    public static int numElements_u_buf_cmd_name(int dimension) {
      int array_dims[] = { 8,  };
        if (dimension < 0 || dimension >= 1) throw new ArrayIndexOutOfBoundsException();
        if (array_dims[dimension] == 0) throw new IllegalArgumentException("Array dimension "+dimension+" has unknown size");
        return array_dims[dimension];
    }

    /**
     * Fill in the array 'u.buf.cmd.name' with a String
     */
    public void setString_u_buf_cmd_name(String s) { 
         int len = s.length();
         int i;
         for (i = 0; i < len; i++) {
             setElement_u_buf_cmd_name(i, (byte)s.charAt(i));
         }
         setElement_u_buf_cmd_name(i, (byte)0); //null terminate
    }

    /**
     * Read the array 'u.buf.cmd.name' as a String
     */
    public String getString_u_buf_cmd_name() { 
         char carr[] = new char[Math.min(net.tinyos.message.Message.MAX_CONVERTED_STRING_LENGTH,8)];
         int i;
         for (i = 0; i < carr.length; i++) {
             if ((char)getElement_u_buf_cmd_name(i) == (char)0) break;
             carr[i] = (char)getElement_u_buf_cmd_name(i);
         }
         return new String(carr,0,i);
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.buf.cmd.hasParam
    //   Field type: short
    //   Offset (bits): 216
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.buf.cmd.hasParam' is signed (false).
     */
    public static boolean isSigned_u_buf_cmd_hasParam() {
        return false;
    }

    /**
     * Return whether the field 'u.buf.cmd.hasParam' is an array (false).
     */
    public static boolean isArray_u_buf_cmd_hasParam() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.buf.cmd.hasParam'
     */
    public static int offset_u_buf_cmd_hasParam() {
        return (216 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.buf.cmd.hasParam'
     */
    public static int offsetBits_u_buf_cmd_hasParam() {
        return 216;
    }

    /**
     * Return the value (as a short) of the field 'u.buf.cmd.hasParam'
     */
    public short get_u_buf_cmd_hasParam() {
        return (short)getUIntElement(offsetBits_u_buf_cmd_hasParam(), 8);
    }

    /**
     * Set the value of the field 'u.buf.cmd.hasParam'
     */
    public void set_u_buf_cmd_hasParam(short value) {
        setUIntElement(offsetBits_u_buf_cmd_hasParam(), 8, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.buf.cmd.hasParam'
     */
    public static int size_u_buf_cmd_hasParam() {
        return (8 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.buf.cmd.hasParam'
     */
    public static int sizeBits_u_buf_cmd_hasParam() {
        return 8;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.buf.cmd.param
    //   Field type: short
    //   Offset (bits): 224
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.buf.cmd.param' is signed (false).
     */
    public static boolean isSigned_u_buf_cmd_param() {
        return false;
    }

    /**
     * Return whether the field 'u.buf.cmd.param' is an array (false).
     */
    public static boolean isArray_u_buf_cmd_param() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.buf.cmd.param'
     */
    public static int offset_u_buf_cmd_param() {
        return (224 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.buf.cmd.param'
     */
    public static int offsetBits_u_buf_cmd_param() {
        return 224;
    }

    /**
     * Return the value (as a short) of the field 'u.buf.cmd.param'
     */
    public short get_u_buf_cmd_param() {
        return (short)getSIntElement(offsetBits_u_buf_cmd_param(), 16);
    }

    /**
     * Set the value of the field 'u.buf.cmd.param'
     */
    public void set_u_buf_cmd_param(short value) {
        setSIntElement(offsetBits_u_buf_cmd_param(), 16, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.buf.cmd.param'
     */
    public static int size_u_buf_cmd_param() {
        return (16 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.buf.cmd.param'
     */
    public static int sizeBits_u_buf_cmd_param() {
        return 16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.buf.ram.hasOutput
    //   Field type: byte
    //   Offset (bits): 152
    //   Size (bits): 1
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.buf.ram.hasOutput' is signed (false).
     */
    public static boolean isSigned_u_buf_ram_hasOutput() {
        return false;
    }

    /**
     * Return whether the field 'u.buf.ram.hasOutput' is an array (false).
     */
    public static boolean isArray_u_buf_ram_hasOutput() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.buf.ram.hasOutput'
     */
    public static int offset_u_buf_ram_hasOutput() {
        return (152 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.buf.ram.hasOutput'
     */
    public static int offsetBits_u_buf_ram_hasOutput() {
        return 152;
    }

    /**
     * Return the value (as a byte) of the field 'u.buf.ram.hasOutput'
     */
    public byte get_u_buf_ram_hasOutput() {
        return (byte)getUIntElement(offsetBits_u_buf_ram_hasOutput(), 1);
    }

    /**
     * Set the value of the field 'u.buf.ram.hasOutput'
     */
    public void set_u_buf_ram_hasOutput(byte value) {
        setUIntElement(offsetBits_u_buf_ram_hasOutput(), 1, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.buf.ram.hasOutput'
     * WARNING: This field is not an even-sized number of bytes (1 bits).
     */
    public static int size_u_buf_ram_hasOutput() {
        return (1 / 8) + 1;
    }

    /**
     * Return the size, in bits, of the field 'u.buf.ram.hasOutput'
     */
    public static int sizeBits_u_buf_ram_hasOutput() {
        return 1;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.buf.ram.hasInput
    //   Field type: byte
    //   Offset (bits): 153
    //   Size (bits): 1
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.buf.ram.hasInput' is signed (false).
     */
    public static boolean isSigned_u_buf_ram_hasInput() {
        return false;
    }

    /**
     * Return whether the field 'u.buf.ram.hasInput' is an array (false).
     */
    public static boolean isArray_u_buf_ram_hasInput() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.buf.ram.hasInput'
     * WARNING: This field is not byte-aligned (bit offset 153).
     */
    public static int offset_u_buf_ram_hasInput() {
        return (153 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.buf.ram.hasInput'
     */
    public static int offsetBits_u_buf_ram_hasInput() {
        return 153;
    }

    /**
     * Return the value (as a byte) of the field 'u.buf.ram.hasInput'
     */
    public byte get_u_buf_ram_hasInput() {
        return (byte)getUIntElement(offsetBits_u_buf_ram_hasInput(), 1);
    }

    /**
     * Set the value of the field 'u.buf.ram.hasInput'
     */
    public void set_u_buf_ram_hasInput(byte value) {
        setUIntElement(offsetBits_u_buf_ram_hasInput(), 1, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.buf.ram.hasInput'
     * WARNING: This field is not an even-sized number of bytes (1 bits).
     */
    public static int size_u_buf_ram_hasInput() {
        return (1 / 8) + 1;
    }

    /**
     * Return the size, in bits, of the field 'u.buf.ram.hasInput'
     */
    public static int sizeBits_u_buf_ram_hasInput() {
        return 1;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.buf.ram.create
    //   Field type: byte
    //   Offset (bits): 154
    //   Size (bits): 1
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.buf.ram.create' is signed (false).
     */
    public static boolean isSigned_u_buf_ram_create() {
        return false;
    }

    /**
     * Return whether the field 'u.buf.ram.create' is an array (false).
     */
    public static boolean isArray_u_buf_ram_create() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.buf.ram.create'
     * WARNING: This field is not byte-aligned (bit offset 154).
     */
    public static int offset_u_buf_ram_create() {
        return (154 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.buf.ram.create'
     */
    public static int offsetBits_u_buf_ram_create() {
        return 154;
    }

    /**
     * Return the value (as a byte) of the field 'u.buf.ram.create'
     */
    public byte get_u_buf_ram_create() {
        return (byte)getUIntElement(offsetBits_u_buf_ram_create(), 1);
    }

    /**
     * Set the value of the field 'u.buf.ram.create'
     */
    public void set_u_buf_ram_create(byte value) {
        setUIntElement(offsetBits_u_buf_ram_create(), 1, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.buf.ram.create'
     * WARNING: This field is not an even-sized number of bytes (1 bits).
     */
    public static int size_u_buf_ram_create() {
        return (1 / 8) + 1;
    }

    /**
     * Return the size, in bits, of the field 'u.buf.ram.create'
     */
    public static int sizeBits_u_buf_ram_create() {
        return 1;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.buf.ram.numRows
    //   Field type: short
    //   Offset (bits): 155
    //   Size (bits): 13
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.buf.ram.numRows' is signed (false).
     */
    public static boolean isSigned_u_buf_ram_numRows() {
        return false;
    }

    /**
     * Return whether the field 'u.buf.ram.numRows' is an array (false).
     */
    public static boolean isArray_u_buf_ram_numRows() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.buf.ram.numRows'
     * WARNING: This field is not byte-aligned (bit offset 155).
     */
    public static int offset_u_buf_ram_numRows() {
        return (155 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.buf.ram.numRows'
     */
    public static int offsetBits_u_buf_ram_numRows() {
        return 155;
    }

    /**
     * Return the value (as a short) of the field 'u.buf.ram.numRows'
     */
    public short get_u_buf_ram_numRows() {
        return (short)getUIntElement(offsetBits_u_buf_ram_numRows(), 13);
    }

    /**
     * Set the value of the field 'u.buf.ram.numRows'
     */
    public void set_u_buf_ram_numRows(short value) {
        setUIntElement(offsetBits_u_buf_ram_numRows(), 13, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.buf.ram.numRows'
     * WARNING: This field is not an even-sized number of bytes (13 bits).
     */
    public static int size_u_buf_ram_numRows() {
        return (13 / 8) + 1;
    }

    /**
     * Return the size, in bits, of the field 'u.buf.ram.numRows'
     */
    public static int sizeBits_u_buf_ram_numRows() {
        return 13;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.buf.ram.outBufName
    //   Field type: byte[]
    //   Offset (bits): 168
    //   Size of each element (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.buf.ram.outBufName' is signed (false).
     */
    public static boolean isSigned_u_buf_ram_outBufName() {
        return false;
    }

    /**
     * Return whether the field 'u.buf.ram.outBufName' is an array (true).
     */
    public static boolean isArray_u_buf_ram_outBufName() {
        return true;
    }

    /**
     * Return the offset (in bytes) of the field 'u.buf.ram.outBufName'
     */
    public static int offset_u_buf_ram_outBufName(int index1) {
        int offset = 168;
        if (index1 < 0 || index1 >= 8) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * 8;
        return (offset / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.buf.ram.outBufName'
     */
    public static int offsetBits_u_buf_ram_outBufName(int index1) {
        int offset = 168;
        if (index1 < 0 || index1 >= 8) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * 8;
        return offset;
    }

    /**
     * Return the entire array 'u.buf.ram.outBufName' as a byte[]
     */
    public byte[] get_u_buf_ram_outBufName() {
        byte[] tmp = new byte[8];
        for (int index0 = 0; index0 < numElements_u_buf_ram_outBufName(0); index0++) {
            tmp[index0] = getElement_u_buf_ram_outBufName(index0);
        }
        return tmp;
    }

    /**
     * Set the contents of the array 'u.buf.ram.outBufName' from the given byte[]
     */
    public void set_u_buf_ram_outBufName(byte[] value) {
        for (int index0 = 0; index0 < value.length; index0++) {
            setElement_u_buf_ram_outBufName(index0, value[index0]);
        }
    }

    /**
     * Return an element (as a byte) of the array 'u.buf.ram.outBufName'
     */
    public byte getElement_u_buf_ram_outBufName(int index1) {
        return (byte)getSIntElement(offsetBits_u_buf_ram_outBufName(index1), 8);
    }

    /**
     * Set an element of the array 'u.buf.ram.outBufName'
     */
    public void setElement_u_buf_ram_outBufName(int index1, byte value) {
        setSIntElement(offsetBits_u_buf_ram_outBufName(index1), 8, value);
    }

    /**
     * Return the total size, in bytes, of the array 'u.buf.ram.outBufName'
     */
    public static int totalSize_u_buf_ram_outBufName() {
        return (64 / 8);
    }

    /**
     * Return the total size, in bits, of the array 'u.buf.ram.outBufName'
     */
    public static int totalSizeBits_u_buf_ram_outBufName() {
        return 64;
    }

    /**
     * Return the size, in bytes, of each element of the array 'u.buf.ram.outBufName'
     */
    public static int elementSize_u_buf_ram_outBufName() {
        return (8 / 8);
    }

    /**
     * Return the size, in bits, of each element of the array 'u.buf.ram.outBufName'
     */
    public static int elementSizeBits_u_buf_ram_outBufName() {
        return 8;
    }

    /**
     * Return the number of dimensions in the array 'u.buf.ram.outBufName'
     */
    public static int numDimensions_u_buf_ram_outBufName() {
        return 1;
    }

    /**
     * Return the number of elements in the array 'u.buf.ram.outBufName'
     */
    public static int numElements_u_buf_ram_outBufName() {
        return 8;
    }

    /**
     * Return the number of elements in the array 'u.buf.ram.outBufName'
     * for the given dimension.
     */
    public static int numElements_u_buf_ram_outBufName(int dimension) {
      int array_dims[] = { 8,  };
        if (dimension < 0 || dimension >= 1) throw new ArrayIndexOutOfBoundsException();
        if (array_dims[dimension] == 0) throw new IllegalArgumentException("Array dimension "+dimension+" has unknown size");
        return array_dims[dimension];
    }

    /**
     * Fill in the array 'u.buf.ram.outBufName' with a String
     */
    public void setString_u_buf_ram_outBufName(String s) { 
         int len = s.length();
         int i;
         for (i = 0; i < len; i++) {
             setElement_u_buf_ram_outBufName(i, (byte)s.charAt(i));
         }
         setElement_u_buf_ram_outBufName(i, (byte)0); //null terminate
    }

    /**
     * Read the array 'u.buf.ram.outBufName' as a String
     */
    public String getString_u_buf_ram_outBufName() { 
         char carr[] = new char[Math.min(net.tinyos.message.Message.MAX_CONVERTED_STRING_LENGTH,8)];
         int i;
         for (i = 0; i < carr.length; i++) {
             if ((char)getElement_u_buf_ram_outBufName(i) == (char)0) break;
             carr[i] = (char)getElement_u_buf_ram_outBufName(i);
         }
         return new String(carr,0,i);
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.buf.ram.inBufName
    //   Field type: byte[]
    //   Offset (bits): 232
    //   Size of each element (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.buf.ram.inBufName' is signed (false).
     */
    public static boolean isSigned_u_buf_ram_inBufName() {
        return false;
    }

    /**
     * Return whether the field 'u.buf.ram.inBufName' is an array (true).
     */
    public static boolean isArray_u_buf_ram_inBufName() {
        return true;
    }

    /**
     * Return the offset (in bytes) of the field 'u.buf.ram.inBufName'
     */
    public static int offset_u_buf_ram_inBufName(int index1) {
        int offset = 232;
        if (index1 < 0 || index1 >= 8) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * 8;
        return (offset / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.buf.ram.inBufName'
     */
    public static int offsetBits_u_buf_ram_inBufName(int index1) {
        int offset = 232;
        if (index1 < 0 || index1 >= 8) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * 8;
        return offset;
    }

    /**
     * Return the entire array 'u.buf.ram.inBufName' as a byte[]
     */
    public byte[] get_u_buf_ram_inBufName() {
        byte[] tmp = new byte[8];
        for (int index0 = 0; index0 < numElements_u_buf_ram_inBufName(0); index0++) {
            tmp[index0] = getElement_u_buf_ram_inBufName(index0);
        }
        return tmp;
    }

    /**
     * Set the contents of the array 'u.buf.ram.inBufName' from the given byte[]
     */
    public void set_u_buf_ram_inBufName(byte[] value) {
        for (int index0 = 0; index0 < value.length; index0++) {
            setElement_u_buf_ram_inBufName(index0, value[index0]);
        }
    }

    /**
     * Return an element (as a byte) of the array 'u.buf.ram.inBufName'
     */
    public byte getElement_u_buf_ram_inBufName(int index1) {
        return (byte)getSIntElement(offsetBits_u_buf_ram_inBufName(index1), 8);
    }

    /**
     * Set an element of the array 'u.buf.ram.inBufName'
     */
    public void setElement_u_buf_ram_inBufName(int index1, byte value) {
        setSIntElement(offsetBits_u_buf_ram_inBufName(index1), 8, value);
    }

    /**
     * Return the total size, in bytes, of the array 'u.buf.ram.inBufName'
     */
    public static int totalSize_u_buf_ram_inBufName() {
        return (64 / 8);
    }

    /**
     * Return the total size, in bits, of the array 'u.buf.ram.inBufName'
     */
    public static int totalSizeBits_u_buf_ram_inBufName() {
        return 64;
    }

    /**
     * Return the size, in bytes, of each element of the array 'u.buf.ram.inBufName'
     */
    public static int elementSize_u_buf_ram_inBufName() {
        return (8 / 8);
    }

    /**
     * Return the size, in bits, of each element of the array 'u.buf.ram.inBufName'
     */
    public static int elementSizeBits_u_buf_ram_inBufName() {
        return 8;
    }

    /**
     * Return the number of dimensions in the array 'u.buf.ram.inBufName'
     */
    public static int numDimensions_u_buf_ram_inBufName() {
        return 1;
    }

    /**
     * Return the number of elements in the array 'u.buf.ram.inBufName'
     */
    public static int numElements_u_buf_ram_inBufName() {
        return 8;
    }

    /**
     * Return the number of elements in the array 'u.buf.ram.inBufName'
     * for the given dimension.
     */
    public static int numElements_u_buf_ram_inBufName(int dimension) {
      int array_dims[] = { 8,  };
        if (dimension < 0 || dimension >= 1) throw new ArrayIndexOutOfBoundsException();
        if (array_dims[dimension] == 0) throw new IllegalArgumentException("Array dimension "+dimension+" has unknown size");
        return array_dims[dimension];
    }

    /**
     * Fill in the array 'u.buf.ram.inBufName' with a String
     */
    public void setString_u_buf_ram_inBufName(String s) { 
         int len = s.length();
         int i;
         for (i = 0; i < len; i++) {
             setElement_u_buf_ram_inBufName(i, (byte)s.charAt(i));
         }
         setElement_u_buf_ram_inBufName(i, (byte)0); //null terminate
    }

    /**
     * Read the array 'u.buf.ram.inBufName' as a String
     */
    public String getString_u_buf_ram_inBufName() { 
         char carr[] = new char[Math.min(net.tinyos.message.Message.MAX_CONVERTED_STRING_LENGTH,8)];
         int i;
         for (i = 0; i < carr.length; i++) {
             if ((char)getElement_u_buf_ram_inBufName(i) == (char)0) break;
             carr[i] = (char)getElement_u_buf_ram_inBufName(i);
         }
         return new String(carr,0,i);
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.buf.ram.policy
    //   Field type: short
    //   Offset (bits): 296
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.buf.ram.policy' is signed (false).
     */
    public static boolean isSigned_u_buf_ram_policy() {
        return false;
    }

    /**
     * Return whether the field 'u.buf.ram.policy' is an array (false).
     */
    public static boolean isArray_u_buf_ram_policy() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.buf.ram.policy'
     */
    public static int offset_u_buf_ram_policy() {
        return (296 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.buf.ram.policy'
     */
    public static int offsetBits_u_buf_ram_policy() {
        return 296;
    }

    /**
     * Return the value (as a short) of the field 'u.buf.ram.policy'
     */
    public short get_u_buf_ram_policy() {
        return (short)getSIntElement(offsetBits_u_buf_ram_policy(), 16);
    }

    /**
     * Set the value of the field 'u.buf.ram.policy'
     */
    public void set_u_buf_ram_policy(short value) {
        setSIntElement(offsetBits_u_buf_ram_policy(), 16, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.buf.ram.policy'
     */
    public static int size_u_buf_ram_policy() {
        return (16 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.buf.ram.policy'
     */
    public static int sizeBits_u_buf_ram_policy() {
        return 16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.eventName
    //   Field type: byte[]
    //   Offset (bits): 152
    //   Size of each element (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.eventName' is signed (false).
     */
    public static boolean isSigned_u_eventName() {
        return false;
    }

    /**
     * Return whether the field 'u.eventName' is an array (true).
     */
    public static boolean isArray_u_eventName() {
        return true;
    }

    /**
     * Return the offset (in bytes) of the field 'u.eventName'
     */
    public static int offset_u_eventName(int index1) {
        int offset = 152;
        if (index1 < 0 || index1 >= 8) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * 8;
        return (offset / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.eventName'
     */
    public static int offsetBits_u_eventName(int index1) {
        int offset = 152;
        if (index1 < 0 || index1 >= 8) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * 8;
        return offset;
    }

    /**
     * Return the entire array 'u.eventName' as a byte[]
     */
    public byte[] get_u_eventName() {
        byte[] tmp = new byte[8];
        for (int index0 = 0; index0 < numElements_u_eventName(0); index0++) {
            tmp[index0] = getElement_u_eventName(index0);
        }
        return tmp;
    }

    /**
     * Set the contents of the array 'u.eventName' from the given byte[]
     */
    public void set_u_eventName(byte[] value) {
        for (int index0 = 0; index0 < value.length; index0++) {
            setElement_u_eventName(index0, value[index0]);
        }
    }

    /**
     * Return an element (as a byte) of the array 'u.eventName'
     */
    public byte getElement_u_eventName(int index1) {
        return (byte)getSIntElement(offsetBits_u_eventName(index1), 8);
    }

    /**
     * Set an element of the array 'u.eventName'
     */
    public void setElement_u_eventName(int index1, byte value) {
        setSIntElement(offsetBits_u_eventName(index1), 8, value);
    }

    /**
     * Return the total size, in bytes, of the array 'u.eventName'
     */
    public static int totalSize_u_eventName() {
        return (64 / 8);
    }

    /**
     * Return the total size, in bits, of the array 'u.eventName'
     */
    public static int totalSizeBits_u_eventName() {
        return 64;
    }

    /**
     * Return the size, in bytes, of each element of the array 'u.eventName'
     */
    public static int elementSize_u_eventName() {
        return (8 / 8);
    }

    /**
     * Return the size, in bits, of each element of the array 'u.eventName'
     */
    public static int elementSizeBits_u_eventName() {
        return 8;
    }

    /**
     * Return the number of dimensions in the array 'u.eventName'
     */
    public static int numDimensions_u_eventName() {
        return 1;
    }

    /**
     * Return the number of elements in the array 'u.eventName'
     */
    public static int numElements_u_eventName() {
        return 8;
    }

    /**
     * Return the number of elements in the array 'u.eventName'
     * for the given dimension.
     */
    public static int numElements_u_eventName(int dimension) {
      int array_dims[] = { 8,  };
        if (dimension < 0 || dimension >= 1) throw new ArrayIndexOutOfBoundsException();
        if (array_dims[dimension] == 0) throw new IllegalArgumentException("Array dimension "+dimension+" has unknown size");
        return array_dims[dimension];
    }

    /**
     * Fill in the array 'u.eventName' with a String
     */
    public void setString_u_eventName(String s) { 
         int len = s.length();
         int i;
         for (i = 0; i < len; i++) {
             setElement_u_eventName(i, (byte)s.charAt(i));
         }
         setElement_u_eventName(i, (byte)0); //null terminate
    }

    /**
     * Read the array 'u.eventName' as a String
     */
    public String getString_u_eventName() { 
         char carr[] = new char[Math.min(net.tinyos.message.Message.MAX_CONVERTED_STRING_LENGTH,8)];
         int i;
         for (i = 0; i < carr.length; i++) {
             if ((char)getElement_u_eventName(i) == (char)0) break;
             carr[i] = (char)getElement_u_eventName(i);
         }
         return new String(carr,0,i);
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.numEpochs
    //   Field type: short
    //   Offset (bits): 152
    //   Size (bits): 16
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.numEpochs' is signed (false).
     */
    public static boolean isSigned_u_numEpochs() {
        return false;
    }

    /**
     * Return whether the field 'u.numEpochs' is an array (false).
     */
    public static boolean isArray_u_numEpochs() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.numEpochs'
     */
    public static int offset_u_numEpochs() {
        return (152 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.numEpochs'
     */
    public static int offsetBits_u_numEpochs() {
        return 152;
    }

    /**
     * Return the value (as a short) of the field 'u.numEpochs'
     */
    public short get_u_numEpochs() {
        return (short)getSIntElement(offsetBits_u_numEpochs(), 16);
    }

    /**
     * Set the value of the field 'u.numEpochs'
     */
    public void set_u_numEpochs(short value) {
        setSIntElement(offsetBits_u_numEpochs(), 16, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.numEpochs'
     */
    public static int size_u_numEpochs() {
        return (16 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.numEpochs'
     */
    public static int sizeBits_u_numEpochs() {
        return 16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.ttl
    //   Field type: byte
    //   Offset (bits): 152
    //   Size (bits): 8
    /////////////////////////////////////////////////////////

    /**
     * Return whether the field 'u.ttl' is signed (false).
     */
    public static boolean isSigned_u_ttl() {
        return false;
    }

    /**
     * Return whether the field 'u.ttl' is an array (false).
     */
    public static boolean isArray_u_ttl() {
        return false;
    }

    /**
     * Return the offset (in bytes) of the field 'u.ttl'
     */
    public static int offset_u_ttl() {
        return (152 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.ttl'
     */
    public static int offsetBits_u_ttl() {
        return 152;
    }

    /**
     * Return the value (as a byte) of the field 'u.ttl'
     */
    public byte get_u_ttl() {
        return (byte)getSIntElement(offsetBits_u_ttl(), 8);
    }

    /**
     * Set the value of the field 'u.ttl'
     */
    public void set_u_ttl(byte value) {
        setSIntElement(offsetBits_u_ttl(), 8, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.ttl'
     */
    public static int size_u_ttl() {
        return (8 / 8);
    }

    /**
     * Return the size, in bits, of the field 'u.ttl'
     */
    public static int sizeBits_u_ttl() {
        return 8;
    }
	
	 public byte get_relOps(int index) {
        return (byte)getUIntElement(relOps_offset_bits+index*relOps_size_bits, relOps_size_bits);
    }

    /**
     * Set the value of the field 'u.ttl'
     */
    public void set_relOps(int index,byte value) {
        setUIntElement(relOps_offset_bits+index*relOps_size_bits, relOps_size_bits, value);
    }

}
