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

package net.tinyos.tinydb;

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

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

    /** The Active Message type associated with this message. */
    public static final int AM_TYPE = 101;

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

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

    /**
     * Create a new QueryMsg with the given data_length
     * and base offset.
     */
    public QueryMsg(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 QueryMsg(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 QueryMsg(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 QueryMsg(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 QueryMsg(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 QueryMsg(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())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [fwdNode=0x"+Long.toHexString(get_fwdNode())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [msgType=0x"+Long.toHexString(get_msgType())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [numFields=0x"+Long.toHexString(get_numFields())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [numExprs=0x"+Long.toHexString(get_numExprs())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [fromBuffer=0x"+Long.toHexString(get_fromBuffer())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [fromCatalogBuffer=0x"+Long.toHexString(get_fromCatalogBuffer())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [hasEvent=0x"+Long.toHexString(get_hasEvent())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [hasForClause=0x"+Long.toHexString(get_hasForClause())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [bufferType=0x"+Long.toHexString(get_bufferType())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [epochDuration=0x"+Long.toHexString(get_epochDuration())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [type=0x"+Long.toHexString(get_type())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [idx=0x"+Long.toHexString(get_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 i = 0; i < 8; i++) {
          s += "0x"+Long.toHexString(getElement_u_field_name(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 */ }
      try {
        s += "  [u.field.type=0x"+Long.toHexString(get_u_field_type())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.expr.opType=0x"+Long.toHexString(get_u_expr_opType())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.expr.isStringExp=0x"+Long.toHexString(get_u_expr_isStringExp())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.expr.success=0x"+Long.toHexString(get_u_expr_success())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.expr.idx=0x"+Long.toHexString(get_u_expr_idx())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.expr.ex.opval.field=0x"+Long.toHexString(get_u_expr_ex_opval_field())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.expr.ex.opval.op=0x"+Long.toHexString(get_u_expr_ex_opval_op())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.expr.ex.opval.value=0x"+Long.toHexString(get_u_expr_ex_opval_value())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.expr.ex.agg.field=0x"+Long.toHexString(get_u_expr_ex_agg_field())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.expr.ex.agg.groupingField=0x"+Long.toHexString(get_u_expr_ex_agg_groupingField())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.expr.ex.agg.groupFieldOp=0x"+Long.toHexString(get_u_expr_ex_agg_groupFieldOp())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.expr.ex.agg.groupFieldConst=0x"+Long.toHexString(get_u_expr_ex_agg_groupFieldConst())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.expr.ex.agg.op=0x"+Long.toHexString(get_u_expr_ex_agg_op())+"]\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 {
        s += "  [u.expr.fieldOp=0x"+Long.toHexString(get_u_expr_fieldOp())+"]\n";
      } catch (ArrayIndexOutOfBoundsException aioobe) { /* Skip field */ }
      try {
        s += "  [u.expr.fieldConst=0x"+Long.toHexString(get_u_expr_fieldConst())+"]\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 (0 / 8);
    }

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

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

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

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

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: fwdNode
    //   Field type: int
    //   Offset (bits): 16
    //   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 (16 / 8);
    }

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

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

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

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

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: msgType
    //   Field type: byte
    //   Offset (bits): 32
    //   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 (32 / 8);
    }

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

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

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

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

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: numFields
    //   Field type: byte
    //   Offset (bits): 40
    //   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 (40 / 8);
    }

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

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

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

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

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: numExprs
    //   Field type: byte
    //   Offset (bits): 48
    //   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 (48 / 8);
    }

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

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

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

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

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: fromBuffer
    //   Field type: byte
    //   Offset (bits): 56
    //   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 (56 / 8);
    }

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

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

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

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

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: fromCatalogBuffer
    //   Field type: byte
    //   Offset (bits): 64
    //   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 (64 / 8);
    }

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

    /**
     * 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 (1 / 8) + 1;
    }

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: hasEvent
    //   Field type: byte
    //   Offset (bits): 65
    //   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 65).
     */
    public static int offset_hasEvent() {
        return (65 / 8);
    }

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

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

    /**
     * Set the value of the field 'hasEvent'
     */
    public void set_hasEvent(byte value) {
        setUIntElement(offsetBits_hasEvent(), 1, 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 (1 / 8) + 1;
    }

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: hasForClause
    //   Field type: byte
    //   Offset (bits): 66
    //   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 66).
     */
    public static int offset_hasForClause() {
        return (66 / 8);
    }

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

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

    /**
     * Set the value of the field 'hasForClause'
     */
    public void set_hasForClause(byte value) {
        setUIntElement(offsetBits_hasForClause(), 1, 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 (1 / 8) + 1;
    }

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: bufferType
    //   Field type: byte
    //   Offset (bits): 67
    //   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 67).
     */
    public static int offset_bufferType() {
        return (67 / 8);
    }

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

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

    /**
     * Set the value of the field 'bufferType'
     */
    public void set_bufferType(byte value) {
        setUIntElement(offsetBits_bufferType(), 5, 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 (5 / 8) + 1;
    }

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: epochDuration
    //   Field type: short
    //   Offset (bits): 80
    //   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 (80 / 8);
    }

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

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

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

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

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: type
    //   Field type: byte
    //   Offset (bits): 96
    //   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 (96 / 8);
    }

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

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

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

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

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: idx
    //   Field type: byte
    //   Offset (bits): 104
    //   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 (104 / 8);
    }

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

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

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

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

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: timeSyncData
    //   Field type: short[]
    //   Offset (bits): 112
    //   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 = 112;
        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 = 112;
        if (index1 < 0 || index1 >= 5) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * 8;
        return offset;
    }

    /**
     * Return the entire array 'timeSyncData' as a short[]
     */
    public short[] get_timeSyncData() {
        short[] tmp = new short[5];
        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), 8);
    }

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

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

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

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

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

    /**
     * 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 5;
    }

    /**
     * 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): 160
    //   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 (160 / 8);
    }

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

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

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

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

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.field.name
    //   Field type: byte[]
    //   Offset (bits): 176
    //   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 = 176;
        if (index1 < 0 || index1 >= 8) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * 8;
        return (offset / 8);
    }

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

    /**
     * Return the entire array 'u.field.name' as a byte[]
     */
    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;
    }

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

    /**
     * Return an element (as a byte) of the array 'u.field.name'
     */
    public byte getElement_u_field_name(int index1) {
        return (byte)getSIntElement(offsetBits_u_field_name(index1), 8);
    }

    /**
     * Set an element of the array 'u.field.name'
     */
    public void setElement_u_field_name(int index1, byte 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 (64 / 8);
    }

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

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

    /**
     * Return the size, in bits, of each element of the array 'u.field.name'
     */
    public static int elementSizeBits_u_field_name() {
        return 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 8;
    }

    /**
     * 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 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;
         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() { 
         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(i) == (char)0) break;
             carr[i] = (char)getElement_u_field_name(i);
         }
         return new String(carr,0,i);
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.field.op
    //   Field type: short
    //   Offset (bits): 240
    //   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 (240 / 8);
    }

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

    /**
     * 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(), 8);
    }

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

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

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.field.type
    //   Field type: short
    //   Offset (bits): 248
    //   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 (248 / 8);
    }

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

    /**
     * Return the value (as a short) of the field 'u.field.type'
     */
    public short get_u_field_type() {
        return (short)getUIntElement(offsetBits_u_field_type(), 8);
    }

    /**
     * Set the value of the field 'u.field.type'
     */
    public void set_u_field_type(short 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): 176
    //   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 (176 / 8);
    }

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

    /**
     * Return the value (as a byte) of the field 'u.expr.opType'
     */
    public byte get_u_expr_opType() {
        return (byte)getSIntElement(offsetBits_u_expr_opType(), 6);
    }

    /**
     * Set the value of the field 'u.expr.opType'
     */
    public void set_u_expr_opType(byte 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 (6 / 8) + 1;
    }

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.isStringExp
    //   Field type: byte
    //   Offset (bits): 182
    //   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 182).
     */
    public static int offset_u_expr_isStringExp() {
        return (182 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.isStringExp'
     */
    public static int offsetBits_u_expr_isStringExp() {
        return 182;
    }

    /**
     * Return the value (as a byte) of the field 'u.expr.isStringExp'
     */
    public byte get_u_expr_isStringExp() {
        return (byte)getUIntElement(offsetBits_u_expr_isStringExp(), 1);
    }

    /**
     * Set the value of the field 'u.expr.isStringExp'
     */
    public void set_u_expr_isStringExp(byte value) {
        setUIntElement(offsetBits_u_expr_isStringExp(), 1, 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 (1 / 8) + 1;
    }

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.success
    //   Field type: byte
    //   Offset (bits): 183
    //   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 183).
     */
    public static int offset_u_expr_success() {
        return (183 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.success'
     */
    public static int offsetBits_u_expr_success() {
        return 183;
    }

    /**
     * Return the value (as a byte) of the field 'u.expr.success'
     */
    public byte get_u_expr_success() {
        return (byte)getUIntElement(offsetBits_u_expr_success(), 1);
    }

    /**
     * Set the value of the field 'u.expr.success'
     */
    public void set_u_expr_success(byte 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 (1 / 8) + 1;
    }

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.idx
    //   Field type: byte
    //   Offset (bits): 184
    //   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 (184 / 8);
    }

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

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

    /**
     * Set the value of the field 'u.expr.idx'
     */
    public void set_u_expr_idx(byte value) {
        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): 192
    //   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() {
        return (192 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.opval.field'
     */
    public static int offsetBits_u_expr_ex_opval_field() {
        return 192;
    }

    /**
     * Return the value (as a short) of the field 'u.expr.ex.opval.field'
     */
    public short get_u_expr_ex_opval_field() {
        return (short)getSIntElement(offsetBits_u_expr_ex_opval_field(), 16);
    }

    /**
     * Set the value of the field 'u.expr.ex.opval.field'
     */
    public void set_u_expr_ex_opval_field(short value) {
        setSIntElement(offsetBits_u_expr_ex_opval_field(), 16, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.opval.field'
     */
    public static int size_u_expr_ex_opval_field() {
        return (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 16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.opval.op
    //   Field type: byte
    //   Offset (bits): 208
    //   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() {
        return (208 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.opval.op'
     */
    public static int offsetBits_u_expr_ex_opval_op() {
        return 208;
    }

    /**
     * Return the value (as a byte) of the field 'u.expr.ex.opval.op'
     */
    public byte get_u_expr_ex_opval_op() {
        return (byte)getSIntElement(offsetBits_u_expr_ex_opval_op(), 8);
    }

    /**
     * Set the value of the field 'u.expr.ex.opval.op'
     */
    public void set_u_expr_ex_opval_op(byte value) {
        setSIntElement(offsetBits_u_expr_ex_opval_op(), 8, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.opval.op'
     */
    public static int size_u_expr_ex_opval_op() {
        return (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 8;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.opval.value
    //   Field type: short
    //   Offset (bits): 224
    //   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() {
        return (224 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.opval.value'
     */
    public static int offsetBits_u_expr_ex_opval_value() {
        return 224;
    }

    /**
     * Return the value (as a short) of the field 'u.expr.ex.opval.value'
     */
    public short get_u_expr_ex_opval_value() {
        return (short)getSIntElement(offsetBits_u_expr_ex_opval_value(), 16);
    }

    /**
     * Set the value of the field 'u.expr.ex.opval.value'
     */
    public void set_u_expr_ex_opval_value(short value) {
        setSIntElement(offsetBits_u_expr_ex_opval_value(), 16, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.opval.value'
     */
    public static int size_u_expr_ex_opval_value() {
        return (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 16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.agg.field
    //   Field type: short
    //   Offset (bits): 192
    //   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() {
        return (192 / 8);
    }

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

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

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

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.agg.field'
     */
    public static int size_u_expr_ex_agg_field() {
        return (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 16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.agg.groupingField
    //   Field type: short
    //   Offset (bits): 208
    //   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() {
        return (208 / 8);
    }

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

    /**
     * Return the value (as a short) of the field 'u.expr.ex.agg.groupingField'
     */
    public short get_u_expr_ex_agg_groupingField() {
        return (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(short value) {
        setSIntElement(offsetBits_u_expr_ex_agg_groupingField(), 16, value);
    }

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.agg.groupingField'
     */
    public static int size_u_expr_ex_agg_groupingField() {
        return (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 16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.agg.groupFieldOp
    //   Field type: short
    //   Offset (bits): 224
    //   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() {
        return (224 / 8);
    }

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

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

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

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.agg.groupFieldOp'
     */
    public static int size_u_expr_ex_agg_groupFieldOp() {
        return (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 16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.agg.groupFieldConst
    //   Field type: short
    //   Offset (bits): 240
    //   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() {
        return (240 / 8);
    }

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

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

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

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.agg.groupFieldConst'
     */
    public static int size_u_expr_ex_agg_groupFieldConst() {
        return (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 16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.agg.op
    //   Field type: byte
    //   Offset (bits): 256
    //   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() {
        return (256 / 8);
    }

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

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

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

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

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.tagg.agg.field
    //   Field type: short
    //   Offset (bits): 192
    //   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 (192 / 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 192;
    }

    /**
     * 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): 208
    //   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 (208 / 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 208;
    }

    /**
     * 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): 224
    //   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 (224 / 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 224;
    }

    /**
     * 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): 240
    //   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 (240 / 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 240;
    }

    /**
     * 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): 256
    //   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 (256 / 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 256;
    }

    /**
     * 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): 272
    //   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 = 272;
        if (index1 < 0 || index1 >= 4) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * 8;
        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 = 272;
        if (index1 < 0 || index1 >= 4) throw new ArrayIndexOutOfBoundsException();
        offset += 0 + index1 * 8;
        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), 8);
    }

    /**
     * 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), 8, 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 (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 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 (8 / 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 8;
    }

    /**
     * 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 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[] = { 4,  };
        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): 192
    //   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() {
        return (192 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.sexp.op'
     */
    public static int offsetBits_u_expr_ex_sexp_op() {
        return 192;
    }

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

    /**
     * Set the value of the field 'u.expr.ex.sexp.op'
     */
    public void set_u_expr_ex_sexp_op(byte value) {
        setSIntElement(offsetBits_u_expr_ex_sexp_op(), 8, 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): 208
    //   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() {
        return (208 / 8);
    }

    /**
     * Return the offset (in bits) of the field 'u.expr.ex.sexp.field'
     */
    public static int offsetBits_u_expr_ex_sexp_field() {
        return 208;
    }

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

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

    /**
     * Return the size, in bytes, of the field 'u.expr.ex.sexp.field'
     */
    public static int size_u_expr_ex_sexp_field() {
        return (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 16;
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.ex.sexp.s
    //   Field type: byte[]
    //   Offset (bits): 224
    //   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 index1) {
        int offset = 224;
        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 index1) {
        int offset = 224;
        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() {
        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(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(byte[] value) {
        for (int index0 = 0; index0 < value.length; index0++) {
            setElement_u_expr_ex_sexp_s(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 index1) {
        return (byte)getSIntElement(offsetBits_u_expr_ex_sexp_s(index1), 8);
    }

    /**
     * Set an element of the array 'u.expr.ex.sexp.s'
     */
    public void setElement_u_expr_ex_sexp_s(int index1, byte value) {
        setSIntElement(offsetBits_u_expr_ex_sexp_s(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 (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 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 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[] = { 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(String s) { 
         int len = s.length();
         int i;
         for (i = 0; i < len; i++) {
             setElement_u_expr_ex_sexp_s(i, (byte)s.charAt(i));
         }
         setElement_u_expr_ex_sexp_s(i, (byte)0); //null terminate
    }

    /**
     * Read the array 'u.expr.ex.sexp.s' as a String
     */
    public String getString_u_expr_ex_sexp_s() { 
         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(i) == (char)0) break;
             carr[i] = (char)getElement_u_expr_ex_sexp_s(i);
         }
         return new String(carr,0,i);
    }

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.fieldOp
    //   Field type: short
    //   Offset (bits): 304
    //   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 (304 / 8);
    }

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

    /**
     * Return the value (as a short) of the field 'u.expr.fieldOp'
     */
    public short get_u_expr_fieldOp() {
        return (short)getSIntElement(offsetBits_u_expr_fieldOp(), 16);
    }

    /**
     * Set the value of the field 'u.expr.fieldOp'
     */
    public void set_u_expr_fieldOp(short value) {
        setSIntElement(offsetBits_u_expr_fieldOp(), 16, value);
    }

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

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

    /////////////////////////////////////////////////////////
    // Accessor methods for field: u.expr.fieldConst
    //   Field type: short
    //   Offset (bits): 320
    //   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 (320 / 8);
    }

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

    /**
     * Return the value (as a short) of the field 'u.expr.fieldConst'
     */
    public short get_u_expr_fieldConst() {
        return (short)getSIntElement(offsetBits_u_expr_fieldConst(), 16);
    }

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

    /**
     * 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): 336
    //   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 (336 / 8);
    }

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

    /**
     * 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): 176
    //   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 = 176;
        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 = 176;
        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): 240
    //   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 (240 / 8);
    }

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

    /**
     * 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): 256
    //   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 (256 / 8);
    }

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

    /**
     * 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): 176
    //   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 (176 / 8);
    }

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

    /**
     * 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): 177
    //   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 177).
     */
    public static int offset_u_buf_ram_hasInput() {
        return (177 / 8);
    }

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

    /**
     * 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): 178
    //   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 178).
     */
    public static int offset_u_buf_ram_create() {
        return (178 / 8);
    }

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

    /**
     * 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): 179
    //   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 179).
     */
    public static int offset_u_buf_ram_numRows() {
        return (179 / 8);
    }

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

    /**
     * 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): 192
    //   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 = 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.buf.ram.outBufName'
     */
    public static int offsetBits_u_buf_ram_outBufName(int index1) {
        int offset = 192;
        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): 256
    //   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 = 256;
        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 = 256;
        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): 320
    //   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 (320 / 8);
    }

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

    /**
     * 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): 176
    //   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 = 176;
        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 = 176;
        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): 176
    //   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 (176 / 8);
    }

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

    /**
     * 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): 176
    //   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 (176 / 8);
    }

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

    /**
     * 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;
    }

}
