public override int Deserialize(System.Byte[] serialized, int startIndex)
 {
     int curIndex = startIndex;
     data = serialized[curIndex];
     curIndex++;
     return (curIndex - startIndex);
 }

 public override void Serialize(MemoryStream stream)
 {
     System.Byte[] type_bytes = new System.Byte[] {type};
     stream.Write(type_bytes, 0, type_bytes.Length);
     System.Byte[] id_bytes = new System.Byte[] {id};
     stream.Write(id_bytes, 0, id_bytes.Length);
     System.Byte[] intensity_bytes = BitConverter.GetBytes(intensity);
     stream.Write(intensity_bytes, 0, intensity_bytes.Length);
 }

 public override void Serialize(MemoryStream stream)
 {
     goal_id.Serialize(stream);
     System.Byte[] status_bytes = new System.Byte[] {status};
     stream.Write(status_bytes, 0, status_bytes.Length);
     System.Byte[] text_bytes = System.Text.Encoding.UTF8.GetBytes(text);
     System.Byte[] text_len_bytes = BitConverter.GetBytes((System.UInt32)text_bytes.Length);
     stream.Write(text_len_bytes, 0, text_len_bytes.Length);
     stream.Write(text_bytes, 0, text_bytes.Length);
 }

 public Image()
 {
     header = new std_msgs.Header();
     height = 0;
     width = 0;
     encoding = "";
     is_bigendian = 0;
     step = 0;
     data = new List<System.Byte>();
 }

 public override int Deserialize(System.Byte[] serialized, int startIndex)
 {
     int curIndex = startIndex;
     type = serialized[curIndex];
     curIndex++;
     id = serialized[curIndex];
     curIndex++;
     intensity = BitConverter.ToSingle(serialized, curIndex);
     curIndex += BitConverter.GetBytes(intensity).Length;
     return (curIndex - startIndex);
 }

 public override int Deserialize(System.Byte[] serialized, int startIndex)
 {
     int curIndex = startIndex;
     System.UInt32 CompressedMessageData_len = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(CompressedMessageData_len).Length;
     System.Byte[] temp = new System.Byte[CompressedMessageData_len];
     Array.Copy(serialized, curIndex, temp, 0, CompressedMessageData_len);
     CompressedMessageData = temp.ToList();
     curIndex += (int)CompressedMessageData_len;
     return (curIndex - startIndex);
 }

 public override int Deserialize(System.Byte[] serialized, int startIndex)
 {
     int curIndex = startIndex;
     curIndex += goal_id.Deserialize(serialized, curIndex);
     status = serialized[curIndex];
     curIndex++;
     System.UInt32 text_len = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(text_len).Length;
     text = System.Text.Encoding.UTF8.GetString(serialized, curIndex, (int)text_len);
     curIndex += (int)text_len;
     return (curIndex - startIndex);
 }

 public override int Deserialize(System.Byte[] serialized, int startIndex)
 {
     int curIndex = startIndex;
     curIndex += layout.Deserialize(serialized, curIndex);
     System.UInt32 data_len = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(data_len).Length;
     System.Byte[] temp = new System.Byte[data_len];
     Array.Copy(serialized, curIndex, temp, 0, data_len);
     data = temp.ToList();
     curIndex += (int)data_len;
     return (curIndex - startIndex);
 }

 public override void Serialize(MemoryStream stream)
 {
     System.Byte[] name_bytes = System.Text.Encoding.UTF8.GetBytes(name);
     System.Byte[] name_len_bytes = BitConverter.GetBytes((System.UInt32)name_bytes.Length);
     stream.Write(name_len_bytes, 0, name_len_bytes.Length);
     stream.Write(name_bytes, 0, name_bytes.Length);
     System.Byte[] offset_bytes = BitConverter.GetBytes(offset);
     stream.Write(offset_bytes, 0, offset_bytes.Length);
     System.Byte[] datatype_bytes = new System.Byte[] {datatype};
     stream.Write(datatype_bytes, 0, datatype_bytes.Length);
     System.Byte[] count_bytes = BitConverter.GetBytes(count);
     stream.Write(count_bytes, 0, count_bytes.Length);
 }

 public CompressedPointCloud2()
 {
     header = new std_msgs.Header();
     height = 0;
     width = 0;
     fields = new List<sensor_msgs.PointField>();
     is_bigendian = false;
     point_step = 0;
     row_step = 0;
     compression_type = 0;
     compressed_data = new List<System.Byte>();
     is_dense = false;
 }

 public override void Serialize(MemoryStream stream)
 {
     header.Serialize(stream);
     System.Byte[] radiation_type_bytes = new System.Byte[] {radiation_type};
     stream.Write(radiation_type_bytes, 0, radiation_type_bytes.Length);
     System.Byte[] field_of_view_bytes = BitConverter.GetBytes(field_of_view);
     stream.Write(field_of_view_bytes, 0, field_of_view_bytes.Length);
     System.Byte[] min_range_bytes = BitConverter.GetBytes(min_range);
     stream.Write(min_range_bytes, 0, min_range_bytes.Length);
     System.Byte[] max_range_bytes = BitConverter.GetBytes(max_range);
     stream.Write(max_range_bytes, 0, max_range_bytes.Length);
     System.Byte[] range_bytes = BitConverter.GetBytes(range);
     stream.Write(range_bytes, 0, range_bytes.Length);
 }

 public override int Deserialize(System.Byte[] serialized, int startIndex)
 {
     int curIndex = startIndex;
     System.UInt32 name_len = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(name_len).Length;
     name = System.Text.Encoding.UTF8.GetString(serialized, curIndex, (int)name_len);
     curIndex += (int)name_len;
     offset = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(offset).Length;
     datatype = serialized[curIndex];
     curIndex++;
     count = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(count).Length;
     return (curIndex - startIndex);
 }

 public override int Deserialize(System.Byte[] serialized, int startIndex)
 {
     int curIndex = startIndex;
     curIndex += header.Deserialize(serialized, curIndex);
     System.UInt32 format_len = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(format_len).Length;
     format = System.Text.Encoding.UTF8.GetString(serialized, curIndex, (int)format_len);
     curIndex += (int)format_len;
     System.UInt32 data_len = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(data_len).Length;
     System.Byte[] temp = new System.Byte[data_len];
     Array.Copy(serialized, curIndex, temp, 0, data_len);
     data = temp.ToList();
     curIndex += (int)data_len;
     return (curIndex - startIndex);
 }

 public override int Deserialize(System.Byte[] serialized, int startIndex)
 {
     int curIndex = startIndex;
     curIndex += header.Deserialize(serialized, curIndex);
     radiation_type = serialized[curIndex];
     curIndex++;
     field_of_view = BitConverter.ToSingle(serialized, curIndex);
     curIndex += BitConverter.GetBytes(field_of_view).Length;
     min_range = BitConverter.ToSingle(serialized, curIndex);
     curIndex += BitConverter.GetBytes(min_range).Length;
     max_range = BitConverter.ToSingle(serialized, curIndex);
     curIndex += BitConverter.GetBytes(max_range).Length;
     range = BitConverter.ToSingle(serialized, curIndex);
     curIndex += BitConverter.GetBytes(range).Length;
     return (curIndex - startIndex);
 }

 public override int Deserialize(System.Byte[] serialized, int startIndex)
 {
     int curIndex = startIndex;
     System.UInt32 TopicName_len = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(TopicName_len).Length;
     TopicName = System.Text.Encoding.UTF8.GetString(serialized, curIndex, (int)TopicName_len);
     curIndex += (int)TopicName_len;
     System.UInt32 TopicType_len = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(TopicType_len).Length;
     TopicType = System.Text.Encoding.UTF8.GetString(serialized, curIndex, (int)TopicType_len);
     curIndex += (int)TopicType_len;
     System.UInt32 SerializedMessageData_len = BitConverter.ToUInt32(serialized, curIndex);
     curIndex += BitConverter.GetBytes(SerializedMessageData_len).Length;
     System.Byte[] temp = new System.Byte[SerializedMessageData_len];
     Array.Copy(serialized, curIndex, temp, 0, SerializedMessageData_len);
     SerializedMessageData = temp.ToList();
     curIndex += (int)SerializedMessageData_len;
     return (curIndex - startIndex);
 }

 public override void Serialize(MemoryStream stream)
 {
     header.Serialize(stream);
     System.Byte[] ActiveTracks_bytes = BitConverter.GetBytes(ActiveTracks);
     stream.Write(ActiveTracks_bytes, 0, ActiveTracks_bytes.Length);
     System.Byte[] TotalTracks_bytes = BitConverter.GetBytes(TotalTracks);
     stream.Write(TotalTracks_bytes, 0, TotalTracks_bytes.Length);
     System.Byte[] Tracks_len_bytes = BitConverter.GetBytes((System.UInt32)Tracks.Count);
     stream.Write(Tracks_len_bytes, 0, Tracks_len_bytes.Length);
     foreach(person_tracker.TrackedPerson element in Tracks)
     {
         element.Serialize(stream);
     }
     System.Byte[] TrackerType_bytes = new System.Byte[] {TrackerType};
     stream.Write(TrackerType_bytes, 0, TrackerType_bytes.Length);
     System.Byte[] TrackerName_bytes = System.Text.Encoding.UTF8.GetBytes(TrackerName);
     System.Byte[] TrackerName_len_bytes = BitConverter.GetBytes((System.UInt32)TrackerName_bytes.Length);
     stream.Write(TrackerName_len_bytes, 0, TrackerName_len_bytes.Length);
     stream.Write(TrackerName_bytes, 0, TrackerName_bytes.Length);
 }

 public override void Serialize(MemoryStream stream)
 {
     header.Serialize(stream);
     System.Byte[] height_bytes = BitConverter.GetBytes(height);
     stream.Write(height_bytes, 0, height_bytes.Length);
     System.Byte[] width_bytes = BitConverter.GetBytes(width);
     stream.Write(width_bytes, 0, width_bytes.Length);
     System.Byte[] encoding_bytes = System.Text.Encoding.UTF8.GetBytes(encoding);
     System.Byte[] encoding_len_bytes = BitConverter.GetBytes((System.UInt32)encoding_bytes.Length);
     stream.Write(encoding_len_bytes, 0, encoding_len_bytes.Length);
     stream.Write(encoding_bytes, 0, encoding_bytes.Length);
     System.Byte[] is_bigendian_bytes = new System.Byte[] {is_bigendian};
     stream.Write(is_bigendian_bytes, 0, is_bigendian_bytes.Length);
     System.Byte[] step_bytes = BitConverter.GetBytes(step);
     stream.Write(step_bytes, 0, step_bytes.Length);
     System.Byte[] data_bytes = data.ToArray();
     System.Byte[] data_len_bytes = BitConverter.GetBytes((System.UInt32)data_bytes.Length);
     stream.Write(data_len_bytes, 0, data_len_bytes.Length);
     stream.Write(data_bytes, 0, data_bytes.Length);
 }

        public void Save(System.String fileName)
        {
            System.Int32 bufferLength = 16*(BARanges.Count+1);
            for (System.Int32 i=0;i<BARanges.Count;i++)
                bufferLength+= BARanges[i][1];

            System.Byte[] outputBuffer = new System.Byte[bufferLength];
            System.Array.Copy(System.Text.Encoding.ASCII.GetBytes("BARDMA"), 0, outputBuffer, 0, 6);
            System.Array.Copy(System.BitConverter.GetBytes(BARanges.Count), 0, outputBuffer, 8, 4);
            for (System.Int32 i=0;i<BARanges.Count;i++)
            {
                System.Array.Copy(System.Text.Encoding.ASCII.GetBytes(rangesNames[i]), 0, outputBuffer, 0x10+i*0x10, 4);
                System.Int32 currOffset = i==0?0x10+BARanges.Count*0x10:
                                                       System.BitConverter.ToInt32(new System.Byte[] {
                                                                                   	outputBuffer[0x4+i*0x10],
                                                                                   	outputBuffer[0x5+i*0x10],
                                                                                   	outputBuffer[0x6+i*0x10],
                                                                                   	outputBuffer[0x7+i*0x10]},0)+
                                                       System.BitConverter.ToInt32(new System.Byte[] {
                                                                                   	outputBuffer[0x8+i*0x10],
                                                                                   	outputBuffer[0x9+i*0x10],
                                                                                   	outputBuffer[0xA+i*0x10],
                                                                                   	outputBuffer[0xB+i*0x10]},0);
                System.Array.Copy(System.BitConverter.GetBytes(currOffset),0, outputBuffer, 0x14+i*0x10, 4);
                System.Array.Copy(System.BitConverter.GetBytes(BARanges[i][1]), 0, outputBuffer, 0x18+i*0x10, 4);
                System.Array.Copy(System.BitConverter.GetBytes(BARanges[i][0]), 0, outputBuffer, 0x1C+i*0x10, 4);
                System.Byte[] curBuffer = new System.Byte[BARanges[i][1]];
                System.Array.Copy(DMAbuffer,BARanges[i][0],curBuffer,0,BARanges[i][1]);
                System.Array.Copy(curBuffer, 0, outputBuffer, currOffset, curBuffer.Length);
            }
            try
            {
                System.IO.File.WriteAllBytes(fileName,outputBuffer);
            }
            catch (System.UnauthorizedAccessException)
            {

            }
        }

 public override void Serialize(MemoryStream stream)
 {
     System.Byte[] data_bytes = new System.Byte[] {data};
     stream.Write(data_bytes, 0, data_bytes.Length);
 }

 public PointField()
 {
     name = "";
     offset = 0;
     datatype = 0;
     count = 0;
 }