text: #ifndef _ROS_sensor_msgs_MultiEchoLaserScan_h
  #define _ROS_sensor_msgs_MultiEchoLaserScan_h
  
  #include <stdint.h>
  #include <string.h>
  #include <stdlib.h>
  #include "ros/msg.h"
  #include "std_msgs/Header.h"
  #include "sensor_msgs/LaserEcho.h"
  
  namespace sensor_msgs
  {
  
    class MultiEchoLaserScan : public ros::Msg
    {
      public:
        typedef std_msgs::Header _header_type;
        _header_type header;
        typedef float _angle_min_type;
        _angle_min_type angle_min;
        typedef float _angle_max_type;
        _angle_max_type angle_max;
        typedef float _angle_increment_type;
        _angle_increment_type angle_increment;
        typedef float _time_increment_type;
        _time_increment_type time_increment;
        typedef float _scan_time_type;
        _scan_time_type scan_time;
        typedef float _range_min_type;
        _range_min_type range_min;
        typedef float _range_max_type;
        _range_max_type range_max;
        uint32_t ranges_length;
        typedef sensor_msgs::LaserEcho _ranges_type;
        _ranges_type st_ranges;
        _ranges_type * ranges;
        uint32_t intensities_length;
        typedef sensor_msgs::LaserEcho _intensities_type;
        _intensities_type st_intensities;
        _intensities_type * intensities;
  
      MultiEchoLaserScan():
        header(),
        angle_min(0),
        angle_max(0),
        angle_increment(0),
        time_increment(0),
        scan_time(0),
        range_min(0),
        range_max(0),
        ranges_length(0), ranges(NULL),
        intensities_length(0), intensities(NULL)
      {
      }
  
      virtual int serialize(unsigned char *outbuffer) const
      {
        int offset = 0;
        offset += this->header.serialize(outbuffer + offset);
        union {
          float real;
          uint32_t base;
        } u_angle_min;
        u_angle_min.real = this->angle_min;
        *(outbuffer + offset + 0) = (u_angle_min.base >> (8 * 0)) & 0xFF;
        *(outbuffer + offset + 1) = (u_angle_min.base >> (8 * 1)) & 0xFF;
        *(outbuffer + offset + 2) = (u_angle_min.base >> (8 * 2)) & 0xFF;
        *(outbuffer + offset + 3) = (u_angle_min.base >> (8 * 3)) & 0xFF;
        offset += sizeof(this->angle_min);
        union {
          float real;
          uint32_t base;
        } u_angle_max;
        u_angle_max.real = this->angle_max;
        *(outbuffer + offset + 0) = (u_angle_max.base >> (8 * 0)) & 0xFF;
        *(outbuffer + offset + 1) = (u_angle_max.base >> (8 * 1)) & 0xFF;
        *(outbuffer + offset + 2) = (u_angle_max.base >> (8 * 2)) & 0xFF;
        *(outbuffer + offset + 3) = (u_angle_max.base >> (8 * 3)) & 0xFF;
        offset += sizeof(this->angle_max);
        union {
          float real;
          uint32_t base;
        } u_angle_increment;
        u_angle_increment.real = this->angle_increment;
        *(outbuffer + offset + 0) = (u_angle_increment.base >> (8 * 0)) & 0xFF;
        *(outbuffer + offset + 1) = (u_angle_increment.base >> (8 * 1)) & 0xFF;
        *(outbuffer + offset + 2) = (u_angle_increment.base >> (8 * 2)) & 0xFF;
        *(outbuffer + offset + 3) = (u_angle_increment.base >> (8 * 3)) & 0xFF;
        offset += sizeof(this->angle_increment);
        union {
          float real;
          uint32_t base;
        } u_time_increment;
        u_time_increment.real = this->time_increment;
        *(outbuffer + offset + 0) = (u_time_increment.base >> (8 * 0)) & 0xFF;
        *(outbuffer + offset + 1) = (u_time_increment.base >> (8 * 1)) & 0xFF;
        *(outbuffer + offset + 2) = (u_time_increment.base >> (8 * 2)) & 0xFF;
        *(outbuffer + offset + 3) = (u_time_increment.base >> (8 * 3)) & 0xFF;
        offset += sizeof(this->time_increment);
        union {
          float real;
          uint32_t base;
        } u_scan_time;
        u_scan_time.real = this->scan_time;
        *(outbuffer + offset + 0) = (u_scan_time.base >> (8 * 0)) & 0xFF;
        *(outbuffer + offset + 1) = (u_scan_time.base >> (8 * 1)) & 0xFF;
        *(outbuffer + offset + 2) = (u_scan_time.base >> (8 * 2)) & 0xFF;
        *(outbuffer + offset + 3) = (u_scan_time.base >> (8 * 3)) & 0xFF;
        offset += sizeof(this->scan_time);
        union {
          float real;
          uint32_t base;
        } u_range_min;
        u_range_min.real = this->range_min;
        *(outbuffer + offset + 0) = (u_range_min.base >> (8 * 0)) & 0xFF;
        *(outbuffer + offset + 1) = (u_range_min.base >> (8 * 1)) & 0xFF;
        *(outbuffer + offset + 2) = (u_range_min.base >> (8 * 2)) & 0xFF;
        *(outbuffer + offset + 3) = (u_range_min.base >> (8 * 3)) & 0xFF;
        offset += sizeof(this->range_min);
        union {
          float real;
          uint32_t base;
        } u_range_max;
        u_range_max.real = this->range_max;
        *(outbuffer + offset + 0) = (u_range_max.base >> (8 * 0)) & 0xFF;
        *(outbuffer + offset + 1) = (u_range_max.base >> (8 * 1)) & 0xFF;
        *(outbuffer + offset + 2) = (u_range_max.base >> (8 * 2)) & 0xFF;
        *(outbuffer + offset + 3) = (u_range_max.base >> (8 * 3)) & 0xFF;
        offset += sizeof(this->range_max);
        *(outbuffer + offset + 0) = (this->ranges_length >> (8 * 0)) & 0xFF;
        *(outbuffer + offset + 1) = (this->ranges_length >> (8 * 1)) & 0xFF;
        *(outbuffer + offset + 2) = (this->ranges_length >> (8 * 2)) & 0xFF;
        *(outbuffer + offset + 3) = (this->ranges_length >> (8 * 3)) & 0xFF;
        offset += sizeof(this->ranges_length);
        for( uint32_t i = 0; i < ranges_length; i++){
        offset += this->ranges[i].serialize(outbuffer + offset);
        }
        *(outbuffer + offset + 0) = (this->intensities_length >> (8 * 0)) & 0xFF;
        *(outbuffer + offset + 1) = (this->intensities_length >> (8 * 1)) & 0xFF;
        *(outbuffer + offset + 2) = (this->intensities_length >> (8 * 2)) & 0xFF;
        *(outbuffer + offset + 3) = (this->intensities_length >> (8 * 3)) & 0xFF;
        offset += sizeof(this->intensities_length);
        for( uint32_t i = 0; i < intensities_length; i++){
        offset += this->intensities[i].serialize(outbuffer + offset);
        }
        return offset;
      }
  
      virtual int deserialize(unsigned char *inbuffer)
      {
        int offset = 0;
        offset += this->header.deserialize(inbuffer + offset);
        union {
          float real;
          uint32_t base;
        } u_angle_min;
        u_angle_min.base = 0;
        u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
        u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
        u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
        u_angle_min.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
        this->angle_min = u_angle_min.real;
        offset += sizeof(this->angle_min);
        union {
          float real;
          uint32_t base;
        } u_angle_max;
        u_angle_max.base = 0;
        u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
        u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
        u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
        u_angle_max.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
        this->angle_max = u_angle_max.real;
        offset += sizeof(this->angle_max);
        union {
          float real;
          uint32_t base;
        } u_angle_increment;
        u_angle_increment.base = 0;
        u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
        u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
        u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
        u_angle_increment.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
        this->angle_increment = u_angle_increment.real;
        offset += sizeof(this->angle_increment);
        union {
          float real;
          uint32_t base;
        } u_time_increment;
        u_time_increment.base = 0;
        u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
        u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
        u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
        u_time_increment.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
        this->time_increment = u_time_increment.real;
        offset += sizeof(this->time_increment);
        union {
          float real;
          uint32_t base;
        } u_scan_time;
        u_scan_time.base = 0;
        u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
        u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
        u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
        u_scan_time.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
        this->scan_time = u_scan_time.real;
        offset += sizeof(this->scan_time);
        union {
          float real;
          uint32_t base;
        } u_range_min;
        u_range_min.base = 0;
        u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
        u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
        u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
        u_range_min.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
        this->range_min = u_range_min.real;
        offset += sizeof(this->range_min);
        union {
          float real;
          uint32_t base;
        } u_range_max;
        u_range_max.base = 0;
        u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 0))) << (8 * 0);
        u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1);
        u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2);
        u_range_max.base |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3);
        this->range_max = u_range_max.real;
        offset += sizeof(this->range_max);
        uint32_t ranges_lengthT = ((uint32_t) (*(inbuffer + offset))); 
        ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
        ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
        ranges_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
        offset += sizeof(this->ranges_length);
        if(ranges_lengthT > ranges_length)
          this->ranges = (sensor_msgs::LaserEcho*)realloc(this->ranges, ranges_lengthT * sizeof(sensor_msgs::LaserEcho));
        ranges_length = ranges_lengthT;
        for( uint32_t i = 0; i < ranges_length; i++){
        offset += this->st_ranges.deserialize(inbuffer + offset);
          memcpy( &(this->ranges[i]), &(this->st_ranges), sizeof(sensor_msgs::LaserEcho));
        }
        uint32_t intensities_lengthT = ((uint32_t) (*(inbuffer + offset))); 
        intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 1))) << (8 * 1); 
        intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 2))) << (8 * 2); 
        intensities_lengthT |= ((uint32_t) (*(inbuffer + offset + 3))) << (8 * 3); 
        offset += sizeof(this->intensities_length);
        if(intensities_lengthT > intensities_length)
          this->intensities = (sensor_msgs::LaserEcho*)realloc(this->intensities, intensities_lengthT * sizeof(sensor_msgs::LaserEcho));
        intensities_length = intensities_lengthT;
        for( uint32_t i = 0; i < intensities_length; i++){
        offset += this->st_intensities.deserialize(inbuffer + offset);
          memcpy( &(this->intensities[i]), &(this->st_intensities), sizeof(sensor_msgs::LaserEcho));
        }
       return offset;
      }
  
      const char * getType(){ return "sensor_msgs/MultiEchoLaserScan"; };
      const char * getMD5(){ return "6fefb0c6da89d7c8abe4b339f5c2f8fb"; };
  
    };
  
  }
  #endif