text:
// Code generated by protoc-gen-gogo.
// source: agent/agent.proto
// DO NOT EDIT!

/*
	Package agent is a generated protocol buffer package.

	It is generated from these files:
		agent/agent.proto

	It has these top-level messages:
		Call
		Response
		ProcessIO
*/
package agent

import proto "github.com/gogo/protobuf/proto"
import fmt "fmt"
import math "math"
import mesos "github.com/mesos/mesos-go"

// discarding unused import gogoproto "github.com/gogo/protobuf/gogoproto"

import strconv "strconv"

import bytes "bytes"

import strings "strings"
import github_com_gogo_protobuf_proto "github.com/gogo/protobuf/proto"
import sort "sort"
import reflect "reflect"

import io "io"

// Reference imports to suppress errors if they are not otherwise used.
var _ = proto.Marshal
var _ = fmt.Errorf
var _ = math.Inf

// If a call of type `Call::FOO` requires additional parameters they can be
// included in the corresponding `Call::Foo` message. Similarly, if a call
// receives a synchronous response it will be returned as a `Response`
// message of type `Response::FOO`; see `Call::LaunchNestedContainerSession`
// and `Call::AttachContainerOutput` for exceptions.
type Call_Type int32

const (
	Call_UNKNOWN           Call_Type = 0
	Call_GET_HEALTH        Call_Type = 1
	Call_GET_FLAGS         Call_Type = 2
	Call_GET_VERSION       Call_Type = 3
	Call_GET_METRICS       Call_Type = 4
	Call_GET_LOGGING_LEVEL Call_Type = 5
	Call_SET_LOGGING_LEVEL Call_Type = 6
	Call_LIST_FILES        Call_Type = 7
	Call_READ_FILE         Call_Type = 8
	Call_GET_STATE         Call_Type = 9
	Call_GET_CONTAINERS    Call_Type = 10
	Call_GET_FRAMEWORKS    Call_Type = 11
	Call_GET_EXECUTORS     Call_Type = 12
	Call_GET_TASKS         Call_Type = 13
	// Calls for managing nested containers underneath an executor's container.
	Call_LAUNCH_NESTED_CONTAINER Call_Type = 14
	Call_WAIT_NESTED_CONTAINER   Call_Type = 15
	Call_KILL_NESTED_CONTAINER   Call_Type = 16
	// See 'LaunchNestedContainerSession' below.
	Call_LAUNCH_NESTED_CONTAINER_SESSION Call_Type = 17
	Call_ATTACH_CONTAINER_INPUT          Call_Type = 18
	Call_ATTACH_CONTAINER_OUTPUT         Call_Type = 19
)

var Call_Type_name = map[int32]string{
	0:  "UNKNOWN",
	1:  "GET_HEALTH",
	2:  "GET_FLAGS",
	3:  "GET_VERSION",
	4:  "GET_METRICS",
	5:  "GET_LOGGING_LEVEL",
	6:  "SET_LOGGING_LEVEL",
	7:  "LIST_FILES",
	8:  "READ_FILE",
	9:  "GET_STATE",
	10: "GET_CONTAINERS",
	11: "GET_FRAMEWORKS",
	12: "GET_EXECUTORS",
	13: "GET_TASKS",
	14: "LAUNCH_NESTED_CONTAINER",
	15: "WAIT_NESTED_CONTAINER",
	16: "KILL_NESTED_CONTAINER",
	17: "LAUNCH_NESTED_CONTAINER_SESSION",
	18: "ATTACH_CONTAINER_INPUT",
	19: "ATTACH_CONTAINER_OUTPUT",
}
var Call_Type_value = map[string]int32{
	"UNKNOWN":                         0,
	"GET_HEALTH":                      1,
	"GET_FLAGS":                       2,
	"GET_VERSION":                     3,
	"GET_METRICS":                     4,
	"GET_LOGGING_LEVEL":               5,
	"SET_LOGGING_LEVEL":               6,
	"LIST_FILES":                      7,
	"READ_FILE":                       8,
	"GET_STATE":                       9,
	"GET_CONTAINERS":                  10,
	"GET_FRAMEWORKS":                  11,
	"GET_EXECUTORS":                   12,
	"GET_TASKS":                       13,
	"LAUNCH_NESTED_CONTAINER":         14,
	"WAIT_NESTED_CONTAINER":           15,
	"KILL_NESTED_CONTAINER":           16,
	"LAUNCH_NESTED_CONTAINER_SESSION": 17,
	"ATTACH_CONTAINER_INPUT":          18,
	"ATTACH_CONTAINER_OUTPUT":         19,
}

func (x Call_Type) Enum() *Call_Type {
	p := new(Call_Type)
	*p = x
	return p
}
func (x Call_Type) MarshalJSON() ([]byte, error) {
	return proto.MarshalJSONEnum(Call_Type_name, int32(x))
}
func (x *Call_Type) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(Call_Type_value, data, "Call_Type")
	if err != nil {
		return err
	}
	*x = Call_Type(value)
	return nil
}

type Call_AttachContainerInput_Type int32

const (
	Call_AttachContainerInput_UNKNOWN      Call_AttachContainerInput_Type = 0
	Call_AttachContainerInput_CONTAINER_ID Call_AttachContainerInput_Type = 1
	Call_AttachContainerInput_PROCESS_IO   Call_AttachContainerInput_Type = 2
)

var Call_AttachContainerInput_Type_name = map[int32]string{
	0: "UNKNOWN",
	1: "CONTAINER_ID",
	2: "PROCESS_IO",
}
var Call_AttachContainerInput_Type_value = map[string]int32{
	"UNKNOWN":      0,
	"CONTAINER_ID": 1,
	"PROCESS_IO":   2,
}

func (x Call_AttachContainerInput_Type) Enum() *Call_AttachContainerInput_Type {
	p := new(Call_AttachContainerInput_Type)
	*p = x
	return p
}
func (x Call_AttachContainerInput_Type) MarshalJSON() ([]byte, error) {
	return proto.MarshalJSONEnum(Call_AttachContainerInput_Type_name, int32(x))
}
func (x *Call_AttachContainerInput_Type) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(Call_AttachContainerInput_Type_value, data, "Call_AttachContainerInput_Type")
	if err != nil {
		return err
	}
	*x = Call_AttachContainerInput_Type(value)
	return nil
}

// Each of the responses of type `FOO` corresponds to `Foo` message below.
type Response_Type int32

const (
	Response_UNKNOWN               Response_Type = 0
	Response_GET_HEALTH            Response_Type = 1
	Response_GET_FLAGS             Response_Type = 2
	Response_GET_VERSION           Response_Type = 3
	Response_GET_METRICS           Response_Type = 4
	Response_GET_LOGGING_LEVEL     Response_Type = 5
	Response_LIST_FILES            Response_Type = 6
	Response_READ_FILE             Response_Type = 7
	Response_GET_STATE             Response_Type = 8
	Response_GET_CONTAINERS        Response_Type = 9
	Response_GET_FRAMEWORKS        Response_Type = 10
	Response_GET_EXECUTORS         Response_Type = 11
	Response_GET_TASKS             Response_Type = 12
	Response_WAIT_NESTED_CONTAINER Response_Type = 13
)

var Response_Type_name = map[int32]string{
	0:  "UNKNOWN",
	1:  "GET_HEALTH",
	2:  "GET_FLAGS",
	3:  "GET_VERSION",
	4:  "GET_METRICS",
	5:  "GET_LOGGING_LEVEL",
	6:  "LIST_FILES",
	7:  "READ_FILE",
	8:  "GET_STATE",
	9:  "GET_CONTAINERS",
	10: "GET_FRAMEWORKS",
	11: "GET_EXECUTORS",
	12: "GET_TASKS",
	13: "WAIT_NESTED_CONTAINER",
}
var Response_Type_value = map[string]int32{
	"UNKNOWN":               0,
	"GET_HEALTH":            1,
	"GET_FLAGS":             2,
	"GET_VERSION":           3,
	"GET_METRICS":           4,
	"GET_LOGGING_LEVEL":     5,
	"LIST_FILES":            6,
	"READ_FILE":             7,
	"GET_STATE":             8,
	"GET_CONTAINERS":        9,
	"GET_FRAMEWORKS":        10,
	"GET_EXECUTORS":         11,
	"GET_TASKS":             12,
	"WAIT_NESTED_CONTAINER": 13,
}

func (x Response_Type) Enum() *Response_Type {
	p := new(Response_Type)
	*p = x
	return p
}
func (x Response_Type) MarshalJSON() ([]byte, error) {
	return proto.MarshalJSONEnum(Response_Type_name, int32(x))
}
func (x *Response_Type) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(Response_Type_value, data, "Response_Type")
	if err != nil {
		return err
	}
	*x = Response_Type(value)
	return nil
}

type ProcessIO_Type int32

const (
	ProcessIO_UNKNOWN ProcessIO_Type = 0
	ProcessIO_DATA    ProcessIO_Type = 1
	ProcessIO_CONTROL ProcessIO_Type = 2
)

var ProcessIO_Type_name = map[int32]string{
	0: "UNKNOWN",
	1: "DATA",
	2: "CONTROL",
}
var ProcessIO_Type_value = map[string]int32{
	"UNKNOWN": 0,
	"DATA":    1,
	"CONTROL": 2,
}

func (x ProcessIO_Type) Enum() *ProcessIO_Type {
	p := new(ProcessIO_Type)
	*p = x
	return p
}
func (x ProcessIO_Type) MarshalJSON() ([]byte, error) {
	return proto.MarshalJSONEnum(ProcessIO_Type_name, int32(x))
}
func (x *ProcessIO_Type) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ProcessIO_Type_value, data, "ProcessIO_Type")
	if err != nil {
		return err
	}
	*x = ProcessIO_Type(value)
	return nil
}

type ProcessIO_Data_Type int32

const (
	ProcessIO_Data_UNKNOWN ProcessIO_Data_Type = 0
	ProcessIO_Data_STDIN   ProcessIO_Data_Type = 1
	ProcessIO_Data_STDOUT  ProcessIO_Data_Type = 2
	ProcessIO_Data_STDERR  ProcessIO_Data_Type = 3
)

var ProcessIO_Data_Type_name = map[int32]string{
	0: "UNKNOWN",
	1: "STDIN",
	2: "STDOUT",
	3: "STDERR",
}
var ProcessIO_Data_Type_value = map[string]int32{
	"UNKNOWN": 0,
	"STDIN":   1,
	"STDOUT":  2,
	"STDERR":  3,
}

func (x ProcessIO_Data_Type) Enum() *ProcessIO_Data_Type {
	p := new(ProcessIO_Data_Type)
	*p = x
	return p
}
func (x ProcessIO_Data_Type) MarshalJSON() ([]byte, error) {
	return proto.MarshalJSONEnum(ProcessIO_Data_Type_name, int32(x))
}
func (x *ProcessIO_Data_Type) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ProcessIO_Data_Type_value, data, "ProcessIO_Data_Type")
	if err != nil {
		return err
	}
	*x = ProcessIO_Data_Type(value)
	return nil
}

type ProcessIO_Control_Type int32

const (
	ProcessIO_Control_UNKNOWN   ProcessIO_Control_Type = 0
	ProcessIO_Control_TTY_INFO  ProcessIO_Control_Type = 1
	ProcessIO_Control_HEARTBEAT ProcessIO_Control_Type = 2
)

var ProcessIO_Control_Type_name = map[int32]string{
	0: "UNKNOWN",
	1: "TTY_INFO",
	2: "HEARTBEAT",
}
var ProcessIO_Control_Type_value = map[string]int32{
	"UNKNOWN":   0,
	"TTY_INFO":  1,
	"HEARTBEAT": 2,
}

func (x ProcessIO_Control_Type) Enum() *ProcessIO_Control_Type {
	p := new(ProcessIO_Control_Type)
	*p = x
	return p
}
func (x ProcessIO_Control_Type) MarshalJSON() ([]byte, error) {
	return proto.MarshalJSONEnum(ProcessIO_Control_Type_name, int32(x))
}
func (x *ProcessIO_Control_Type) UnmarshalJSON(data []byte) error {
	value, err := proto.UnmarshalJSONEnum(ProcessIO_Control_Type_value, data, "ProcessIO_Control_Type")
	if err != nil {
		return err
	}
	*x = ProcessIO_Control_Type(value)
	return nil
}

// *
// Calls that can be sent to the v1 agent API.
//
// A call is described using the standard protocol buffer "union"
// trick, see
// https://developers.google.com/protocol-buffers/docs/techniques#union.
type Call struct {
	Type                         *Call_Type                         `protobuf:"varint,1,opt,name=type,enum=mesos.agent.Call_Type" json:"type,omitempty"`
	GetMetrics                   *Call_GetMetrics                   `protobuf:"bytes,2,opt,name=get_metrics" json:"get_metrics,omitempty"`
	SetLoggingLevel              *Call_SetLoggingLevel              `protobuf:"bytes,3,opt,name=set_logging_level" json:"set_logging_level,omitempty"`
	ListFiles                    *Call_ListFiles                    `protobuf:"bytes,4,opt,name=list_files" json:"list_files,omitempty"`
	ReadFile                     *Call_ReadFile                     `protobuf:"bytes,5,opt,name=read_file" json:"read_file,omitempty"`
	LaunchNestedContainer        *Call_LaunchNestedContainer        `protobuf:"bytes,6,opt,name=launch_nested_container" json:"launch_nested_container,omitempty"`
	WaitNestedContainer          *Call_WaitNestedContainer          `protobuf:"bytes,7,opt,name=wait_nested_container" json:"wait_nested_container,omitempty"`
	KillNestedContainer          *Call_KillNestedContainer          `protobuf:"bytes,8,opt,name=kill_nested_container" json:"kill_nested_container,omitempty"`
	LaunchNestedContainerSession *Call_LaunchNestedContainerSession `protobuf:"bytes,9,opt,name=launch_nested_container_session" json:"launch_nested_container_session,omitempty"`
	AttachContainerInput         *Call_AttachContainerInput         `protobuf:"bytes,10,opt,name=attach_container_input" json:"attach_container_input,omitempty"`
	AttachContainerOutput        *Call_AttachContainerOutput        `protobuf:"bytes,11,opt,name=attach_container_output" json:"attach_container_output,omitempty"`
}

func (m *Call) Reset()      { *m = Call{} }
func (*Call) ProtoMessage() {}

func (m *Call) GetType() Call_Type {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return Call_UNKNOWN
}

func (m *Call) GetGetMetrics() *Call_GetMetrics {
	if m != nil {
		return m.GetMetrics
	}
	return nil
}

func (m *Call) GetSetLoggingLevel() *Call_SetLoggingLevel {
	if m != nil {
		return m.SetLoggingLevel
	}
	return nil
}

func (m *Call) GetListFiles() *Call_ListFiles {
	if m != nil {
		return m.ListFiles
	}
	return nil
}

func (m *Call) GetReadFile() *Call_ReadFile {
	if m != nil {
		return m.ReadFile
	}
	return nil
}

func (m *Call) GetLaunchNestedContainer() *Call_LaunchNestedContainer {
	if m != nil {
		return m.LaunchNestedContainer
	}
	return nil
}

func (m *Call) GetWaitNestedContainer() *Call_WaitNestedContainer {
	if m != nil {
		return m.WaitNestedContainer
	}
	return nil
}

func (m *Call) GetKillNestedContainer() *Call_KillNestedContainer {
	if m != nil {
		return m.KillNestedContainer
	}
	return nil
}

func (m *Call) GetLaunchNestedContainerSession() *Call_LaunchNestedContainerSession {
	if m != nil {
		return m.LaunchNestedContainerSession
	}
	return nil
}

func (m *Call) GetAttachContainerInput() *Call_AttachContainerInput {
	if m != nil {
		return m.AttachContainerInput
	}
	return nil
}

func (m *Call) GetAttachContainerOutput() *Call_AttachContainerOutput {
	if m != nil {
		return m.AttachContainerOutput
	}
	return nil
}

// Provides a snapshot of the current metrics tracked by the agent.
type Call_GetMetrics struct {
	// If set, `timeout` would be used to determines the maximum amount of time
	// the API will take to respond. If the timeout is exceeded, some metrics
	// may not be included in the response.
	Timeout *mesos.DurationInfo `protobuf:"bytes,1,opt,name=timeout" json:"timeout,omitempty"`
}

func (m *Call_GetMetrics) Reset()      { *m = Call_GetMetrics{} }
func (*Call_GetMetrics) ProtoMessage() {}

func (m *Call_GetMetrics) GetTimeout() *mesos.DurationInfo {
	if m != nil {
		return m.Timeout
	}
	return nil
}

// Sets the logging verbosity level for a specified duration. Mesos uses
// [glog](https://github.com/google/glog) for logging. The library only uses
// verbose logging which means nothing will be output unless the verbosity
// level is set (by default it's 0, libprocess uses levels 1, 2, and 3).
type Call_SetLoggingLevel struct {
	// The verbosity level.
	Level *uint32 `protobuf:"varint,1,req,name=level" json:"level,omitempty"`
	// The duration to keep verbosity level toggled. After this duration, the
	// verbosity level of log would revert to the original level.
	Duration *mesos.DurationInfo `protobuf:"bytes,2,req,name=duration" json:"duration,omitempty"`
}

func (m *Call_SetLoggingLevel) Reset()      { *m = Call_SetLoggingLevel{} }
func (*Call_SetLoggingLevel) ProtoMessage() {}

func (m *Call_SetLoggingLevel) GetLevel() uint32 {
	if m != nil && m.Level != nil {
		return *m.Level
	}
	return 0
}

func (m *Call_SetLoggingLevel) GetDuration() *mesos.DurationInfo {
	if m != nil {
		return m.Duration
	}
	return nil
}

// Provides the file listing for a directory.
type Call_ListFiles struct {
	Path *string `protobuf:"bytes,1,req,name=path" json:"path,omitempty"`
}

func (m *Call_ListFiles) Reset()      { *m = Call_ListFiles{} }
func (*Call_ListFiles) ProtoMessage() {}

func (m *Call_ListFiles) GetPath() string {
	if m != nil && m.Path != nil {
		return *m.Path
	}
	return ""
}

// Reads data from a file.
type Call_ReadFile struct {
	// The path of file.
	Path string `protobuf:"bytes,1,req,name=path" json:"path"`
	// Initial offset in file to start reading from.
	Offset uint64 `protobuf:"varint,2,req,name=offset" json:"offset"`
	// The maximum number of bytes to read. The read length is capped at 16
	// memory pages.
	Length uint64 `protobuf:"varint,3,opt,name=length" json:"length"`
}

func (m *Call_ReadFile) Reset()      { *m = Call_ReadFile{} }
func (*Call_ReadFile) ProtoMessage() {}

func (m *Call_ReadFile) GetPath() string {
	if m != nil {
		return m.Path
	}
	return ""
}

func (m *Call_ReadFile) GetOffset() uint64 {
	if m != nil {
		return m.Offset
	}
	return 0
}

func (m *Call_ReadFile) GetLength() uint64 {
	if m != nil {
		return m.Length
	}
	return 0
}

// Launches a nested container within an executor's tree of containers.
type Call_LaunchNestedContainer struct {
	ContainerId *mesos.ContainerID   `protobuf:"bytes,1,req,name=container_id" json:"container_id,omitempty"`
	Command     *mesos.CommandInfo   `protobuf:"bytes,2,opt,name=command" json:"command,omitempty"`
	Container   *mesos.ContainerInfo `protobuf:"bytes,3,opt,name=container" json:"container,omitempty"`
}

func (m *Call_LaunchNestedContainer) Reset()      { *m = Call_LaunchNestedContainer{} }
func (*Call_LaunchNestedContainer) ProtoMessage() {}

func (m *Call_LaunchNestedContainer) GetContainerId() *mesos.ContainerID {
	if m != nil {
		return m.ContainerId
	}
	return nil
}

func (m *Call_LaunchNestedContainer) GetCommand() *mesos.CommandInfo {
	if m != nil {
		return m.Command
	}
	return nil
}

func (m *Call_LaunchNestedContainer) GetContainer() *mesos.ContainerInfo {
	if m != nil {
		return m.Container
	}
	return nil
}

// Waits for the nested container to terminate and receives the exit status.
type Call_WaitNestedContainer struct {
	ContainerId *mesos.ContainerID `protobuf:"bytes,1,req,name=container_id" json:"container_id,omitempty"`
}

func (m *Call_WaitNestedContainer) Reset()      { *m = Call_WaitNestedContainer{} }
func (*Call_WaitNestedContainer) ProtoMessage() {}

func (m *Call_WaitNestedContainer) GetContainerId() *mesos.ContainerID {
	if m != nil {
		return m.ContainerId
	}
	return nil
}

// Kills the nested container. Currently only supports SIGKILL.
type Call_KillNestedContainer struct {
	ContainerId *mesos.ContainerID `protobuf:"bytes,1,req,name=container_id" json:"container_id,omitempty"`
}

func (m *Call_KillNestedContainer) Reset()      { *m = Call_KillNestedContainer{} }
func (*Call_KillNestedContainer) ProtoMessage() {}

func (m *Call_KillNestedContainer) GetContainerId() *mesos.ContainerID {
	if m != nil {
		return m.ContainerId
	}
	return nil
}

// Launches a nested container within an executor's tree of containers.
// The differences between this call and `LaunchNestedContainer` are:
// 1) The container's life-cycle is tied to the lifetime of the
//    connection used to make this call, i.e., if the connection ever
//    breaks, the container will be destroyed.
// 2) The nested container shares the same namespaces and cgroups as
//    its parent container.
// 3) Results in a streaming response of type `ProcessIO`. So the call
//    needs to be made on a persistent connection.
type Call_LaunchNestedContainerSession struct {
	ContainerId *mesos.ContainerID   `protobuf:"bytes,1,req,name=container_id" json:"container_id,omitempty"`
	Command     *mesos.CommandInfo   `protobuf:"bytes,2,opt,name=command" json:"command,omitempty"`
	Container   *mesos.ContainerInfo `protobuf:"bytes,3,opt,name=container" json:"container,omitempty"`
}

func (m *Call_LaunchNestedContainerSession) Reset()      { *m = Call_LaunchNestedContainerSession{} }
func (*Call_LaunchNestedContainerSession) ProtoMessage() {}

func (m *Call_LaunchNestedContainerSession) GetContainerId() *mesos.ContainerID {
	if m != nil {
		return m.ContainerId
	}
	return nil
}

func (m *Call_LaunchNestedContainerSession) GetCommand() *mesos.CommandInfo {
	if m != nil {
		return m.Command
	}
	return nil
}

func (m *Call_LaunchNestedContainerSession) GetContainer() *mesos.ContainerInfo {
	if m != nil {
		return m.Container
	}
	return nil
}

// Attaches the caller to the STDIN of the entry point of the container.
// Clients can use this to stream input data to a container.
// Note that this call needs to be made on a persistent connection by
// streaming a CONTAINER_ID message followed by one or more PROCESS_IO
// messages.
type Call_AttachContainerInput struct {
	Type        *Call_AttachContainerInput_Type `protobuf:"varint,1,opt,name=type,enum=mesos.agent.Call_AttachContainerInput_Type" json:"type,omitempty"`
	ContainerId *mesos.ContainerID              `protobuf:"bytes,2,opt,name=container_id" json:"container_id,omitempty"`
	ProcessIo   *ProcessIO                      `protobuf:"bytes,3,opt,name=process_io" json:"process_io,omitempty"`
}

func (m *Call_AttachContainerInput) Reset()      { *m = Call_AttachContainerInput{} }
func (*Call_AttachContainerInput) ProtoMessage() {}

func (m *Call_AttachContainerInput) GetType() Call_AttachContainerInput_Type {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return Call_AttachContainerInput_UNKNOWN
}

func (m *Call_AttachContainerInput) GetContainerId() *mesos.ContainerID {
	if m != nil {
		return m.ContainerId
	}
	return nil
}

func (m *Call_AttachContainerInput) GetProcessIo() *ProcessIO {
	if m != nil {
		return m.ProcessIo
	}
	return nil
}

// Attaches the caller to the STDOUT and STDERR of the entrypoint of
// the container. Clients can use this to stream output/error from the
// container. This call will result in a streaming response of `ProcessIO`;
// so this call needs to be made on a persistent connection.
type Call_AttachContainerOutput struct {
	ContainerId *mesos.ContainerID `protobuf:"bytes,1,req,name=container_id" json:"container_id,omitempty"`
}

func (m *Call_AttachContainerOutput) Reset()      { *m = Call_AttachContainerOutput{} }
func (*Call_AttachContainerOutput) ProtoMessage() {}

func (m *Call_AttachContainerOutput) GetContainerId() *mesos.ContainerID {
	if m != nil {
		return m.ContainerId
	}
	return nil
}

// *
// Synchronous responses for all calls made to the v1 agent API.
type Response struct {
	Type                *Response_Type                `protobuf:"varint,1,opt,name=type,enum=mesos.agent.Response_Type" json:"type,omitempty"`
	GetHealth           *Response_GetHealth           `protobuf:"bytes,2,opt,name=get_health" json:"get_health,omitempty"`
	GetFlags            *Response_GetFlags            `protobuf:"bytes,3,opt,name=get_flags" json:"get_flags,omitempty"`
	GetVersion          *Response_GetVersion          `protobuf:"bytes,4,opt,name=get_version" json:"get_version,omitempty"`
	GetMetrics          *Response_GetMetrics          `protobuf:"bytes,5,opt,name=get_metrics" json:"get_metrics,omitempty"`
	GetLoggingLevel     *Response_GetLoggingLevel     `protobuf:"bytes,6,opt,name=get_logging_level" json:"get_logging_level,omitempty"`
	ListFiles           *Response_ListFiles           `protobuf:"bytes,7,opt,name=list_files" json:"list_files,omitempty"`
	ReadFile            *Response_ReadFile            `protobuf:"bytes,8,opt,name=read_file" json:"read_file,omitempty"`
	GetState            *Response_GetState            `protobuf:"bytes,9,opt,name=get_state" json:"get_state,omitempty"`
	GetContainers       *Response_GetContainers       `protobuf:"bytes,10,opt,name=get_containers" json:"get_containers,omitempty"`
	GetFrameworks       *Response_GetFrameworks       `protobuf:"bytes,11,opt,name=get_frameworks" json:"get_frameworks,omitempty"`
	GetExecutors        *Response_GetExecutors        `protobuf:"bytes,12,opt,name=get_executors" json:"get_executors,omitempty"`
	GetTasks            *Response_GetTasks            `protobuf:"bytes,13,opt,name=get_tasks" json:"get_tasks,omitempty"`
	WaitNestedContainer *Response_WaitNestedContainer `protobuf:"bytes,14,opt,name=wait_nested_container" json:"wait_nested_container,omitempty"`
}

func (m *Response) Reset()      { *m = Response{} }
func (*Response) ProtoMessage() {}

func (m *Response) GetType() Response_Type {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return Response_UNKNOWN
}

func (m *Response) GetGetHealth() *Response_GetHealth {
	if m != nil {
		return m.GetHealth
	}
	return nil
}

func (m *Response) GetGetFlags() *Response_GetFlags {
	if m != nil {
		return m.GetFlags
	}
	return nil
}

func (m *Response) GetGetVersion() *Response_GetVersion {
	if m != nil {
		return m.GetVersion
	}
	return nil
}

func (m *Response) GetGetMetrics() *Response_GetMetrics {
	if m != nil {
		return m.GetMetrics
	}
	return nil
}

func (m *Response) GetGetLoggingLevel() *Response_GetLoggingLevel {
	if m != nil {
		return m.GetLoggingLevel
	}
	return nil
}

func (m *Response) GetListFiles() *Response_ListFiles {
	if m != nil {
		return m.ListFiles
	}
	return nil
}

func (m *Response) GetReadFile() *Response_ReadFile {
	if m != nil {
		return m.ReadFile
	}
	return nil
}

func (m *Response) GetGetState() *Response_GetState {
	if m != nil {
		return m.GetState
	}
	return nil
}

func (m *Response) GetGetContainers() *Response_GetContainers {
	if m != nil {
		return m.GetContainers
	}
	return nil
}

func (m *Response) GetGetFrameworks() *Response_GetFrameworks {
	if m != nil {
		return m.GetFrameworks
	}
	return nil
}

func (m *Response) GetGetExecutors() *Response_GetExecutors {
	if m != nil {
		return m.GetExecutors
	}
	return nil
}

func (m *Response) GetGetTasks() *Response_GetTasks {
	if m != nil {
		return m.GetTasks
	}
	return nil
}

func (m *Response) GetWaitNestedContainer() *Response_WaitNestedContainer {
	if m != nil {
		return m.WaitNestedContainer
	}
	return nil
}

// `healthy` would be true if the agent is healthy. Delayed responses are also
// indicative of the poor health of the agent.
type Response_GetHealth struct {
	Healthy *bool `protobuf:"varint,1,req,name=healthy" json:"healthy,omitempty"`
}

func (m *Response_GetHealth) Reset()      { *m = Response_GetHealth{} }
func (*Response_GetHealth) ProtoMessage() {}

func (m *Response_GetHealth) GetHealthy() bool {
	if m != nil && m.Healthy != nil {
		return *m.Healthy
	}
	return false
}

// Contains the flag configuration of the agent.
type Response_GetFlags struct {
	Flags []*mesos.Flag `protobuf:"bytes,1,rep,name=flags" json:"flags,omitempty"`
}

func (m *Response_GetFlags) Reset()      { *m = Response_GetFlags{} }
func (*Response_GetFlags) ProtoMessage() {}

func (m *Response_GetFlags) GetFlags() []*mesos.Flag {
	if m != nil {
		return m.Flags
	}
	return nil
}

// Contains the version information of the agent.
type Response_GetVersion struct {
	VersionInfo *mesos.VersionInfo `protobuf:"bytes,1,req,name=version_info" json:"version_info,omitempty"`
}

func (m *Response_GetVersion) Reset()      { *m = Response_GetVersion{} }
func (*Response_GetVersion) ProtoMessage() {}

func (m *Response_GetVersion) GetVersionInfo() *mesos.VersionInfo {
	if m != nil {
		return m.VersionInfo
	}
	return nil
}

// Contains a snapshot of the current metrics.
type Response_GetMetrics struct {
	Metrics []*mesos.Metric `protobuf:"bytes,1,rep,name=metrics" json:"metrics,omitempty"`
}

func (m *Response_GetMetrics) Reset()      { *m = Response_GetMetrics{} }
func (*Response_GetMetrics) ProtoMessage() {}

func (m *Response_GetMetrics) GetMetrics() []*mesos.Metric {
	if m != nil {
		return m.Metrics
	}
	return nil
}

// Contains the logging level of the agent.
type Response_GetLoggingLevel struct {
	Level *uint32 `protobuf:"varint,1,req,name=level" json:"level,omitempty"`
}

func (m *Response_GetLoggingLevel) Reset()      { *m = Response_GetLoggingLevel{} }
func (*Response_GetLoggingLevel) ProtoMessage() {}

func (m *Response_GetLoggingLevel) GetLevel() uint32 {
	if m != nil && m.Level != nil {
		return *m.Level
	}
	return 0
}

// Contains the file listing(similar to `ls -l`) for a directory.
type Response_ListFiles struct {
	FileInfos []*mesos.FileInfo `protobuf:"bytes,1,rep,name=file_infos" json:"file_infos,omitempty"`
}

func (m *Response_ListFiles) Reset()      { *m = Response_ListFiles{} }
func (*Response_ListFiles) ProtoMessage() {}

func (m *Response_ListFiles) GetFileInfos() []*mesos.FileInfo {
	if m != nil {
		return m.FileInfos
	}
	return nil
}

// Contains the file data.
type Response_ReadFile struct {
	// The size of file (in bytes).
	Size_ uint64 `protobuf:"varint,1,req,name=size" json:"size"`
	Data  []byte `protobuf:"bytes,2,req,name=data" json:"data,omitempty"`
}

func (m *Response_ReadFile) Reset()      { *m = Response_ReadFile{} }
func (*Response_ReadFile) ProtoMessage() {}

func (m *Response_ReadFile) GetSize_() uint64 {
	if m != nil {
		return m.Size_
	}
	return 0
}

func (m *Response_ReadFile) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

// Contains full state of the agent i.e. information about the tasks,
// frameworks and executors running in the cluster.
type Response_GetState struct {
	GetTasks      *Response_GetTasks      `protobuf:"bytes,1,opt,name=get_tasks" json:"get_tasks,omitempty"`
	GetExecutors  *Response_GetExecutors  `protobuf:"bytes,2,opt,name=get_executors" json:"get_executors,omitempty"`
	GetFrameworks *Response_GetFrameworks `protobuf:"bytes,3,opt,name=get_frameworks" json:"get_frameworks,omitempty"`
}

func (m *Response_GetState) Reset()      { *m = Response_GetState{} }
func (*Response_GetState) ProtoMessage() {}

func (m *Response_GetState) GetGetTasks() *Response_GetTasks {
	if m != nil {
		return m.GetTasks
	}
	return nil
}

func (m *Response_GetState) GetGetExecutors() *Response_GetExecutors {
	if m != nil {
		return m.GetExecutors
	}
	return nil
}

func (m *Response_GetState) GetGetFrameworks() *Response_GetFrameworks {
	if m != nil {
		return m.GetFrameworks
	}
	return nil
}

// Information about containers running on this agent. It contains
// ContainerStatus and ResourceStatistics along with some metadata
// of the containers.
type Response_GetContainers struct {
	Containers []*Response_GetContainers_Container `protobuf:"bytes,1,rep,name=containers" json:"containers,omitempty"`
}

func (m *Response_GetContainers) Reset()      { *m = Response_GetContainers{} }
func (*Response_GetContainers) ProtoMessage() {}

func (m *Response_GetContainers) GetContainers() []*Response_GetContainers_Container {
	if m != nil {
		return m.Containers
	}
	return nil
}

type Response_GetContainers_Container struct {
	FrameworkId        *mesos.FrameworkID        `protobuf:"bytes,1,req,name=framework_id" json:"framework_id,omitempty"`
	ExecutorId         *mesos.ExecutorID         `protobuf:"bytes,2,req,name=executor_id" json:"executor_id,omitempty"`
	ExecutorName       *string                   `protobuf:"bytes,3,req,name=executor_name" json:"executor_name,omitempty"`
	ContainerId        *mesos.ContainerID        `protobuf:"bytes,4,req,name=container_id" json:"container_id,omitempty"`
	ContainerStatus    *mesos.ContainerStatus    `protobuf:"bytes,5,opt,name=container_status" json:"container_status,omitempty"`
	ResourceStatistics *mesos.ResourceStatistics `protobuf:"bytes,6,opt,name=resource_statistics" json:"resource_statistics,omitempty"`
}

func (m *Response_GetContainers_Container) Reset()      { *m = Response_GetContainers_Container{} }
func (*Response_GetContainers_Container) ProtoMessage() {}

func (m *Response_GetContainers_Container) GetFrameworkId() *mesos.FrameworkID {
	if m != nil {
		return m.FrameworkId
	}
	return nil
}

func (m *Response_GetContainers_Container) GetExecutorId() *mesos.ExecutorID {
	if m != nil {
		return m.ExecutorId
	}
	return nil
}

func (m *Response_GetContainers_Container) GetExecutorName() string {
	if m != nil && m.ExecutorName != nil {
		return *m.ExecutorName
	}
	return ""
}

func (m *Response_GetContainers_Container) GetContainerId() *mesos.ContainerID {
	if m != nil {
		return m.ContainerId
	}
	return nil
}

func (m *Response_GetContainers_Container) GetContainerStatus() *mesos.ContainerStatus {
	if m != nil {
		return m.ContainerStatus
	}
	return nil
}

func (m *Response_GetContainers_Container) GetResourceStatistics() *mesos.ResourceStatistics {
	if m != nil {
		return m.ResourceStatistics
	}
	return nil
}

// Information about all the frameworks known to the agent at the current
// time.
type Response_GetFrameworks struct {
	Frameworks          []*Response_GetFrameworks_Framework `protobuf:"bytes,1,rep,name=frameworks" json:"frameworks,omitempty"`
	CompletedFrameworks []*Response_GetFrameworks_Framework `protobuf:"bytes,2,rep,name=completed_frameworks" json:"completed_frameworks,omitempty"`
}

func (m *Response_GetFrameworks) Reset()      { *m = Response_GetFrameworks{} }
func (*Response_GetFrameworks) ProtoMessage() {}

func (m *Response_GetFrameworks) GetFrameworks() []*Response_GetFrameworks_Framework {
	if m != nil {
		return m.Frameworks
	}
	return nil
}

func (m *Response_GetFrameworks) GetCompletedFrameworks() []*Response_GetFrameworks_Framework {
	if m != nil {
		return m.CompletedFrameworks
	}
	return nil
}

type Response_GetFrameworks_Framework struct {
	FrameworkInfo *mesos.FrameworkInfo `protobuf:"bytes,1,req,name=framework_info" json:"framework_info,omitempty"`
}

func (m *Response_GetFrameworks_Framework) Reset()      { *m = Response_GetFrameworks_Framework{} }
func (*Response_GetFrameworks_Framework) ProtoMessage() {}

func (m *Response_GetFrameworks_Framework) GetFrameworkInfo() *mesos.FrameworkInfo {
	if m != nil {
		return m.FrameworkInfo
	}
	return nil
}

// Lists information about all the executors known to the agent at the
// current time.
type Response_GetExecutors struct {
	Executors          []*Response_GetExecutors_Executor `protobuf:"bytes,1,rep,name=executors" json:"executors,omitempty"`
	CompletedExecutors []*Response_GetExecutors_Executor `protobuf:"bytes,2,rep,name=completed_executors" json:"completed_executors,omitempty"`
}

func (m *Response_GetExecutors) Reset()      { *m = Response_GetExecutors{} }
func (*Response_GetExecutors) ProtoMessage() {}

func (m *Response_GetExecutors) GetExecutors() []*Response_GetExecutors_Executor {
	if m != nil {
		return m.Executors
	}
	return nil
}

func (m *Response_GetExecutors) GetCompletedExecutors() []*Response_GetExecutors_Executor {
	if m != nil {
		return m.CompletedExecutors
	}
	return nil
}

type Response_GetExecutors_Executor struct {
	ExecutorInfo *mesos.ExecutorInfo `protobuf:"bytes,1,req,name=executor_info" json:"executor_info,omitempty"`
}

func (m *Response_GetExecutors_Executor) Reset()      { *m = Response_GetExecutors_Executor{} }
func (*Response_GetExecutors_Executor) ProtoMessage() {}

func (m *Response_GetExecutors_Executor) GetExecutorInfo() *mesos.ExecutorInfo {
	if m != nil {
		return m.ExecutorInfo
	}
	return nil
}

// Lists information about all the tasks known to the agent at the current
// time.
type Response_GetTasks struct {
	// Tasks that are pending in the agent's queue before an executor is
	// launched.
	PendingTasks []*mesos.Task `protobuf:"bytes,1,rep,name=pending_tasks" json:"pending_tasks,omitempty"`
	// Tasks that are enqueued for a launched executor that has not yet
	// registered.
	QueuedTasks []*mesos.Task `protobuf:"bytes,2,rep,name=queued_tasks" json:"queued_tasks,omitempty"`
	// Tasks that are running.
	LaunchedTasks []*mesos.Task `protobuf:"bytes,3,rep,name=launched_tasks" json:"launched_tasks,omitempty"`
	// Tasks that are terminated but pending updates.
	TerminatedTasks []*mesos.Task `protobuf:"bytes,4,rep,name=terminated_tasks" json:"terminated_tasks,omitempty"`
	// Tasks that are terminated and updates acked.
	CompletedTasks []*mesos.Task `protobuf:"bytes,5,rep,name=completed_tasks" json:"completed_tasks,omitempty"`
}

func (m *Response_GetTasks) Reset()      { *m = Response_GetTasks{} }
func (*Response_GetTasks) ProtoMessage() {}

func (m *Response_GetTasks) GetPendingTasks() []*mesos.Task {
	if m != nil {
		return m.PendingTasks
	}
	return nil
}

func (m *Response_GetTasks) GetQueuedTasks() []*mesos.Task {
	if m != nil {
		return m.QueuedTasks
	}
	return nil
}

func (m *Response_GetTasks) GetLaunchedTasks() []*mesos.Task {
	if m != nil {
		return m.LaunchedTasks
	}
	return nil
}

func (m *Response_GetTasks) GetTerminatedTasks() []*mesos.Task {
	if m != nil {
		return m.TerminatedTasks
	}
	return nil
}

func (m *Response_GetTasks) GetCompletedTasks() []*mesos.Task {
	if m != nil {
		return m.CompletedTasks
	}
	return nil
}

// Returns termination information about the nested container.
type Response_WaitNestedContainer struct {
	ExitStatus *int32 `protobuf:"varint,1,opt,name=exit_status" json:"exit_status,omitempty"`
}

func (m *Response_WaitNestedContainer) Reset()      { *m = Response_WaitNestedContainer{} }
func (*Response_WaitNestedContainer) ProtoMessage() {}

func (m *Response_WaitNestedContainer) GetExitStatus() int32 {
	if m != nil && m.ExitStatus != nil {
		return *m.ExitStatus
	}
	return 0
}

// *
// Streaming response to `Call::LAUNCH_NESTED_CONTAINER_SESSION` and
// `Call::ATTACH_CONTAINER_OUTPUT`.
//
// This message is also used to stream request data for
// `Call::ATTACH_CONTAINER_INPUT`.
type ProcessIO struct {
	Type    *ProcessIO_Type    `protobuf:"varint,1,opt,name=type,enum=mesos.agent.ProcessIO_Type" json:"type,omitempty"`
	Data    *ProcessIO_Data    `protobuf:"bytes,2,opt,name=data" json:"data,omitempty"`
	Control *ProcessIO_Control `protobuf:"bytes,3,opt,name=control" json:"control,omitempty"`
}

func (m *ProcessIO) Reset()      { *m = ProcessIO{} }
func (*ProcessIO) ProtoMessage() {}

func (m *ProcessIO) GetType() ProcessIO_Type {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return ProcessIO_UNKNOWN
}

func (m *ProcessIO) GetData() *ProcessIO_Data {
	if m != nil {
		return m.Data
	}
	return nil
}

func (m *ProcessIO) GetControl() *ProcessIO_Control {
	if m != nil {
		return m.Control
	}
	return nil
}

type ProcessIO_Data struct {
	Type *ProcessIO_Data_Type `protobuf:"varint,1,opt,name=type,enum=mesos.agent.ProcessIO_Data_Type" json:"type,omitempty"`
	Data []byte               `protobuf:"bytes,2,opt,name=data" json:"data,omitempty"`
}

func (m *ProcessIO_Data) Reset()      { *m = ProcessIO_Data{} }
func (*ProcessIO_Data) ProtoMessage() {}

func (m *ProcessIO_Data) GetType() ProcessIO_Data_Type {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return ProcessIO_Data_UNKNOWN
}

func (m *ProcessIO_Data) GetData() []byte {
	if m != nil {
		return m.Data
	}
	return nil
}

type ProcessIO_Control struct {
	Type      *ProcessIO_Control_Type      `protobuf:"varint,1,opt,name=type,enum=mesos.agent.ProcessIO_Control_Type" json:"type,omitempty"`
	TtyInfo   *mesos.TTYInfo               `protobuf:"bytes,2,opt,name=tty_info" json:"tty_info,omitempty"`
	Heartbeat *ProcessIO_Control_Heartbeat `protobuf:"bytes,3,opt,name=heartbeat" json:"heartbeat,omitempty"`
}

func (m *ProcessIO_Control) Reset()      { *m = ProcessIO_Control{} }
func (*ProcessIO_Control) ProtoMessage() {}

func (m *ProcessIO_Control) GetType() ProcessIO_Control_Type {
	if m != nil && m.Type != nil {
		return *m.Type
	}
	return ProcessIO_Control_UNKNOWN
}

func (m *ProcessIO_Control) GetTtyInfo() *mesos.TTYInfo {
	if m != nil {
		return m.TtyInfo
	}
	return nil
}

func (m *ProcessIO_Control) GetHeartbeat() *ProcessIO_Control_Heartbeat {
	if m != nil {
		return m.Heartbeat
	}
	return nil
}

type ProcessIO_Control_Heartbeat struct {
	Interval *mesos.DurationInfo `protobuf:"bytes,1,opt,name=interval" json:"interval,omitempty"`
}

func (m *ProcessIO_Control_Heartbeat) Reset()      { *m = ProcessIO_Control_Heartbeat{} }
func (*ProcessIO_Control_Heartbeat) ProtoMessage() {}

func (m *ProcessIO_Control_Heartbeat) GetInterval() *mesos.DurationInfo {
	if m != nil {
		return m.Interval
	}
	return nil
}

func init() {
	proto.RegisterEnum("mesos.agent.Call_Type", Call_Type_name, Call_Type_value)
	proto.RegisterEnum("mesos.agent.Call_AttachContainerInput_Type", Call_AttachContainerInput_Type_name, Call_AttachContainerInput_Type_value)
	proto.RegisterEnum("mesos.agent.Response_Type", Response_Type_name, Response_Type_value)
	proto.RegisterEnum("mesos.agent.ProcessIO_Type", ProcessIO_Type_name, ProcessIO_Type_value)
	proto.RegisterEnum("mesos.agent.ProcessIO_Data_Type", ProcessIO_Data_Type_name, ProcessIO_Data_Type_value)
	proto.RegisterEnum("mesos.agent.ProcessIO_Control_Type", ProcessIO_Control_Type_name, ProcessIO_Control_Type_value)
}
func (x Call_Type) String() string {
	s, ok := Call_Type_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x Call_AttachContainerInput_Type) String() string {
	s, ok := Call_AttachContainerInput_Type_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x Response_Type) String() string {
	s, ok := Response_Type_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x ProcessIO_Type) String() string {
	s, ok := ProcessIO_Type_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x ProcessIO_Data_Type) String() string {
	s, ok := ProcessIO_Data_Type_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (x ProcessIO_Control_Type) String() string {
	s, ok := ProcessIO_Control_Type_name[int32(x)]
	if ok {
		return s
	}
	return strconv.Itoa(int(x))
}
func (this *Call) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Call)
	if !ok {
		return fmt.Errorf("that is not of type *Call")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Call but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Callbut is not nil && this == nil")
	}
	if this.Type != nil && that1.Type != nil {
		if *this.Type != *that1.Type {
			return fmt.Errorf("Type this(%v) Not Equal that(%v)", *this.Type, *that1.Type)
		}
	} else if this.Type != nil {
		return fmt.Errorf("this.Type == nil && that.Type != nil")
	} else if that1.Type != nil {
		return fmt.Errorf("Type this(%v) Not Equal that(%v)", this.Type, that1.Type)
	}
	if !this.GetMetrics.Equal(that1.GetMetrics) {
		return fmt.Errorf("GetMetrics this(%v) Not Equal that(%v)", this.GetMetrics, that1.GetMetrics)
	}
	if !this.SetLoggingLevel.Equal(that1.SetLoggingLevel) {
		return fmt.Errorf("SetLoggingLevel this(%v) Not Equal that(%v)", this.SetLoggingLevel, that1.SetLoggingLevel)
	}
	if !this.ListFiles.Equal(that1.ListFiles) {
		return fmt.Errorf("ListFiles this(%v) Not Equal that(%v)", this.ListFiles, that1.ListFiles)
	}
	if !this.ReadFile.Equal(that1.ReadFile) {
		return fmt.Errorf("ReadFile this(%v) Not Equal that(%v)", this.ReadFile, that1.ReadFile)
	}
	if !this.LaunchNestedContainer.Equal(that1.LaunchNestedContainer) {
		return fmt.Errorf("LaunchNestedContainer this(%v) Not Equal that(%v)", this.LaunchNestedContainer, that1.LaunchNestedContainer)
	}
	if !this.WaitNestedContainer.Equal(that1.WaitNestedContainer) {
		return fmt.Errorf("WaitNestedContainer this(%v) Not Equal that(%v)", this.WaitNestedContainer, that1.WaitNestedContainer)
	}
	if !this.KillNestedContainer.Equal(that1.KillNestedContainer) {
		return fmt.Errorf("KillNestedContainer this(%v) Not Equal that(%v)", this.KillNestedContainer, that1.KillNestedContainer)
	}
	if !this.LaunchNestedContainerSession.Equal(that1.LaunchNestedContainerSession) {
		return fmt.Errorf("LaunchNestedContainerSession this(%v) Not Equal that(%v)", this.LaunchNestedContainerSession, that1.LaunchNestedContainerSession)
	}
	if !this.AttachContainerInput.Equal(that1.AttachContainerInput) {
		return fmt.Errorf("AttachContainerInput this(%v) Not Equal that(%v)", this.AttachContainerInput, that1.AttachContainerInput)
	}
	if !this.AttachContainerOutput.Equal(that1.AttachContainerOutput) {
		return fmt.Errorf("AttachContainerOutput this(%v) Not Equal that(%v)", this.AttachContainerOutput, that1.AttachContainerOutput)
	}
	return nil
}
func (this *Call) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Call)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Type != nil && that1.Type != nil {
		if *this.Type != *that1.Type {
			return false
		}
	} else if this.Type != nil {
		return false
	} else if that1.Type != nil {
		return false
	}
	if !this.GetMetrics.Equal(that1.GetMetrics) {
		return false
	}
	if !this.SetLoggingLevel.Equal(that1.SetLoggingLevel) {
		return false
	}
	if !this.ListFiles.Equal(that1.ListFiles) {
		return false
	}
	if !this.ReadFile.Equal(that1.ReadFile) {
		return false
	}
	if !this.LaunchNestedContainer.Equal(that1.LaunchNestedContainer) {
		return false
	}
	if !this.WaitNestedContainer.Equal(that1.WaitNestedContainer) {
		return false
	}
	if !this.KillNestedContainer.Equal(that1.KillNestedContainer) {
		return false
	}
	if !this.LaunchNestedContainerSession.Equal(that1.LaunchNestedContainerSession) {
		return false
	}
	if !this.AttachContainerInput.Equal(that1.AttachContainerInput) {
		return false
	}
	if !this.AttachContainerOutput.Equal(that1.AttachContainerOutput) {
		return false
	}
	return true
}
func (this *Call_GetMetrics) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Call_GetMetrics)
	if !ok {
		return fmt.Errorf("that is not of type *Call_GetMetrics")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Call_GetMetrics but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Call_GetMetricsbut is not nil && this == nil")
	}
	if !this.Timeout.Equal(that1.Timeout) {
		return fmt.Errorf("Timeout this(%v) Not Equal that(%v)", this.Timeout, that1.Timeout)
	}
	return nil
}
func (this *Call_GetMetrics) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Call_GetMetrics)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.Timeout.Equal(that1.Timeout) {
		return false
	}
	return true
}
func (this *Call_SetLoggingLevel) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Call_SetLoggingLevel)
	if !ok {
		return fmt.Errorf("that is not of type *Call_SetLoggingLevel")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Call_SetLoggingLevel but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Call_SetLoggingLevelbut is not nil && this == nil")
	}
	if this.Level != nil && that1.Level != nil {
		if *this.Level != *that1.Level {
			return fmt.Errorf("Level this(%v) Not Equal that(%v)", *this.Level, *that1.Level)
		}
	} else if this.Level != nil {
		return fmt.Errorf("this.Level == nil && that.Level != nil")
	} else if that1.Level != nil {
		return fmt.Errorf("Level this(%v) Not Equal that(%v)", this.Level, that1.Level)
	}
	if !this.Duration.Equal(that1.Duration) {
		return fmt.Errorf("Duration this(%v) Not Equal that(%v)", this.Duration, that1.Duration)
	}
	return nil
}
func (this *Call_SetLoggingLevel) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Call_SetLoggingLevel)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Level != nil && that1.Level != nil {
		if *this.Level != *that1.Level {
			return false
		}
	} else if this.Level != nil {
		return false
	} else if that1.Level != nil {
		return false
	}
	if !this.Duration.Equal(that1.Duration) {
		return false
	}
	return true
}
func (this *Call_ListFiles) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Call_ListFiles)
	if !ok {
		return fmt.Errorf("that is not of type *Call_ListFiles")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Call_ListFiles but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Call_ListFilesbut is not nil && this == nil")
	}
	if this.Path != nil && that1.Path != nil {
		if *this.Path != *that1.Path {
			return fmt.Errorf("Path this(%v) Not Equal that(%v)", *this.Path, *that1.Path)
		}
	} else if this.Path != nil {
		return fmt.Errorf("this.Path == nil && that.Path != nil")
	} else if that1.Path != nil {
		return fmt.Errorf("Path this(%v) Not Equal that(%v)", this.Path, that1.Path)
	}
	return nil
}
func (this *Call_ListFiles) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Call_ListFiles)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Path != nil && that1.Path != nil {
		if *this.Path != *that1.Path {
			return false
		}
	} else if this.Path != nil {
		return false
	} else if that1.Path != nil {
		return false
	}
	return true
}
func (this *Call_ReadFile) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Call_ReadFile)
	if !ok {
		return fmt.Errorf("that is not of type *Call_ReadFile")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Call_ReadFile but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Call_ReadFilebut is not nil && this == nil")
	}
	if this.Path != that1.Path {
		return fmt.Errorf("Path this(%v) Not Equal that(%v)", this.Path, that1.Path)
	}
	if this.Offset != that1.Offset {
		return fmt.Errorf("Offset this(%v) Not Equal that(%v)", this.Offset, that1.Offset)
	}
	if this.Length != that1.Length {
		return fmt.Errorf("Length this(%v) Not Equal that(%v)", this.Length, that1.Length)
	}
	return nil
}
func (this *Call_ReadFile) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Call_ReadFile)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Path != that1.Path {
		return false
	}
	if this.Offset != that1.Offset {
		return false
	}
	if this.Length != that1.Length {
		return false
	}
	return true
}
func (this *Call_LaunchNestedContainer) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Call_LaunchNestedContainer)
	if !ok {
		return fmt.Errorf("that is not of type *Call_LaunchNestedContainer")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Call_LaunchNestedContainer but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Call_LaunchNestedContainerbut is not nil && this == nil")
	}
	if !this.ContainerId.Equal(that1.ContainerId) {
		return fmt.Errorf("ContainerId this(%v) Not Equal that(%v)", this.ContainerId, that1.ContainerId)
	}
	if !this.Command.Equal(that1.Command) {
		return fmt.Errorf("Command this(%v) Not Equal that(%v)", this.Command, that1.Command)
	}
	if !this.Container.Equal(that1.Container) {
		return fmt.Errorf("Container this(%v) Not Equal that(%v)", this.Container, that1.Container)
	}
	return nil
}
func (this *Call_LaunchNestedContainer) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Call_LaunchNestedContainer)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.ContainerId.Equal(that1.ContainerId) {
		return false
	}
	if !this.Command.Equal(that1.Command) {
		return false
	}
	if !this.Container.Equal(that1.Container) {
		return false
	}
	return true
}
func (this *Call_WaitNestedContainer) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Call_WaitNestedContainer)
	if !ok {
		return fmt.Errorf("that is not of type *Call_WaitNestedContainer")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Call_WaitNestedContainer but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Call_WaitNestedContainerbut is not nil && this == nil")
	}
	if !this.ContainerId.Equal(that1.ContainerId) {
		return fmt.Errorf("ContainerId this(%v) Not Equal that(%v)", this.ContainerId, that1.ContainerId)
	}
	return nil
}
func (this *Call_WaitNestedContainer) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Call_WaitNestedContainer)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.ContainerId.Equal(that1.ContainerId) {
		return false
	}
	return true
}
func (this *Call_KillNestedContainer) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Call_KillNestedContainer)
	if !ok {
		return fmt.Errorf("that is not of type *Call_KillNestedContainer")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Call_KillNestedContainer but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Call_KillNestedContainerbut is not nil && this == nil")
	}
	if !this.ContainerId.Equal(that1.ContainerId) {
		return fmt.Errorf("ContainerId this(%v) Not Equal that(%v)", this.ContainerId, that1.ContainerId)
	}
	return nil
}
func (this *Call_KillNestedContainer) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Call_KillNestedContainer)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.ContainerId.Equal(that1.ContainerId) {
		return false
	}
	return true
}
func (this *Call_LaunchNestedContainerSession) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Call_LaunchNestedContainerSession)
	if !ok {
		return fmt.Errorf("that is not of type *Call_LaunchNestedContainerSession")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Call_LaunchNestedContainerSession but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Call_LaunchNestedContainerSessionbut is not nil && this == nil")
	}
	if !this.ContainerId.Equal(that1.ContainerId) {
		return fmt.Errorf("ContainerId this(%v) Not Equal that(%v)", this.ContainerId, that1.ContainerId)
	}
	if !this.Command.Equal(that1.Command) {
		return fmt.Errorf("Command this(%v) Not Equal that(%v)", this.Command, that1.Command)
	}
	if !this.Container.Equal(that1.Container) {
		return fmt.Errorf("Container this(%v) Not Equal that(%v)", this.Container, that1.Container)
	}
	return nil
}
func (this *Call_LaunchNestedContainerSession) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Call_LaunchNestedContainerSession)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.ContainerId.Equal(that1.ContainerId) {
		return false
	}
	if !this.Command.Equal(that1.Command) {
		return false
	}
	if !this.Container.Equal(that1.Container) {
		return false
	}
	return true
}
func (this *Call_AttachContainerInput) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Call_AttachContainerInput)
	if !ok {
		return fmt.Errorf("that is not of type *Call_AttachContainerInput")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Call_AttachContainerInput but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Call_AttachContainerInputbut is not nil && this == nil")
	}
	if this.Type != nil && that1.Type != nil {
		if *this.Type != *that1.Type {
			return fmt.Errorf("Type this(%v) Not Equal that(%v)", *this.Type, *that1.Type)
		}
	} else if this.Type != nil {
		return fmt.Errorf("this.Type == nil && that.Type != nil")
	} else if that1.Type != nil {
		return fmt.Errorf("Type this(%v) Not Equal that(%v)", this.Type, that1.Type)
	}
	if !this.ContainerId.Equal(that1.ContainerId) {
		return fmt.Errorf("ContainerId this(%v) Not Equal that(%v)", this.ContainerId, that1.ContainerId)
	}
	if !this.ProcessIo.Equal(that1.ProcessIo) {
		return fmt.Errorf("ProcessIo this(%v) Not Equal that(%v)", this.ProcessIo, that1.ProcessIo)
	}
	return nil
}
func (this *Call_AttachContainerInput) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Call_AttachContainerInput)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Type != nil && that1.Type != nil {
		if *this.Type != *that1.Type {
			return false
		}
	} else if this.Type != nil {
		return false
	} else if that1.Type != nil {
		return false
	}
	if !this.ContainerId.Equal(that1.ContainerId) {
		return false
	}
	if !this.ProcessIo.Equal(that1.ProcessIo) {
		return false
	}
	return true
}
func (this *Call_AttachContainerOutput) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Call_AttachContainerOutput)
	if !ok {
		return fmt.Errorf("that is not of type *Call_AttachContainerOutput")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Call_AttachContainerOutput but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Call_AttachContainerOutputbut is not nil && this == nil")
	}
	if !this.ContainerId.Equal(that1.ContainerId) {
		return fmt.Errorf("ContainerId this(%v) Not Equal that(%v)", this.ContainerId, that1.ContainerId)
	}
	return nil
}
func (this *Call_AttachContainerOutput) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Call_AttachContainerOutput)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.ContainerId.Equal(that1.ContainerId) {
		return false
	}
	return true
}
func (this *Response) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Response)
	if !ok {
		return fmt.Errorf("that is not of type *Response")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Response but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Responsebut is not nil && this == nil")
	}
	if this.Type != nil && that1.Type != nil {
		if *this.Type != *that1.Type {
			return fmt.Errorf("Type this(%v) Not Equal that(%v)", *this.Type, *that1.Type)
		}
	} else if this.Type != nil {
		return fmt.Errorf("this.Type == nil && that.Type != nil")
	} else if that1.Type != nil {
		return fmt.Errorf("Type this(%v) Not Equal that(%v)", this.Type, that1.Type)
	}
	if !this.GetHealth.Equal(that1.GetHealth) {
		return fmt.Errorf("GetHealth this(%v) Not Equal that(%v)", this.GetHealth, that1.GetHealth)
	}
	if !this.GetFlags.Equal(that1.GetFlags) {
		return fmt.Errorf("GetFlags this(%v) Not Equal that(%v)", this.GetFlags, that1.GetFlags)
	}
	if !this.GetVersion.Equal(that1.GetVersion) {
		return fmt.Errorf("GetVersion this(%v) Not Equal that(%v)", this.GetVersion, that1.GetVersion)
	}
	if !this.GetMetrics.Equal(that1.GetMetrics) {
		return fmt.Errorf("GetMetrics this(%v) Not Equal that(%v)", this.GetMetrics, that1.GetMetrics)
	}
	if !this.GetLoggingLevel.Equal(that1.GetLoggingLevel) {
		return fmt.Errorf("GetLoggingLevel this(%v) Not Equal that(%v)", this.GetLoggingLevel, that1.GetLoggingLevel)
	}
	if !this.ListFiles.Equal(that1.ListFiles) {
		return fmt.Errorf("ListFiles this(%v) Not Equal that(%v)", this.ListFiles, that1.ListFiles)
	}
	if !this.ReadFile.Equal(that1.ReadFile) {
		return fmt.Errorf("ReadFile this(%v) Not Equal that(%v)", this.ReadFile, that1.ReadFile)
	}
	if !this.GetState.Equal(that1.GetState) {
		return fmt.Errorf("GetState this(%v) Not Equal that(%v)", this.GetState, that1.GetState)
	}
	if !this.GetContainers.Equal(that1.GetContainers) {
		return fmt.Errorf("GetContainers this(%v) Not Equal that(%v)", this.GetContainers, that1.GetContainers)
	}
	if !this.GetFrameworks.Equal(that1.GetFrameworks) {
		return fmt.Errorf("GetFrameworks this(%v) Not Equal that(%v)", this.GetFrameworks, that1.GetFrameworks)
	}
	if !this.GetExecutors.Equal(that1.GetExecutors) {
		return fmt.Errorf("GetExecutors this(%v) Not Equal that(%v)", this.GetExecutors, that1.GetExecutors)
	}
	if !this.GetTasks.Equal(that1.GetTasks) {
		return fmt.Errorf("GetTasks this(%v) Not Equal that(%v)", this.GetTasks, that1.GetTasks)
	}
	if !this.WaitNestedContainer.Equal(that1.WaitNestedContainer) {
		return fmt.Errorf("WaitNestedContainer this(%v) Not Equal that(%v)", this.WaitNestedContainer, that1.WaitNestedContainer)
	}
	return nil
}
func (this *Response) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Response)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Type != nil && that1.Type != nil {
		if *this.Type != *that1.Type {
			return false
		}
	} else if this.Type != nil {
		return false
	} else if that1.Type != nil {
		return false
	}
	if !this.GetHealth.Equal(that1.GetHealth) {
		return false
	}
	if !this.GetFlags.Equal(that1.GetFlags) {
		return false
	}
	if !this.GetVersion.Equal(that1.GetVersion) {
		return false
	}
	if !this.GetMetrics.Equal(that1.GetMetrics) {
		return false
	}
	if !this.GetLoggingLevel.Equal(that1.GetLoggingLevel) {
		return false
	}
	if !this.ListFiles.Equal(that1.ListFiles) {
		return false
	}
	if !this.ReadFile.Equal(that1.ReadFile) {
		return false
	}
	if !this.GetState.Equal(that1.GetState) {
		return false
	}
	if !this.GetContainers.Equal(that1.GetContainers) {
		return false
	}
	if !this.GetFrameworks.Equal(that1.GetFrameworks) {
		return false
	}
	if !this.GetExecutors.Equal(that1.GetExecutors) {
		return false
	}
	if !this.GetTasks.Equal(that1.GetTasks) {
		return false
	}
	if !this.WaitNestedContainer.Equal(that1.WaitNestedContainer) {
		return false
	}
	return true
}
func (this *Response_GetHealth) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Response_GetHealth)
	if !ok {
		return fmt.Errorf("that is not of type *Response_GetHealth")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Response_GetHealth but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Response_GetHealthbut is not nil && this == nil")
	}
	if this.Healthy != nil && that1.Healthy != nil {
		if *this.Healthy != *that1.Healthy {
			return fmt.Errorf("Healthy this(%v) Not Equal that(%v)", *this.Healthy, *that1.Healthy)
		}
	} else if this.Healthy != nil {
		return fmt.Errorf("this.Healthy == nil && that.Healthy != nil")
	} else if that1.Healthy != nil {
		return fmt.Errorf("Healthy this(%v) Not Equal that(%v)", this.Healthy, that1.Healthy)
	}
	return nil
}
func (this *Response_GetHealth) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Response_GetHealth)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Healthy != nil && that1.Healthy != nil {
		if *this.Healthy != *that1.Healthy {
			return false
		}
	} else if this.Healthy != nil {
		return false
	} else if that1.Healthy != nil {
		return false
	}
	return true
}
func (this *Response_GetFlags) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Response_GetFlags)
	if !ok {
		return fmt.Errorf("that is not of type *Response_GetFlags")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Response_GetFlags but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Response_GetFlagsbut is not nil && this == nil")
	}
	if len(this.Flags) != len(that1.Flags) {
		return fmt.Errorf("Flags this(%v) Not Equal that(%v)", len(this.Flags), len(that1.Flags))
	}
	for i := range this.Flags {
		if !this.Flags[i].Equal(that1.Flags[i]) {
			return fmt.Errorf("Flags this[%v](%v) Not Equal that[%v](%v)", i, this.Flags[i], i, that1.Flags[i])
		}
	}
	return nil
}
func (this *Response_GetFlags) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Response_GetFlags)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if len(this.Flags) != len(that1.Flags) {
		return false
	}
	for i := range this.Flags {
		if !this.Flags[i].Equal(that1.Flags[i]) {
			return false
		}
	}
	return true
}
func (this *Response_GetVersion) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Response_GetVersion)
	if !ok {
		return fmt.Errorf("that is not of type *Response_GetVersion")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Response_GetVersion but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Response_GetVersionbut is not nil && this == nil")
	}
	if !this.VersionInfo.Equal(that1.VersionInfo) {
		return fmt.Errorf("VersionInfo this(%v) Not Equal that(%v)", this.VersionInfo, that1.VersionInfo)
	}
	return nil
}
func (this *Response_GetVersion) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Response_GetVersion)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.VersionInfo.Equal(that1.VersionInfo) {
		return false
	}
	return true
}
func (this *Response_GetMetrics) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Response_GetMetrics)
	if !ok {
		return fmt.Errorf("that is not of type *Response_GetMetrics")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Response_GetMetrics but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Response_GetMetricsbut is not nil && this == nil")
	}
	if len(this.Metrics) != len(that1.Metrics) {
		return fmt.Errorf("Metrics this(%v) Not Equal that(%v)", len(this.Metrics), len(that1.Metrics))
	}
	for i := range this.Metrics {
		if !this.Metrics[i].Equal(that1.Metrics[i]) {
			return fmt.Errorf("Metrics this[%v](%v) Not Equal that[%v](%v)", i, this.Metrics[i], i, that1.Metrics[i])
		}
	}
	return nil
}
func (this *Response_GetMetrics) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Response_GetMetrics)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if len(this.Metrics) != len(that1.Metrics) {
		return false
	}
	for i := range this.Metrics {
		if !this.Metrics[i].Equal(that1.Metrics[i]) {
			return false
		}
	}
	return true
}
func (this *Response_GetLoggingLevel) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Response_GetLoggingLevel)
	if !ok {
		return fmt.Errorf("that is not of type *Response_GetLoggingLevel")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Response_GetLoggingLevel but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Response_GetLoggingLevelbut is not nil && this == nil")
	}
	if this.Level != nil && that1.Level != nil {
		if *this.Level != *that1.Level {
			return fmt.Errorf("Level this(%v) Not Equal that(%v)", *this.Level, *that1.Level)
		}
	} else if this.Level != nil {
		return fmt.Errorf("this.Level == nil && that.Level != nil")
	} else if that1.Level != nil {
		return fmt.Errorf("Level this(%v) Not Equal that(%v)", this.Level, that1.Level)
	}
	return nil
}
func (this *Response_GetLoggingLevel) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Response_GetLoggingLevel)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Level != nil && that1.Level != nil {
		if *this.Level != *that1.Level {
			return false
		}
	} else if this.Level != nil {
		return false
	} else if that1.Level != nil {
		return false
	}
	return true
}
func (this *Response_ListFiles) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Response_ListFiles)
	if !ok {
		return fmt.Errorf("that is not of type *Response_ListFiles")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Response_ListFiles but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Response_ListFilesbut is not nil && this == nil")
	}
	if len(this.FileInfos) != len(that1.FileInfos) {
		return fmt.Errorf("FileInfos this(%v) Not Equal that(%v)", len(this.FileInfos), len(that1.FileInfos))
	}
	for i := range this.FileInfos {
		if !this.FileInfos[i].Equal(that1.FileInfos[i]) {
			return fmt.Errorf("FileInfos this[%v](%v) Not Equal that[%v](%v)", i, this.FileInfos[i], i, that1.FileInfos[i])
		}
	}
	return nil
}
func (this *Response_ListFiles) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Response_ListFiles)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if len(this.FileInfos) != len(that1.FileInfos) {
		return false
	}
	for i := range this.FileInfos {
		if !this.FileInfos[i].Equal(that1.FileInfos[i]) {
			return false
		}
	}
	return true
}
func (this *Response_ReadFile) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Response_ReadFile)
	if !ok {
		return fmt.Errorf("that is not of type *Response_ReadFile")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Response_ReadFile but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Response_ReadFilebut is not nil && this == nil")
	}
	if this.Size_ != that1.Size_ {
		return fmt.Errorf("Size_ this(%v) Not Equal that(%v)", this.Size_, that1.Size_)
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data)
	}
	return nil
}
func (this *Response_ReadFile) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Response_ReadFile)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Size_ != that1.Size_ {
		return false
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return false
	}
	return true
}
func (this *Response_GetState) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Response_GetState)
	if !ok {
		return fmt.Errorf("that is not of type *Response_GetState")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Response_GetState but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Response_GetStatebut is not nil && this == nil")
	}
	if !this.GetTasks.Equal(that1.GetTasks) {
		return fmt.Errorf("GetTasks this(%v) Not Equal that(%v)", this.GetTasks, that1.GetTasks)
	}
	if !this.GetExecutors.Equal(that1.GetExecutors) {
		return fmt.Errorf("GetExecutors this(%v) Not Equal that(%v)", this.GetExecutors, that1.GetExecutors)
	}
	if !this.GetFrameworks.Equal(that1.GetFrameworks) {
		return fmt.Errorf("GetFrameworks this(%v) Not Equal that(%v)", this.GetFrameworks, that1.GetFrameworks)
	}
	return nil
}
func (this *Response_GetState) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Response_GetState)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.GetTasks.Equal(that1.GetTasks) {
		return false
	}
	if !this.GetExecutors.Equal(that1.GetExecutors) {
		return false
	}
	if !this.GetFrameworks.Equal(that1.GetFrameworks) {
		return false
	}
	return true
}
func (this *Response_GetContainers) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Response_GetContainers)
	if !ok {
		return fmt.Errorf("that is not of type *Response_GetContainers")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Response_GetContainers but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Response_GetContainersbut is not nil && this == nil")
	}
	if len(this.Containers) != len(that1.Containers) {
		return fmt.Errorf("Containers this(%v) Not Equal that(%v)", len(this.Containers), len(that1.Containers))
	}
	for i := range this.Containers {
		if !this.Containers[i].Equal(that1.Containers[i]) {
			return fmt.Errorf("Containers this[%v](%v) Not Equal that[%v](%v)", i, this.Containers[i], i, that1.Containers[i])
		}
	}
	return nil
}
func (this *Response_GetContainers) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Response_GetContainers)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if len(this.Containers) != len(that1.Containers) {
		return false
	}
	for i := range this.Containers {
		if !this.Containers[i].Equal(that1.Containers[i]) {
			return false
		}
	}
	return true
}
func (this *Response_GetContainers_Container) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Response_GetContainers_Container)
	if !ok {
		return fmt.Errorf("that is not of type *Response_GetContainers_Container")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Response_GetContainers_Container but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Response_GetContainers_Containerbut is not nil && this == nil")
	}
	if !this.FrameworkId.Equal(that1.FrameworkId) {
		return fmt.Errorf("FrameworkId this(%v) Not Equal that(%v)", this.FrameworkId, that1.FrameworkId)
	}
	if !this.ExecutorId.Equal(that1.ExecutorId) {
		return fmt.Errorf("ExecutorId this(%v) Not Equal that(%v)", this.ExecutorId, that1.ExecutorId)
	}
	if this.ExecutorName != nil && that1.ExecutorName != nil {
		if *this.ExecutorName != *that1.ExecutorName {
			return fmt.Errorf("ExecutorName this(%v) Not Equal that(%v)", *this.ExecutorName, *that1.ExecutorName)
		}
	} else if this.ExecutorName != nil {
		return fmt.Errorf("this.ExecutorName == nil && that.ExecutorName != nil")
	} else if that1.ExecutorName != nil {
		return fmt.Errorf("ExecutorName this(%v) Not Equal that(%v)", this.ExecutorName, that1.ExecutorName)
	}
	if !this.ContainerId.Equal(that1.ContainerId) {
		return fmt.Errorf("ContainerId this(%v) Not Equal that(%v)", this.ContainerId, that1.ContainerId)
	}
	if !this.ContainerStatus.Equal(that1.ContainerStatus) {
		return fmt.Errorf("ContainerStatus this(%v) Not Equal that(%v)", this.ContainerStatus, that1.ContainerStatus)
	}
	if !this.ResourceStatistics.Equal(that1.ResourceStatistics) {
		return fmt.Errorf("ResourceStatistics this(%v) Not Equal that(%v)", this.ResourceStatistics, that1.ResourceStatistics)
	}
	return nil
}
func (this *Response_GetContainers_Container) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Response_GetContainers_Container)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.FrameworkId.Equal(that1.FrameworkId) {
		return false
	}
	if !this.ExecutorId.Equal(that1.ExecutorId) {
		return false
	}
	if this.ExecutorName != nil && that1.ExecutorName != nil {
		if *this.ExecutorName != *that1.ExecutorName {
			return false
		}
	} else if this.ExecutorName != nil {
		return false
	} else if that1.ExecutorName != nil {
		return false
	}
	if !this.ContainerId.Equal(that1.ContainerId) {
		return false
	}
	if !this.ContainerStatus.Equal(that1.ContainerStatus) {
		return false
	}
	if !this.ResourceStatistics.Equal(that1.ResourceStatistics) {
		return false
	}
	return true
}
func (this *Response_GetFrameworks) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Response_GetFrameworks)
	if !ok {
		return fmt.Errorf("that is not of type *Response_GetFrameworks")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Response_GetFrameworks but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Response_GetFrameworksbut is not nil && this == nil")
	}
	if len(this.Frameworks) != len(that1.Frameworks) {
		return fmt.Errorf("Frameworks this(%v) Not Equal that(%v)", len(this.Frameworks), len(that1.Frameworks))
	}
	for i := range this.Frameworks {
		if !this.Frameworks[i].Equal(that1.Frameworks[i]) {
			return fmt.Errorf("Frameworks this[%v](%v) Not Equal that[%v](%v)", i, this.Frameworks[i], i, that1.Frameworks[i])
		}
	}
	if len(this.CompletedFrameworks) != len(that1.CompletedFrameworks) {
		return fmt.Errorf("CompletedFrameworks this(%v) Not Equal that(%v)", len(this.CompletedFrameworks), len(that1.CompletedFrameworks))
	}
	for i := range this.CompletedFrameworks {
		if !this.CompletedFrameworks[i].Equal(that1.CompletedFrameworks[i]) {
			return fmt.Errorf("CompletedFrameworks this[%v](%v) Not Equal that[%v](%v)", i, this.CompletedFrameworks[i], i, that1.CompletedFrameworks[i])
		}
	}
	return nil
}
func (this *Response_GetFrameworks) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Response_GetFrameworks)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if len(this.Frameworks) != len(that1.Frameworks) {
		return false
	}
	for i := range this.Frameworks {
		if !this.Frameworks[i].Equal(that1.Frameworks[i]) {
			return false
		}
	}
	if len(this.CompletedFrameworks) != len(that1.CompletedFrameworks) {
		return false
	}
	for i := range this.CompletedFrameworks {
		if !this.CompletedFrameworks[i].Equal(that1.CompletedFrameworks[i]) {
			return false
		}
	}
	return true
}
func (this *Response_GetFrameworks_Framework) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Response_GetFrameworks_Framework)
	if !ok {
		return fmt.Errorf("that is not of type *Response_GetFrameworks_Framework")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Response_GetFrameworks_Framework but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Response_GetFrameworks_Frameworkbut is not nil && this == nil")
	}
	if !this.FrameworkInfo.Equal(that1.FrameworkInfo) {
		return fmt.Errorf("FrameworkInfo this(%v) Not Equal that(%v)", this.FrameworkInfo, that1.FrameworkInfo)
	}
	return nil
}
func (this *Response_GetFrameworks_Framework) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Response_GetFrameworks_Framework)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.FrameworkInfo.Equal(that1.FrameworkInfo) {
		return false
	}
	return true
}
func (this *Response_GetExecutors) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Response_GetExecutors)
	if !ok {
		return fmt.Errorf("that is not of type *Response_GetExecutors")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Response_GetExecutors but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Response_GetExecutorsbut is not nil && this == nil")
	}
	if len(this.Executors) != len(that1.Executors) {
		return fmt.Errorf("Executors this(%v) Not Equal that(%v)", len(this.Executors), len(that1.Executors))
	}
	for i := range this.Executors {
		if !this.Executors[i].Equal(that1.Executors[i]) {
			return fmt.Errorf("Executors this[%v](%v) Not Equal that[%v](%v)", i, this.Executors[i], i, that1.Executors[i])
		}
	}
	if len(this.CompletedExecutors) != len(that1.CompletedExecutors) {
		return fmt.Errorf("CompletedExecutors this(%v) Not Equal that(%v)", len(this.CompletedExecutors), len(that1.CompletedExecutors))
	}
	for i := range this.CompletedExecutors {
		if !this.CompletedExecutors[i].Equal(that1.CompletedExecutors[i]) {
			return fmt.Errorf("CompletedExecutors this[%v](%v) Not Equal that[%v](%v)", i, this.CompletedExecutors[i], i, that1.CompletedExecutors[i])
		}
	}
	return nil
}
func (this *Response_GetExecutors) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Response_GetExecutors)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if len(this.Executors) != len(that1.Executors) {
		return false
	}
	for i := range this.Executors {
		if !this.Executors[i].Equal(that1.Executors[i]) {
			return false
		}
	}
	if len(this.CompletedExecutors) != len(that1.CompletedExecutors) {
		return false
	}
	for i := range this.CompletedExecutors {
		if !this.CompletedExecutors[i].Equal(that1.CompletedExecutors[i]) {
			return false
		}
	}
	return true
}
func (this *Response_GetExecutors_Executor) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Response_GetExecutors_Executor)
	if !ok {
		return fmt.Errorf("that is not of type *Response_GetExecutors_Executor")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Response_GetExecutors_Executor but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Response_GetExecutors_Executorbut is not nil && this == nil")
	}
	if !this.ExecutorInfo.Equal(that1.ExecutorInfo) {
		return fmt.Errorf("ExecutorInfo this(%v) Not Equal that(%v)", this.ExecutorInfo, that1.ExecutorInfo)
	}
	return nil
}
func (this *Response_GetExecutors_Executor) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Response_GetExecutors_Executor)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.ExecutorInfo.Equal(that1.ExecutorInfo) {
		return false
	}
	return true
}
func (this *Response_GetTasks) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Response_GetTasks)
	if !ok {
		return fmt.Errorf("that is not of type *Response_GetTasks")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Response_GetTasks but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Response_GetTasksbut is not nil && this == nil")
	}
	if len(this.PendingTasks) != len(that1.PendingTasks) {
		return fmt.Errorf("PendingTasks this(%v) Not Equal that(%v)", len(this.PendingTasks), len(that1.PendingTasks))
	}
	for i := range this.PendingTasks {
		if !this.PendingTasks[i].Equal(that1.PendingTasks[i]) {
			return fmt.Errorf("PendingTasks this[%v](%v) Not Equal that[%v](%v)", i, this.PendingTasks[i], i, that1.PendingTasks[i])
		}
	}
	if len(this.QueuedTasks) != len(that1.QueuedTasks) {
		return fmt.Errorf("QueuedTasks this(%v) Not Equal that(%v)", len(this.QueuedTasks), len(that1.QueuedTasks))
	}
	for i := range this.QueuedTasks {
		if !this.QueuedTasks[i].Equal(that1.QueuedTasks[i]) {
			return fmt.Errorf("QueuedTasks this[%v](%v) Not Equal that[%v](%v)", i, this.QueuedTasks[i], i, that1.QueuedTasks[i])
		}
	}
	if len(this.LaunchedTasks) != len(that1.LaunchedTasks) {
		return fmt.Errorf("LaunchedTasks this(%v) Not Equal that(%v)", len(this.LaunchedTasks), len(that1.LaunchedTasks))
	}
	for i := range this.LaunchedTasks {
		if !this.LaunchedTasks[i].Equal(that1.LaunchedTasks[i]) {
			return fmt.Errorf("LaunchedTasks this[%v](%v) Not Equal that[%v](%v)", i, this.LaunchedTasks[i], i, that1.LaunchedTasks[i])
		}
	}
	if len(this.TerminatedTasks) != len(that1.TerminatedTasks) {
		return fmt.Errorf("TerminatedTasks this(%v) Not Equal that(%v)", len(this.TerminatedTasks), len(that1.TerminatedTasks))
	}
	for i := range this.TerminatedTasks {
		if !this.TerminatedTasks[i].Equal(that1.TerminatedTasks[i]) {
			return fmt.Errorf("TerminatedTasks this[%v](%v) Not Equal that[%v](%v)", i, this.TerminatedTasks[i], i, that1.TerminatedTasks[i])
		}
	}
	if len(this.CompletedTasks) != len(that1.CompletedTasks) {
		return fmt.Errorf("CompletedTasks this(%v) Not Equal that(%v)", len(this.CompletedTasks), len(that1.CompletedTasks))
	}
	for i := range this.CompletedTasks {
		if !this.CompletedTasks[i].Equal(that1.CompletedTasks[i]) {
			return fmt.Errorf("CompletedTasks this[%v](%v) Not Equal that[%v](%v)", i, this.CompletedTasks[i], i, that1.CompletedTasks[i])
		}
	}
	return nil
}
func (this *Response_GetTasks) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Response_GetTasks)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if len(this.PendingTasks) != len(that1.PendingTasks) {
		return false
	}
	for i := range this.PendingTasks {
		if !this.PendingTasks[i].Equal(that1.PendingTasks[i]) {
			return false
		}
	}
	if len(this.QueuedTasks) != len(that1.QueuedTasks) {
		return false
	}
	for i := range this.QueuedTasks {
		if !this.QueuedTasks[i].Equal(that1.QueuedTasks[i]) {
			return false
		}
	}
	if len(this.LaunchedTasks) != len(that1.LaunchedTasks) {
		return false
	}
	for i := range this.LaunchedTasks {
		if !this.LaunchedTasks[i].Equal(that1.LaunchedTasks[i]) {
			return false
		}
	}
	if len(this.TerminatedTasks) != len(that1.TerminatedTasks) {
		return false
	}
	for i := range this.TerminatedTasks {
		if !this.TerminatedTasks[i].Equal(that1.TerminatedTasks[i]) {
			return false
		}
	}
	if len(this.CompletedTasks) != len(that1.CompletedTasks) {
		return false
	}
	for i := range this.CompletedTasks {
		if !this.CompletedTasks[i].Equal(that1.CompletedTasks[i]) {
			return false
		}
	}
	return true
}
func (this *Response_WaitNestedContainer) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*Response_WaitNestedContainer)
	if !ok {
		return fmt.Errorf("that is not of type *Response_WaitNestedContainer")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *Response_WaitNestedContainer but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *Response_WaitNestedContainerbut is not nil && this == nil")
	}
	if this.ExitStatus != nil && that1.ExitStatus != nil {
		if *this.ExitStatus != *that1.ExitStatus {
			return fmt.Errorf("ExitStatus this(%v) Not Equal that(%v)", *this.ExitStatus, *that1.ExitStatus)
		}
	} else if this.ExitStatus != nil {
		return fmt.Errorf("this.ExitStatus == nil && that.ExitStatus != nil")
	} else if that1.ExitStatus != nil {
		return fmt.Errorf("ExitStatus this(%v) Not Equal that(%v)", this.ExitStatus, that1.ExitStatus)
	}
	return nil
}
func (this *Response_WaitNestedContainer) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*Response_WaitNestedContainer)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.ExitStatus != nil && that1.ExitStatus != nil {
		if *this.ExitStatus != *that1.ExitStatus {
			return false
		}
	} else if this.ExitStatus != nil {
		return false
	} else if that1.ExitStatus != nil {
		return false
	}
	return true
}
func (this *ProcessIO) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*ProcessIO)
	if !ok {
		return fmt.Errorf("that is not of type *ProcessIO")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *ProcessIO but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *ProcessIObut is not nil && this == nil")
	}
	if this.Type != nil && that1.Type != nil {
		if *this.Type != *that1.Type {
			return fmt.Errorf("Type this(%v) Not Equal that(%v)", *this.Type, *that1.Type)
		}
	} else if this.Type != nil {
		return fmt.Errorf("this.Type == nil && that.Type != nil")
	} else if that1.Type != nil {
		return fmt.Errorf("Type this(%v) Not Equal that(%v)", this.Type, that1.Type)
	}
	if !this.Data.Equal(that1.Data) {
		return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data)
	}
	if !this.Control.Equal(that1.Control) {
		return fmt.Errorf("Control this(%v) Not Equal that(%v)", this.Control, that1.Control)
	}
	return nil
}
func (this *ProcessIO) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*ProcessIO)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Type != nil && that1.Type != nil {
		if *this.Type != *that1.Type {
			return false
		}
	} else if this.Type != nil {
		return false
	} else if that1.Type != nil {
		return false
	}
	if !this.Data.Equal(that1.Data) {
		return false
	}
	if !this.Control.Equal(that1.Control) {
		return false
	}
	return true
}
func (this *ProcessIO_Data) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*ProcessIO_Data)
	if !ok {
		return fmt.Errorf("that is not of type *ProcessIO_Data")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *ProcessIO_Data but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *ProcessIO_Databut is not nil && this == nil")
	}
	if this.Type != nil && that1.Type != nil {
		if *this.Type != *that1.Type {
			return fmt.Errorf("Type this(%v) Not Equal that(%v)", *this.Type, *that1.Type)
		}
	} else if this.Type != nil {
		return fmt.Errorf("this.Type == nil && that.Type != nil")
	} else if that1.Type != nil {
		return fmt.Errorf("Type this(%v) Not Equal that(%v)", this.Type, that1.Type)
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return fmt.Errorf("Data this(%v) Not Equal that(%v)", this.Data, that1.Data)
	}
	return nil
}
func (this *ProcessIO_Data) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*ProcessIO_Data)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Type != nil && that1.Type != nil {
		if *this.Type != *that1.Type {
			return false
		}
	} else if this.Type != nil {
		return false
	} else if that1.Type != nil {
		return false
	}
	if !bytes.Equal(this.Data, that1.Data) {
		return false
	}
	return true
}
func (this *ProcessIO_Control) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*ProcessIO_Control)
	if !ok {
		return fmt.Errorf("that is not of type *ProcessIO_Control")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *ProcessIO_Control but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *ProcessIO_Controlbut is not nil && this == nil")
	}
	if this.Type != nil && that1.Type != nil {
		if *this.Type != *that1.Type {
			return fmt.Errorf("Type this(%v) Not Equal that(%v)", *this.Type, *that1.Type)
		}
	} else if this.Type != nil {
		return fmt.Errorf("this.Type == nil && that.Type != nil")
	} else if that1.Type != nil {
		return fmt.Errorf("Type this(%v) Not Equal that(%v)", this.Type, that1.Type)
	}
	if !this.TtyInfo.Equal(that1.TtyInfo) {
		return fmt.Errorf("TtyInfo this(%v) Not Equal that(%v)", this.TtyInfo, that1.TtyInfo)
	}
	if !this.Heartbeat.Equal(that1.Heartbeat) {
		return fmt.Errorf("Heartbeat this(%v) Not Equal that(%v)", this.Heartbeat, that1.Heartbeat)
	}
	return nil
}
func (this *ProcessIO_Control) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*ProcessIO_Control)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if this.Type != nil && that1.Type != nil {
		if *this.Type != *that1.Type {
			return false
		}
	} else if this.Type != nil {
		return false
	} else if that1.Type != nil {
		return false
	}
	if !this.TtyInfo.Equal(that1.TtyInfo) {
		return false
	}
	if !this.Heartbeat.Equal(that1.Heartbeat) {
		return false
	}
	return true
}
func (this *ProcessIO_Control_Heartbeat) VerboseEqual(that interface{}) error {
	if that == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that == nil && this != nil")
	}

	that1, ok := that.(*ProcessIO_Control_Heartbeat)
	if !ok {
		return fmt.Errorf("that is not of type *ProcessIO_Control_Heartbeat")
	}
	if that1 == nil {
		if this == nil {
			return nil
		}
		return fmt.Errorf("that is type *ProcessIO_Control_Heartbeat but is nil && this != nil")
	} else if this == nil {
		return fmt.Errorf("that is type *ProcessIO_Control_Heartbeatbut is not nil && this == nil")
	}
	if !this.Interval.Equal(that1.Interval) {
		return fmt.Errorf("Interval this(%v) Not Equal that(%v)", this.Interval, that1.Interval)
	}
	return nil
}
func (this *ProcessIO_Control_Heartbeat) Equal(that interface{}) bool {
	if that == nil {
		if this == nil {
			return true
		}
		return false
	}

	that1, ok := that.(*ProcessIO_Control_Heartbeat)
	if !ok {
		return false
	}
	if that1 == nil {
		if this == nil {
			return true
		}
		return false
	} else if this == nil {
		return false
	}
	if !this.Interval.Equal(that1.Interval) {
		return false
	}
	return true
}
func (this *Call) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 15)
	s = append(s, "&agent.Call{")
	if this.Type != nil {
		s = append(s, "Type: "+valueToGoStringAgent(this.Type, "agent.Call_Type")+",\n")
	}
	if this.GetMetrics != nil {
		s = append(s, "GetMetrics: "+fmt.Sprintf("%#v", this.GetMetrics)+",\n")
	}
	if this.SetLoggingLevel != nil {
		s = append(s, "SetLoggingLevel: "+fmt.Sprintf("%#v", this.SetLoggingLevel)+",\n")
	}
	if this.ListFiles != nil {
		s = append(s, "ListFiles: "+fmt.Sprintf("%#v", this.ListFiles)+",\n")
	}
	if this.ReadFile != nil {
		s = append(s, "ReadFile: "+fmt.Sprintf("%#v", this.ReadFile)+",\n")
	}
	if this.LaunchNestedContainer != nil {
		s = append(s, "LaunchNestedContainer: "+fmt.Sprintf("%#v", this.LaunchNestedContainer)+",\n")
	}
	if this.WaitNestedContainer != nil {
		s = append(s, "WaitNestedContainer: "+fmt.Sprintf("%#v", this.WaitNestedContainer)+",\n")
	}
	if this.KillNestedContainer != nil {
		s = append(s, "KillNestedContainer: "+fmt.Sprintf("%#v", this.KillNestedContainer)+",\n")
	}
	if this.LaunchNestedContainerSession != nil {
		s = append(s, "LaunchNestedContainerSession: "+fmt.Sprintf("%#v", this.LaunchNestedContainerSession)+",\n")
	}
	if this.AttachContainerInput != nil {
		s = append(s, "AttachContainerInput: "+fmt.Sprintf("%#v", this.AttachContainerInput)+",\n")
	}
	if this.AttachContainerOutput != nil {
		s = append(s, "AttachContainerOutput: "+fmt.Sprintf("%#v", this.AttachContainerOutput)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Call_GetMetrics) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&agent.Call_GetMetrics{")
	if this.Timeout != nil {
		s = append(s, "Timeout: "+fmt.Sprintf("%#v", this.Timeout)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Call_SetLoggingLevel) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&agent.Call_SetLoggingLevel{")
	if this.Level != nil {
		s = append(s, "Level: "+valueToGoStringAgent(this.Level, "uint32")+",\n")
	}
	if this.Duration != nil {
		s = append(s, "Duration: "+fmt.Sprintf("%#v", this.Duration)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Call_ListFiles) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&agent.Call_ListFiles{")
	if this.Path != nil {
		s = append(s, "Path: "+valueToGoStringAgent(this.Path, "string")+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Call_ReadFile) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&agent.Call_ReadFile{")
	s = append(s, "Path: "+fmt.Sprintf("%#v", this.Path)+",\n")
	s = append(s, "Offset: "+fmt.Sprintf("%#v", this.Offset)+",\n")
	s = append(s, "Length: "+fmt.Sprintf("%#v", this.Length)+",\n")
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Call_LaunchNestedContainer) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&agent.Call_LaunchNestedContainer{")
	if this.ContainerId != nil {
		s = append(s, "ContainerId: "+fmt.Sprintf("%#v", this.ContainerId)+",\n")
	}
	if this.Command != nil {
		s = append(s, "Command: "+fmt.Sprintf("%#v", this.Command)+",\n")
	}
	if this.Container != nil {
		s = append(s, "Container: "+fmt.Sprintf("%#v", this.Container)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Call_WaitNestedContainer) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&agent.Call_WaitNestedContainer{")
	if this.ContainerId != nil {
		s = append(s, "ContainerId: "+fmt.Sprintf("%#v", this.ContainerId)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Call_KillNestedContainer) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&agent.Call_KillNestedContainer{")
	if this.ContainerId != nil {
		s = append(s, "ContainerId: "+fmt.Sprintf("%#v", this.ContainerId)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Call_LaunchNestedContainerSession) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&agent.Call_LaunchNestedContainerSession{")
	if this.ContainerId != nil {
		s = append(s, "ContainerId: "+fmt.Sprintf("%#v", this.ContainerId)+",\n")
	}
	if this.Command != nil {
		s = append(s, "Command: "+fmt.Sprintf("%#v", this.Command)+",\n")
	}
	if this.Container != nil {
		s = append(s, "Container: "+fmt.Sprintf("%#v", this.Container)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Call_AttachContainerInput) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&agent.Call_AttachContainerInput{")
	if this.Type != nil {
		s = append(s, "Type: "+valueToGoStringAgent(this.Type, "agent.Call_AttachContainerInput_Type")+",\n")
	}
	if this.ContainerId != nil {
		s = append(s, "ContainerId: "+fmt.Sprintf("%#v", this.ContainerId)+",\n")
	}
	if this.ProcessIo != nil {
		s = append(s, "ProcessIo: "+fmt.Sprintf("%#v", this.ProcessIo)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Call_AttachContainerOutput) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&agent.Call_AttachContainerOutput{")
	if this.ContainerId != nil {
		s = append(s, "ContainerId: "+fmt.Sprintf("%#v", this.ContainerId)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 18)
	s = append(s, "&agent.Response{")
	if this.Type != nil {
		s = append(s, "Type: "+valueToGoStringAgent(this.Type, "agent.Response_Type")+",\n")
	}
	if this.GetHealth != nil {
		s = append(s, "GetHealth: "+fmt.Sprintf("%#v", this.GetHealth)+",\n")
	}
	if this.GetFlags != nil {
		s = append(s, "GetFlags: "+fmt.Sprintf("%#v", this.GetFlags)+",\n")
	}
	if this.GetVersion != nil {
		s = append(s, "GetVersion: "+fmt.Sprintf("%#v", this.GetVersion)+",\n")
	}
	if this.GetMetrics != nil {
		s = append(s, "GetMetrics: "+fmt.Sprintf("%#v", this.GetMetrics)+",\n")
	}
	if this.GetLoggingLevel != nil {
		s = append(s, "GetLoggingLevel: "+fmt.Sprintf("%#v", this.GetLoggingLevel)+",\n")
	}
	if this.ListFiles != nil {
		s = append(s, "ListFiles: "+fmt.Sprintf("%#v", this.ListFiles)+",\n")
	}
	if this.ReadFile != nil {
		s = append(s, "ReadFile: "+fmt.Sprintf("%#v", this.ReadFile)+",\n")
	}
	if this.GetState != nil {
		s = append(s, "GetState: "+fmt.Sprintf("%#v", this.GetState)+",\n")
	}
	if this.GetContainers != nil {
		s = append(s, "GetContainers: "+fmt.Sprintf("%#v", this.GetContainers)+",\n")
	}
	if this.GetFrameworks != nil {
		s = append(s, "GetFrameworks: "+fmt.Sprintf("%#v", this.GetFrameworks)+",\n")
	}
	if this.GetExecutors != nil {
		s = append(s, "GetExecutors: "+fmt.Sprintf("%#v", this.GetExecutors)+",\n")
	}
	if this.GetTasks != nil {
		s = append(s, "GetTasks: "+fmt.Sprintf("%#v", this.GetTasks)+",\n")
	}
	if this.WaitNestedContainer != nil {
		s = append(s, "WaitNestedContainer: "+fmt.Sprintf("%#v", this.WaitNestedContainer)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response_GetHealth) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&agent.Response_GetHealth{")
	if this.Healthy != nil {
		s = append(s, "Healthy: "+valueToGoStringAgent(this.Healthy, "bool")+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response_GetFlags) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&agent.Response_GetFlags{")
	if this.Flags != nil {
		s = append(s, "Flags: "+fmt.Sprintf("%#v", this.Flags)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response_GetVersion) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&agent.Response_GetVersion{")
	if this.VersionInfo != nil {
		s = append(s, "VersionInfo: "+fmt.Sprintf("%#v", this.VersionInfo)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response_GetMetrics) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&agent.Response_GetMetrics{")
	if this.Metrics != nil {
		s = append(s, "Metrics: "+fmt.Sprintf("%#v", this.Metrics)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response_GetLoggingLevel) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&agent.Response_GetLoggingLevel{")
	if this.Level != nil {
		s = append(s, "Level: "+valueToGoStringAgent(this.Level, "uint32")+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response_ListFiles) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&agent.Response_ListFiles{")
	if this.FileInfos != nil {
		s = append(s, "FileInfos: "+fmt.Sprintf("%#v", this.FileInfos)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response_ReadFile) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&agent.Response_ReadFile{")
	s = append(s, "Size_: "+fmt.Sprintf("%#v", this.Size_)+",\n")
	if this.Data != nil {
		s = append(s, "Data: "+valueToGoStringAgent(this.Data, "byte")+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response_GetState) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&agent.Response_GetState{")
	if this.GetTasks != nil {
		s = append(s, "GetTasks: "+fmt.Sprintf("%#v", this.GetTasks)+",\n")
	}
	if this.GetExecutors != nil {
		s = append(s, "GetExecutors: "+fmt.Sprintf("%#v", this.GetExecutors)+",\n")
	}
	if this.GetFrameworks != nil {
		s = append(s, "GetFrameworks: "+fmt.Sprintf("%#v", this.GetFrameworks)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response_GetContainers) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&agent.Response_GetContainers{")
	if this.Containers != nil {
		s = append(s, "Containers: "+fmt.Sprintf("%#v", this.Containers)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response_GetContainers_Container) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 10)
	s = append(s, "&agent.Response_GetContainers_Container{")
	if this.FrameworkId != nil {
		s = append(s, "FrameworkId: "+fmt.Sprintf("%#v", this.FrameworkId)+",\n")
	}
	if this.ExecutorId != nil {
		s = append(s, "ExecutorId: "+fmt.Sprintf("%#v", this.ExecutorId)+",\n")
	}
	if this.ExecutorName != nil {
		s = append(s, "ExecutorName: "+valueToGoStringAgent(this.ExecutorName, "string")+",\n")
	}
	if this.ContainerId != nil {
		s = append(s, "ContainerId: "+fmt.Sprintf("%#v", this.ContainerId)+",\n")
	}
	if this.ContainerStatus != nil {
		s = append(s, "ContainerStatus: "+fmt.Sprintf("%#v", this.ContainerStatus)+",\n")
	}
	if this.ResourceStatistics != nil {
		s = append(s, "ResourceStatistics: "+fmt.Sprintf("%#v", this.ResourceStatistics)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response_GetFrameworks) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&agent.Response_GetFrameworks{")
	if this.Frameworks != nil {
		s = append(s, "Frameworks: "+fmt.Sprintf("%#v", this.Frameworks)+",\n")
	}
	if this.CompletedFrameworks != nil {
		s = append(s, "CompletedFrameworks: "+fmt.Sprintf("%#v", this.CompletedFrameworks)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response_GetFrameworks_Framework) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&agent.Response_GetFrameworks_Framework{")
	if this.FrameworkInfo != nil {
		s = append(s, "FrameworkInfo: "+fmt.Sprintf("%#v", this.FrameworkInfo)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response_GetExecutors) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&agent.Response_GetExecutors{")
	if this.Executors != nil {
		s = append(s, "Executors: "+fmt.Sprintf("%#v", this.Executors)+",\n")
	}
	if this.CompletedExecutors != nil {
		s = append(s, "CompletedExecutors: "+fmt.Sprintf("%#v", this.CompletedExecutors)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response_GetExecutors_Executor) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&agent.Response_GetExecutors_Executor{")
	if this.ExecutorInfo != nil {
		s = append(s, "ExecutorInfo: "+fmt.Sprintf("%#v", this.ExecutorInfo)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response_GetTasks) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 9)
	s = append(s, "&agent.Response_GetTasks{")
	if this.PendingTasks != nil {
		s = append(s, "PendingTasks: "+fmt.Sprintf("%#v", this.PendingTasks)+",\n")
	}
	if this.QueuedTasks != nil {
		s = append(s, "QueuedTasks: "+fmt.Sprintf("%#v", this.QueuedTasks)+",\n")
	}
	if this.LaunchedTasks != nil {
		s = append(s, "LaunchedTasks: "+fmt.Sprintf("%#v", this.LaunchedTasks)+",\n")
	}
	if this.TerminatedTasks != nil {
		s = append(s, "TerminatedTasks: "+fmt.Sprintf("%#v", this.TerminatedTasks)+",\n")
	}
	if this.CompletedTasks != nil {
		s = append(s, "CompletedTasks: "+fmt.Sprintf("%#v", this.CompletedTasks)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *Response_WaitNestedContainer) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&agent.Response_WaitNestedContainer{")
	if this.ExitStatus != nil {
		s = append(s, "ExitStatus: "+valueToGoStringAgent(this.ExitStatus, "int32")+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ProcessIO) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&agent.ProcessIO{")
	if this.Type != nil {
		s = append(s, "Type: "+valueToGoStringAgent(this.Type, "agent.ProcessIO_Type")+",\n")
	}
	if this.Data != nil {
		s = append(s, "Data: "+fmt.Sprintf("%#v", this.Data)+",\n")
	}
	if this.Control != nil {
		s = append(s, "Control: "+fmt.Sprintf("%#v", this.Control)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ProcessIO_Data) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 6)
	s = append(s, "&agent.ProcessIO_Data{")
	if this.Type != nil {
		s = append(s, "Type: "+valueToGoStringAgent(this.Type, "agent.ProcessIO_Data_Type")+",\n")
	}
	if this.Data != nil {
		s = append(s, "Data: "+valueToGoStringAgent(this.Data, "byte")+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ProcessIO_Control) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 7)
	s = append(s, "&agent.ProcessIO_Control{")
	if this.Type != nil {
		s = append(s, "Type: "+valueToGoStringAgent(this.Type, "agent.ProcessIO_Control_Type")+",\n")
	}
	if this.TtyInfo != nil {
		s = append(s, "TtyInfo: "+fmt.Sprintf("%#v", this.TtyInfo)+",\n")
	}
	if this.Heartbeat != nil {
		s = append(s, "Heartbeat: "+fmt.Sprintf("%#v", this.Heartbeat)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func (this *ProcessIO_Control_Heartbeat) GoString() string {
	if this == nil {
		return "nil"
	}
	s := make([]string, 0, 5)
	s = append(s, "&agent.ProcessIO_Control_Heartbeat{")
	if this.Interval != nil {
		s = append(s, "Interval: "+fmt.Sprintf("%#v", this.Interval)+",\n")
	}
	s = append(s, "}")
	return strings.Join(s, "")
}
func valueToGoStringAgent(v interface{}, typ string) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("func(v %v) *%v { return &v } ( %#v )", typ, typ, pv)
}
func extensionToGoStringAgent(e map[int32]github_com_gogo_protobuf_proto.Extension) string {
	if e == nil {
		return "nil"
	}
	s := "map[int32]proto.Extension{"
	keys := make([]int, 0, len(e))
	for k := range e {
		keys = append(keys, int(k))
	}
	sort.Ints(keys)
	ss := []string{}
	for _, k := range keys {
		ss = append(ss, strconv.Itoa(k)+": "+e[int32(k)].GoString())
	}
	s += strings.Join(ss, ",") + "}"
	return s
}
func (m *Call) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Call) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != nil {
		data[i] = 0x8
		i++
		i = encodeVarintAgent(data, i, uint64(*m.Type))
	}
	if m.GetMetrics != nil {
		data[i] = 0x12
		i++
		i = encodeVarintAgent(data, i, uint64(m.GetMetrics.Size()))
		n1, err := m.GetMetrics.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n1
	}
	if m.SetLoggingLevel != nil {
		data[i] = 0x1a
		i++
		i = encodeVarintAgent(data, i, uint64(m.SetLoggingLevel.Size()))
		n2, err := m.SetLoggingLevel.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n2
	}
	if m.ListFiles != nil {
		data[i] = 0x22
		i++
		i = encodeVarintAgent(data, i, uint64(m.ListFiles.Size()))
		n3, err := m.ListFiles.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n3
	}
	if m.ReadFile != nil {
		data[i] = 0x2a
		i++
		i = encodeVarintAgent(data, i, uint64(m.ReadFile.Size()))
		n4, err := m.ReadFile.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n4
	}
	if m.LaunchNestedContainer != nil {
		data[i] = 0x32
		i++
		i = encodeVarintAgent(data, i, uint64(m.LaunchNestedContainer.Size()))
		n5, err := m.LaunchNestedContainer.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n5
	}
	if m.WaitNestedContainer != nil {
		data[i] = 0x3a
		i++
		i = encodeVarintAgent(data, i, uint64(m.WaitNestedContainer.Size()))
		n6, err := m.WaitNestedContainer.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n6
	}
	if m.KillNestedContainer != nil {
		data[i] = 0x42
		i++
		i = encodeVarintAgent(data, i, uint64(m.KillNestedContainer.Size()))
		n7, err := m.KillNestedContainer.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n7
	}
	if m.LaunchNestedContainerSession != nil {
		data[i] = 0x4a
		i++
		i = encodeVarintAgent(data, i, uint64(m.LaunchNestedContainerSession.Size()))
		n8, err := m.LaunchNestedContainerSession.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n8
	}
	if m.AttachContainerInput != nil {
		data[i] = 0x52
		i++
		i = encodeVarintAgent(data, i, uint64(m.AttachContainerInput.Size()))
		n9, err := m.AttachContainerInput.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n9
	}
	if m.AttachContainerOutput != nil {
		data[i] = 0x5a
		i++
		i = encodeVarintAgent(data, i, uint64(m.AttachContainerOutput.Size()))
		n10, err := m.AttachContainerOutput.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n10
	}
	return i, nil
}

func (m *Call_GetMetrics) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Call_GetMetrics) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Timeout != nil {
		data[i] = 0xa
		i++
		i = encodeVarintAgent(data, i, uint64(m.Timeout.Size()))
		n11, err := m.Timeout.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n11
	}
	return i, nil
}

func (m *Call_SetLoggingLevel) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Call_SetLoggingLevel) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Level == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("level")
	} else {
		data[i] = 0x8
		i++
		i = encodeVarintAgent(data, i, uint64(*m.Level))
	}
	if m.Duration == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("duration")
	} else {
		data[i] = 0x12
		i++
		i = encodeVarintAgent(data, i, uint64(m.Duration.Size()))
		n12, err := m.Duration.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n12
	}
	return i, nil
}

func (m *Call_ListFiles) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Call_ListFiles) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Path == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("path")
	} else {
		data[i] = 0xa
		i++
		i = encodeVarintAgent(data, i, uint64(len(*m.Path)))
		i += copy(data[i:], *m.Path)
	}
	return i, nil
}

func (m *Call_ReadFile) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Call_ReadFile) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	data[i] = 0xa
	i++
	i = encodeVarintAgent(data, i, uint64(len(m.Path)))
	i += copy(data[i:], m.Path)
	data[i] = 0x10
	i++
	i = encodeVarintAgent(data, i, uint64(m.Offset))
	data[i] = 0x18
	i++
	i = encodeVarintAgent(data, i, uint64(m.Length))
	return i, nil
}

func (m *Call_LaunchNestedContainer) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Call_LaunchNestedContainer) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ContainerId == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("container_id")
	} else {
		data[i] = 0xa
		i++
		i = encodeVarintAgent(data, i, uint64(m.ContainerId.Size()))
		n13, err := m.ContainerId.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n13
	}
	if m.Command != nil {
		data[i] = 0x12
		i++
		i = encodeVarintAgent(data, i, uint64(m.Command.Size()))
		n14, err := m.Command.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n14
	}
	if m.Container != nil {
		data[i] = 0x1a
		i++
		i = encodeVarintAgent(data, i, uint64(m.Container.Size()))
		n15, err := m.Container.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n15
	}
	return i, nil
}

func (m *Call_WaitNestedContainer) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Call_WaitNestedContainer) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ContainerId == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("container_id")
	} else {
		data[i] = 0xa
		i++
		i = encodeVarintAgent(data, i, uint64(m.ContainerId.Size()))
		n16, err := m.ContainerId.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n16
	}
	return i, nil
}

func (m *Call_KillNestedContainer) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Call_KillNestedContainer) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ContainerId == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("container_id")
	} else {
		data[i] = 0xa
		i++
		i = encodeVarintAgent(data, i, uint64(m.ContainerId.Size()))
		n17, err := m.ContainerId.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n17
	}
	return i, nil
}

func (m *Call_LaunchNestedContainerSession) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Call_LaunchNestedContainerSession) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ContainerId == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("container_id")
	} else {
		data[i] = 0xa
		i++
		i = encodeVarintAgent(data, i, uint64(m.ContainerId.Size()))
		n18, err := m.ContainerId.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n18
	}
	if m.Command != nil {
		data[i] = 0x12
		i++
		i = encodeVarintAgent(data, i, uint64(m.Command.Size()))
		n19, err := m.Command.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n19
	}
	if m.Container != nil {
		data[i] = 0x1a
		i++
		i = encodeVarintAgent(data, i, uint64(m.Container.Size()))
		n20, err := m.Container.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n20
	}
	return i, nil
}

func (m *Call_AttachContainerInput) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Call_AttachContainerInput) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != nil {
		data[i] = 0x8
		i++
		i = encodeVarintAgent(data, i, uint64(*m.Type))
	}
	if m.ContainerId != nil {
		data[i] = 0x12
		i++
		i = encodeVarintAgent(data, i, uint64(m.ContainerId.Size()))
		n21, err := m.ContainerId.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n21
	}
	if m.ProcessIo != nil {
		data[i] = 0x1a
		i++
		i = encodeVarintAgent(data, i, uint64(m.ProcessIo.Size()))
		n22, err := m.ProcessIo.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n22
	}
	return i, nil
}

func (m *Call_AttachContainerOutput) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Call_AttachContainerOutput) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ContainerId == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("container_id")
	} else {
		data[i] = 0xa
		i++
		i = encodeVarintAgent(data, i, uint64(m.ContainerId.Size()))
		n23, err := m.ContainerId.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n23
	}
	return i, nil
}

func (m *Response) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Response) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != nil {
		data[i] = 0x8
		i++
		i = encodeVarintAgent(data, i, uint64(*m.Type))
	}
	if m.GetHealth != nil {
		data[i] = 0x12
		i++
		i = encodeVarintAgent(data, i, uint64(m.GetHealth.Size()))
		n24, err := m.GetHealth.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n24
	}
	if m.GetFlags != nil {
		data[i] = 0x1a
		i++
		i = encodeVarintAgent(data, i, uint64(m.GetFlags.Size()))
		n25, err := m.GetFlags.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n25
	}
	if m.GetVersion != nil {
		data[i] = 0x22
		i++
		i = encodeVarintAgent(data, i, uint64(m.GetVersion.Size()))
		n26, err := m.GetVersion.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n26
	}
	if m.GetMetrics != nil {
		data[i] = 0x2a
		i++
		i = encodeVarintAgent(data, i, uint64(m.GetMetrics.Size()))
		n27, err := m.GetMetrics.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n27
	}
	if m.GetLoggingLevel != nil {
		data[i] = 0x32
		i++
		i = encodeVarintAgent(data, i, uint64(m.GetLoggingLevel.Size()))
		n28, err := m.GetLoggingLevel.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n28
	}
	if m.ListFiles != nil {
		data[i] = 0x3a
		i++
		i = encodeVarintAgent(data, i, uint64(m.ListFiles.Size()))
		n29, err := m.ListFiles.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n29
	}
	if m.ReadFile != nil {
		data[i] = 0x42
		i++
		i = encodeVarintAgent(data, i, uint64(m.ReadFile.Size()))
		n30, err := m.ReadFile.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n30
	}
	if m.GetState != nil {
		data[i] = 0x4a
		i++
		i = encodeVarintAgent(data, i, uint64(m.GetState.Size()))
		n31, err := m.GetState.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n31
	}
	if m.GetContainers != nil {
		data[i] = 0x52
		i++
		i = encodeVarintAgent(data, i, uint64(m.GetContainers.Size()))
		n32, err := m.GetContainers.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n32
	}
	if m.GetFrameworks != nil {
		data[i] = 0x5a
		i++
		i = encodeVarintAgent(data, i, uint64(m.GetFrameworks.Size()))
		n33, err := m.GetFrameworks.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n33
	}
	if m.GetExecutors != nil {
		data[i] = 0x62
		i++
		i = encodeVarintAgent(data, i, uint64(m.GetExecutors.Size()))
		n34, err := m.GetExecutors.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n34
	}
	if m.GetTasks != nil {
		data[i] = 0x6a
		i++
		i = encodeVarintAgent(data, i, uint64(m.GetTasks.Size()))
		n35, err := m.GetTasks.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n35
	}
	if m.WaitNestedContainer != nil {
		data[i] = 0x72
		i++
		i = encodeVarintAgent(data, i, uint64(m.WaitNestedContainer.Size()))
		n36, err := m.WaitNestedContainer.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n36
	}
	return i, nil
}

func (m *Response_GetHealth) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Response_GetHealth) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Healthy == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("healthy")
	} else {
		data[i] = 0x8
		i++
		if *m.Healthy {
			data[i] = 1
		} else {
			data[i] = 0
		}
		i++
	}
	return i, nil
}

func (m *Response_GetFlags) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Response_GetFlags) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Flags) > 0 {
		for _, msg := range m.Flags {
			data[i] = 0xa
			i++
			i = encodeVarintAgent(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *Response_GetVersion) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Response_GetVersion) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.VersionInfo == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("version_info")
	} else {
		data[i] = 0xa
		i++
		i = encodeVarintAgent(data, i, uint64(m.VersionInfo.Size()))
		n37, err := m.VersionInfo.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n37
	}
	return i, nil
}

func (m *Response_GetMetrics) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Response_GetMetrics) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Metrics) > 0 {
		for _, msg := range m.Metrics {
			data[i] = 0xa
			i++
			i = encodeVarintAgent(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *Response_GetLoggingLevel) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Response_GetLoggingLevel) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Level == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("level")
	} else {
		data[i] = 0x8
		i++
		i = encodeVarintAgent(data, i, uint64(*m.Level))
	}
	return i, nil
}

func (m *Response_ListFiles) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Response_ListFiles) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.FileInfos) > 0 {
		for _, msg := range m.FileInfos {
			data[i] = 0xa
			i++
			i = encodeVarintAgent(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *Response_ReadFile) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Response_ReadFile) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	data[i] = 0x8
	i++
	i = encodeVarintAgent(data, i, uint64(m.Size_))
	if m.Data == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("data")
	} else {
		data[i] = 0x12
		i++
		i = encodeVarintAgent(data, i, uint64(len(m.Data)))
		i += copy(data[i:], m.Data)
	}
	return i, nil
}

func (m *Response_GetState) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Response_GetState) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.GetTasks != nil {
		data[i] = 0xa
		i++
		i = encodeVarintAgent(data, i, uint64(m.GetTasks.Size()))
		n38, err := m.GetTasks.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n38
	}
	if m.GetExecutors != nil {
		data[i] = 0x12
		i++
		i = encodeVarintAgent(data, i, uint64(m.GetExecutors.Size()))
		n39, err := m.GetExecutors.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n39
	}
	if m.GetFrameworks != nil {
		data[i] = 0x1a
		i++
		i = encodeVarintAgent(data, i, uint64(m.GetFrameworks.Size()))
		n40, err := m.GetFrameworks.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n40
	}
	return i, nil
}

func (m *Response_GetContainers) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Response_GetContainers) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Containers) > 0 {
		for _, msg := range m.Containers {
			data[i] = 0xa
			i++
			i = encodeVarintAgent(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *Response_GetContainers_Container) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Response_GetContainers_Container) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.FrameworkId == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("framework_id")
	} else {
		data[i] = 0xa
		i++
		i = encodeVarintAgent(data, i, uint64(m.FrameworkId.Size()))
		n41, err := m.FrameworkId.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n41
	}
	if m.ExecutorId == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("executor_id")
	} else {
		data[i] = 0x12
		i++
		i = encodeVarintAgent(data, i, uint64(m.ExecutorId.Size()))
		n42, err := m.ExecutorId.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n42
	}
	if m.ExecutorName == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("executor_name")
	} else {
		data[i] = 0x1a
		i++
		i = encodeVarintAgent(data, i, uint64(len(*m.ExecutorName)))
		i += copy(data[i:], *m.ExecutorName)
	}
	if m.ContainerId == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("container_id")
	} else {
		data[i] = 0x22
		i++
		i = encodeVarintAgent(data, i, uint64(m.ContainerId.Size()))
		n43, err := m.ContainerId.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n43
	}
	if m.ContainerStatus != nil {
		data[i] = 0x2a
		i++
		i = encodeVarintAgent(data, i, uint64(m.ContainerStatus.Size()))
		n44, err := m.ContainerStatus.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n44
	}
	if m.ResourceStatistics != nil {
		data[i] = 0x32
		i++
		i = encodeVarintAgent(data, i, uint64(m.ResourceStatistics.Size()))
		n45, err := m.ResourceStatistics.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n45
	}
	return i, nil
}

func (m *Response_GetFrameworks) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Response_GetFrameworks) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Frameworks) > 0 {
		for _, msg := range m.Frameworks {
			data[i] = 0xa
			i++
			i = encodeVarintAgent(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.CompletedFrameworks) > 0 {
		for _, msg := range m.CompletedFrameworks {
			data[i] = 0x12
			i++
			i = encodeVarintAgent(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *Response_GetFrameworks_Framework) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Response_GetFrameworks_Framework) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.FrameworkInfo == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("framework_info")
	} else {
		data[i] = 0xa
		i++
		i = encodeVarintAgent(data, i, uint64(m.FrameworkInfo.Size()))
		n46, err := m.FrameworkInfo.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n46
	}
	return i, nil
}

func (m *Response_GetExecutors) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Response_GetExecutors) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.Executors) > 0 {
		for _, msg := range m.Executors {
			data[i] = 0xa
			i++
			i = encodeVarintAgent(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.CompletedExecutors) > 0 {
		for _, msg := range m.CompletedExecutors {
			data[i] = 0x12
			i++
			i = encodeVarintAgent(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *Response_GetExecutors_Executor) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Response_GetExecutors_Executor) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ExecutorInfo == nil {
		return 0, github_com_gogo_protobuf_proto.NewRequiredNotSetError("executor_info")
	} else {
		data[i] = 0xa
		i++
		i = encodeVarintAgent(data, i, uint64(m.ExecutorInfo.Size()))
		n47, err := m.ExecutorInfo.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n47
	}
	return i, nil
}

func (m *Response_GetTasks) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Response_GetTasks) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if len(m.PendingTasks) > 0 {
		for _, msg := range m.PendingTasks {
			data[i] = 0xa
			i++
			i = encodeVarintAgent(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.QueuedTasks) > 0 {
		for _, msg := range m.QueuedTasks {
			data[i] = 0x12
			i++
			i = encodeVarintAgent(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.LaunchedTasks) > 0 {
		for _, msg := range m.LaunchedTasks {
			data[i] = 0x1a
			i++
			i = encodeVarintAgent(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.TerminatedTasks) > 0 {
		for _, msg := range m.TerminatedTasks {
			data[i] = 0x22
			i++
			i = encodeVarintAgent(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	if len(m.CompletedTasks) > 0 {
		for _, msg := range m.CompletedTasks {
			data[i] = 0x2a
			i++
			i = encodeVarintAgent(data, i, uint64(msg.Size()))
			n, err := msg.MarshalTo(data[i:])
			if err != nil {
				return 0, err
			}
			i += n
		}
	}
	return i, nil
}

func (m *Response_WaitNestedContainer) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *Response_WaitNestedContainer) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.ExitStatus != nil {
		data[i] = 0x8
		i++
		i = encodeVarintAgent(data, i, uint64(*m.ExitStatus))
	}
	return i, nil
}

func (m *ProcessIO) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *ProcessIO) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != nil {
		data[i] = 0x8
		i++
		i = encodeVarintAgent(data, i, uint64(*m.Type))
	}
	if m.Data != nil {
		data[i] = 0x12
		i++
		i = encodeVarintAgent(data, i, uint64(m.Data.Size()))
		n48, err := m.Data.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n48
	}
	if m.Control != nil {
		data[i] = 0x1a
		i++
		i = encodeVarintAgent(data, i, uint64(m.Control.Size()))
		n49, err := m.Control.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n49
	}
	return i, nil
}

func (m *ProcessIO_Data) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *ProcessIO_Data) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != nil {
		data[i] = 0x8
		i++
		i = encodeVarintAgent(data, i, uint64(*m.Type))
	}
	if m.Data != nil {
		data[i] = 0x12
		i++
		i = encodeVarintAgent(data, i, uint64(len(m.Data)))
		i += copy(data[i:], m.Data)
	}
	return i, nil
}

func (m *ProcessIO_Control) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *ProcessIO_Control) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Type != nil {
		data[i] = 0x8
		i++
		i = encodeVarintAgent(data, i, uint64(*m.Type))
	}
	if m.TtyInfo != nil {
		data[i] = 0x12
		i++
		i = encodeVarintAgent(data, i, uint64(m.TtyInfo.Size()))
		n50, err := m.TtyInfo.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n50
	}
	if m.Heartbeat != nil {
		data[i] = 0x1a
		i++
		i = encodeVarintAgent(data, i, uint64(m.Heartbeat.Size()))
		n51, err := m.Heartbeat.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n51
	}
	return i, nil
}

func (m *ProcessIO_Control_Heartbeat) Marshal() (data []byte, err error) {
	size := m.Size()
	data = make([]byte, size)
	n, err := m.MarshalTo(data)
	if err != nil {
		return nil, err
	}
	return data[:n], nil
}

func (m *ProcessIO_Control_Heartbeat) MarshalTo(data []byte) (int, error) {
	var i int
	_ = i
	var l int
	_ = l
	if m.Interval != nil {
		data[i] = 0xa
		i++
		i = encodeVarintAgent(data, i, uint64(m.Interval.Size()))
		n52, err := m.Interval.MarshalTo(data[i:])
		if err != nil {
			return 0, err
		}
		i += n52
	}
	return i, nil
}

func encodeFixed64Agent(data []byte, offset int, v uint64) int {
	data[offset] = uint8(v)
	data[offset+1] = uint8(v >> 8)
	data[offset+2] = uint8(v >> 16)
	data[offset+3] = uint8(v >> 24)
	data[offset+4] = uint8(v >> 32)
	data[offset+5] = uint8(v >> 40)
	data[offset+6] = uint8(v >> 48)
	data[offset+7] = uint8(v >> 56)
	return offset + 8
}
func encodeFixed32Agent(data []byte, offset int, v uint32) int {
	data[offset] = uint8(v)
	data[offset+1] = uint8(v >> 8)
	data[offset+2] = uint8(v >> 16)
	data[offset+3] = uint8(v >> 24)
	return offset + 4
}
func encodeVarintAgent(data []byte, offset int, v uint64) int {
	for v >= 1<<7 {
		data[offset] = uint8(v&0x7f | 0x80)
		v >>= 7
		offset++
	}
	data[offset] = uint8(v)
	return offset + 1
}
func NewPopulatedCall(r randyAgent, easy bool) *Call {
	this := &Call{}
	if r.Intn(10) != 0 {
		v1 := Call_Type([]int32{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19}[r.Intn(20)])
		this.Type = &v1
	}
	if r.Intn(10) != 0 {
		this.GetMetrics = NewPopulatedCall_GetMetrics(r, easy)
	}
	if r.Intn(10) != 0 {
		this.SetLoggingLevel = NewPopulatedCall_SetLoggingLevel(r, easy)
	}
	if r.Intn(10) != 0 {
		this.ListFiles = NewPopulatedCall_ListFiles(r, easy)
	}
	if r.Intn(10) != 0 {
		this.ReadFile = NewPopulatedCall_ReadFile(r, easy)
	}
	if r.Intn(10) != 0 {
		this.LaunchNestedContainer = NewPopulatedCall_LaunchNestedContainer(r, easy)
	}
	if r.Intn(10) != 0 {
		this.WaitNestedContainer = NewPopulatedCall_WaitNestedContainer(r, easy)
	}
	if r.Intn(10) != 0 {
		this.KillNestedContainer = NewPopulatedCall_KillNestedContainer(r, easy)
	}
	if r.Intn(10) != 0 {
		this.LaunchNestedContainerSession = NewPopulatedCall_LaunchNestedContainerSession(r, easy)
	}
	if r.Intn(10) != 0 {
		this.AttachContainerInput = NewPopulatedCall_AttachContainerInput(r, easy)
	}
	if r.Intn(10) != 0 {
		this.AttachContainerOutput = NewPopulatedCall_AttachContainerOutput(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedCall_GetMetrics(r randyAgent, easy bool) *Call_GetMetrics {
	this := &Call_GetMetrics{}
	if r.Intn(10) != 0 {
		this.Timeout = mesos.NewPopulatedDurationInfo(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedCall_SetLoggingLevel(r randyAgent, easy bool) *Call_SetLoggingLevel {
	this := &Call_SetLoggingLevel{}
	v2 := uint32(r.Uint32())
	this.Level = &v2
	this.Duration = mesos.NewPopulatedDurationInfo(r, easy)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedCall_ListFiles(r randyAgent, easy bool) *Call_ListFiles {
	this := &Call_ListFiles{}
	v3 := randStringAgent(r)
	this.Path = &v3
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedCall_ReadFile(r randyAgent, easy bool) *Call_ReadFile {
	this := &Call_ReadFile{}
	this.Path = randStringAgent(r)
	this.Offset = uint64(uint64(r.Uint32()))
	this.Length = uint64(uint64(r.Uint32()))
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedCall_LaunchNestedContainer(r randyAgent, easy bool) *Call_LaunchNestedContainer {
	this := &Call_LaunchNestedContainer{}
	this.ContainerId = mesos.NewPopulatedContainerID(r, easy)
	if r.Intn(10) != 0 {
		this.Command = mesos.NewPopulatedCommandInfo(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Container = mesos.NewPopulatedContainerInfo(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedCall_WaitNestedContainer(r randyAgent, easy bool) *Call_WaitNestedContainer {
	this := &Call_WaitNestedContainer{}
	this.ContainerId = mesos.NewPopulatedContainerID(r, easy)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedCall_KillNestedContainer(r randyAgent, easy bool) *Call_KillNestedContainer {
	this := &Call_KillNestedContainer{}
	this.ContainerId = mesos.NewPopulatedContainerID(r, easy)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedCall_LaunchNestedContainerSession(r randyAgent, easy bool) *Call_LaunchNestedContainerSession {
	this := &Call_LaunchNestedContainerSession{}
	this.ContainerId = mesos.NewPopulatedContainerID(r, easy)
	if r.Intn(10) != 0 {
		this.Command = mesos.NewPopulatedCommandInfo(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Container = mesos.NewPopulatedContainerInfo(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedCall_AttachContainerInput(r randyAgent, easy bool) *Call_AttachContainerInput {
	this := &Call_AttachContainerInput{}
	if r.Intn(10) != 0 {
		v4 := Call_AttachContainerInput_Type([]int32{0, 1, 2}[r.Intn(3)])
		this.Type = &v4
	}
	if r.Intn(10) != 0 {
		this.ContainerId = mesos.NewPopulatedContainerID(r, easy)
	}
	if r.Intn(10) != 0 {
		this.ProcessIo = NewPopulatedProcessIO(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedCall_AttachContainerOutput(r randyAgent, easy bool) *Call_AttachContainerOutput {
	this := &Call_AttachContainerOutput{}
	this.ContainerId = mesos.NewPopulatedContainerID(r, easy)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedResponse(r randyAgent, easy bool) *Response {
	this := &Response{}
	if r.Intn(10) != 0 {
		v5 := Response_Type([]int32{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13}[r.Intn(14)])
		this.Type = &v5
	}
	if r.Intn(10) != 0 {
		this.GetHealth = NewPopulatedResponse_GetHealth(r, easy)
	}
	if r.Intn(10) != 0 {
		this.GetFlags = NewPopulatedResponse_GetFlags(r, easy)
	}
	if r.Intn(10) != 0 {
		this.GetVersion = NewPopulatedResponse_GetVersion(r, easy)
	}
	if r.Intn(10) != 0 {
		this.GetMetrics = NewPopulatedResponse_GetMetrics(r, easy)
	}
	if r.Intn(10) != 0 {
		this.GetLoggingLevel = NewPopulatedResponse_GetLoggingLevel(r, easy)
	}
	if r.Intn(10) != 0 {
		this.ListFiles = NewPopulatedResponse_ListFiles(r, easy)
	}
	if r.Intn(10) != 0 {
		this.ReadFile = NewPopulatedResponse_ReadFile(r, easy)
	}
	if r.Intn(10) != 0 {
		this.GetState = NewPopulatedResponse_GetState(r, easy)
	}
	if r.Intn(10) != 0 {
		this.GetContainers = NewPopulatedResponse_GetContainers(r, easy)
	}
	if r.Intn(10) != 0 {
		this.GetFrameworks = NewPopulatedResponse_GetFrameworks(r, easy)
	}
	if r.Intn(10) != 0 {
		this.GetExecutors = NewPopulatedResponse_GetExecutors(r, easy)
	}
	if r.Intn(10) != 0 {
		this.GetTasks = NewPopulatedResponse_GetTasks(r, easy)
	}
	if r.Intn(10) != 0 {
		this.WaitNestedContainer = NewPopulatedResponse_WaitNestedContainer(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedResponse_GetHealth(r randyAgent, easy bool) *Response_GetHealth {
	this := &Response_GetHealth{}
	v6 := bool(bool(r.Intn(2) == 0))
	this.Healthy = &v6
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedResponse_GetFlags(r randyAgent, easy bool) *Response_GetFlags {
	this := &Response_GetFlags{}
	if r.Intn(10) != 0 {
		v7 := r.Intn(10)
		this.Flags = make([]*mesos.Flag, v7)
		for i := 0; i < v7; i++ {
			this.Flags[i] = mesos.NewPopulatedFlag(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedResponse_GetVersion(r randyAgent, easy bool) *Response_GetVersion {
	this := &Response_GetVersion{}
	this.VersionInfo = mesos.NewPopulatedVersionInfo(r, easy)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedResponse_GetMetrics(r randyAgent, easy bool) *Response_GetMetrics {
	this := &Response_GetMetrics{}
	if r.Intn(10) != 0 {
		v8 := r.Intn(10)
		this.Metrics = make([]*mesos.Metric, v8)
		for i := 0; i < v8; i++ {
			this.Metrics[i] = mesos.NewPopulatedMetric(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedResponse_GetLoggingLevel(r randyAgent, easy bool) *Response_GetLoggingLevel {
	this := &Response_GetLoggingLevel{}
	v9 := uint32(r.Uint32())
	this.Level = &v9
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedResponse_ListFiles(r randyAgent, easy bool) *Response_ListFiles {
	this := &Response_ListFiles{}
	if r.Intn(10) != 0 {
		v10 := r.Intn(10)
		this.FileInfos = make([]*mesos.FileInfo, v10)
		for i := 0; i < v10; i++ {
			this.FileInfos[i] = mesos.NewPopulatedFileInfo(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedResponse_ReadFile(r randyAgent, easy bool) *Response_ReadFile {
	this := &Response_ReadFile{}
	this.Size_ = uint64(uint64(r.Uint32()))
	v11 := r.Intn(100)
	this.Data = make([]byte, v11)
	for i := 0; i < v11; i++ {
		this.Data[i] = byte(r.Intn(256))
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedResponse_GetState(r randyAgent, easy bool) *Response_GetState {
	this := &Response_GetState{}
	if r.Intn(10) != 0 {
		this.GetTasks = NewPopulatedResponse_GetTasks(r, easy)
	}
	if r.Intn(10) != 0 {
		this.GetExecutors = NewPopulatedResponse_GetExecutors(r, easy)
	}
	if r.Intn(10) != 0 {
		this.GetFrameworks = NewPopulatedResponse_GetFrameworks(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedResponse_GetContainers(r randyAgent, easy bool) *Response_GetContainers {
	this := &Response_GetContainers{}
	if r.Intn(10) != 0 {
		v12 := r.Intn(10)
		this.Containers = make([]*Response_GetContainers_Container, v12)
		for i := 0; i < v12; i++ {
			this.Containers[i] = NewPopulatedResponse_GetContainers_Container(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedResponse_GetContainers_Container(r randyAgent, easy bool) *Response_GetContainers_Container {
	this := &Response_GetContainers_Container{}
	this.FrameworkId = mesos.NewPopulatedFrameworkID(r, easy)
	this.ExecutorId = mesos.NewPopulatedExecutorID(r, easy)
	v13 := randStringAgent(r)
	this.ExecutorName = &v13
	this.ContainerId = mesos.NewPopulatedContainerID(r, easy)
	if r.Intn(10) != 0 {
		this.ContainerStatus = mesos.NewPopulatedContainerStatus(r, easy)
	}
	if r.Intn(10) != 0 {
		this.ResourceStatistics = mesos.NewPopulatedResourceStatistics(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedResponse_GetFrameworks(r randyAgent, easy bool) *Response_GetFrameworks {
	this := &Response_GetFrameworks{}
	if r.Intn(10) != 0 {
		v14 := r.Intn(10)
		this.Frameworks = make([]*Response_GetFrameworks_Framework, v14)
		for i := 0; i < v14; i++ {
			this.Frameworks[i] = NewPopulatedResponse_GetFrameworks_Framework(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v15 := r.Intn(10)
		this.CompletedFrameworks = make([]*Response_GetFrameworks_Framework, v15)
		for i := 0; i < v15; i++ {
			this.CompletedFrameworks[i] = NewPopulatedResponse_GetFrameworks_Framework(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedResponse_GetFrameworks_Framework(r randyAgent, easy bool) *Response_GetFrameworks_Framework {
	this := &Response_GetFrameworks_Framework{}
	this.FrameworkInfo = mesos.NewPopulatedFrameworkInfo(r, easy)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedResponse_GetExecutors(r randyAgent, easy bool) *Response_GetExecutors {
	this := &Response_GetExecutors{}
	if r.Intn(10) != 0 {
		v16 := r.Intn(10)
		this.Executors = make([]*Response_GetExecutors_Executor, v16)
		for i := 0; i < v16; i++ {
			this.Executors[i] = NewPopulatedResponse_GetExecutors_Executor(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v17 := r.Intn(10)
		this.CompletedExecutors = make([]*Response_GetExecutors_Executor, v17)
		for i := 0; i < v17; i++ {
			this.CompletedExecutors[i] = NewPopulatedResponse_GetExecutors_Executor(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedResponse_GetExecutors_Executor(r randyAgent, easy bool) *Response_GetExecutors_Executor {
	this := &Response_GetExecutors_Executor{}
	this.ExecutorInfo = mesos.NewPopulatedExecutorInfo(r, easy)
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedResponse_GetTasks(r randyAgent, easy bool) *Response_GetTasks {
	this := &Response_GetTasks{}
	if r.Intn(10) != 0 {
		v18 := r.Intn(10)
		this.PendingTasks = make([]*mesos.Task, v18)
		for i := 0; i < v18; i++ {
			this.PendingTasks[i] = mesos.NewPopulatedTask(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v19 := r.Intn(10)
		this.QueuedTasks = make([]*mesos.Task, v19)
		for i := 0; i < v19; i++ {
			this.QueuedTasks[i] = mesos.NewPopulatedTask(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v20 := r.Intn(10)
		this.LaunchedTasks = make([]*mesos.Task, v20)
		for i := 0; i < v20; i++ {
			this.LaunchedTasks[i] = mesos.NewPopulatedTask(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v21 := r.Intn(10)
		this.TerminatedTasks = make([]*mesos.Task, v21)
		for i := 0; i < v21; i++ {
			this.TerminatedTasks[i] = mesos.NewPopulatedTask(r, easy)
		}
	}
	if r.Intn(10) != 0 {
		v22 := r.Intn(10)
		this.CompletedTasks = make([]*mesos.Task, v22)
		for i := 0; i < v22; i++ {
			this.CompletedTasks[i] = mesos.NewPopulatedTask(r, easy)
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedResponse_WaitNestedContainer(r randyAgent, easy bool) *Response_WaitNestedContainer {
	this := &Response_WaitNestedContainer{}
	if r.Intn(10) != 0 {
		v23 := int32(r.Int31())
		if r.Intn(2) == 0 {
			v23 *= -1
		}
		this.ExitStatus = &v23
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedProcessIO(r randyAgent, easy bool) *ProcessIO {
	this := &ProcessIO{}
	if r.Intn(10) != 0 {
		v24 := ProcessIO_Type([]int32{0, 1, 2}[r.Intn(3)])
		this.Type = &v24
	}
	if r.Intn(10) != 0 {
		this.Data = NewPopulatedProcessIO_Data(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Control = NewPopulatedProcessIO_Control(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedProcessIO_Data(r randyAgent, easy bool) *ProcessIO_Data {
	this := &ProcessIO_Data{}
	if r.Intn(10) != 0 {
		v25 := ProcessIO_Data_Type([]int32{0, 1, 2, 3}[r.Intn(4)])
		this.Type = &v25
	}
	if r.Intn(10) != 0 {
		v26 := r.Intn(100)
		this.Data = make([]byte, v26)
		for i := 0; i < v26; i++ {
			this.Data[i] = byte(r.Intn(256))
		}
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedProcessIO_Control(r randyAgent, easy bool) *ProcessIO_Control {
	this := &ProcessIO_Control{}
	if r.Intn(10) != 0 {
		v27 := ProcessIO_Control_Type([]int32{0, 1, 2}[r.Intn(3)])
		this.Type = &v27
	}
	if r.Intn(10) != 0 {
		this.TtyInfo = mesos.NewPopulatedTTYInfo(r, easy)
	}
	if r.Intn(10) != 0 {
		this.Heartbeat = NewPopulatedProcessIO_Control_Heartbeat(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

func NewPopulatedProcessIO_Control_Heartbeat(r randyAgent, easy bool) *ProcessIO_Control_Heartbeat {
	this := &ProcessIO_Control_Heartbeat{}
	if r.Intn(10) != 0 {
		this.Interval = mesos.NewPopulatedDurationInfo(r, easy)
	}
	if !easy && r.Intn(10) != 0 {
	}
	return this
}

type randyAgent interface {
	Float32() float32
	Float64() float64
	Int63() int64
	Int31() int32
	Uint32() uint32
	Intn(n int) int
}

func randUTF8RuneAgent(r randyAgent) rune {
	ru := r.Intn(62)
	if ru < 10 {
		return rune(ru + 48)
	} else if ru < 36 {
		return rune(ru + 55)
	}
	return rune(ru + 61)
}
func randStringAgent(r randyAgent) string {
	v28 := r.Intn(100)
	tmps := make([]rune, v28)
	for i := 0; i < v28; i++ {
		tmps[i] = randUTF8RuneAgent(r)
	}
	return string(tmps)
}
func randUnrecognizedAgent(r randyAgent, maxFieldNumber int) (data []byte) {
	l := r.Intn(5)
	for i := 0; i < l; i++ {
		wire := r.Intn(4)
		if wire == 3 {
			wire = 5
		}
		fieldNumber := maxFieldNumber + r.Intn(100)
		data = randFieldAgent(data, r, fieldNumber, wire)
	}
	return data
}
func randFieldAgent(data []byte, r randyAgent, fieldNumber int, wire int) []byte {
	key := uint32(fieldNumber)<<3 | uint32(wire)
	switch wire {
	case 0:
		data = encodeVarintPopulateAgent(data, uint64(key))
		v29 := r.Int63()
		if r.Intn(2) == 0 {
			v29 *= -1
		}
		data = encodeVarintPopulateAgent(data, uint64(v29))
	case 1:
		data = encodeVarintPopulateAgent(data, uint64(key))
		data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	case 2:
		data = encodeVarintPopulateAgent(data, uint64(key))
		ll := r.Intn(100)
		data = encodeVarintPopulateAgent(data, uint64(ll))
		for j := 0; j < ll; j++ {
			data = append(data, byte(r.Intn(256)))
		}
	default:
		data = encodeVarintPopulateAgent(data, uint64(key))
		data = append(data, byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)), byte(r.Intn(256)))
	}
	return data
}
func encodeVarintPopulateAgent(data []byte, v uint64) []byte {
	for v >= 1<<7 {
		data = append(data, uint8(uint64(v)&0x7f|0x80))
		v >>= 7
	}
	data = append(data, uint8(v))
	return data
}
func (m *Call) Size() (n int) {
	var l int
	_ = l
	if m.Type != nil {
		n += 1 + sovAgent(uint64(*m.Type))
	}
	if m.GetMetrics != nil {
		l = m.GetMetrics.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.SetLoggingLevel != nil {
		l = m.SetLoggingLevel.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.ListFiles != nil {
		l = m.ListFiles.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.ReadFile != nil {
		l = m.ReadFile.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.LaunchNestedContainer != nil {
		l = m.LaunchNestedContainer.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.WaitNestedContainer != nil {
		l = m.WaitNestedContainer.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.KillNestedContainer != nil {
		l = m.KillNestedContainer.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.LaunchNestedContainerSession != nil {
		l = m.LaunchNestedContainerSession.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.AttachContainerInput != nil {
		l = m.AttachContainerInput.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.AttachContainerOutput != nil {
		l = m.AttachContainerOutput.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *Call_GetMetrics) Size() (n int) {
	var l int
	_ = l
	if m.Timeout != nil {
		l = m.Timeout.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *Call_SetLoggingLevel) Size() (n int) {
	var l int
	_ = l
	if m.Level != nil {
		n += 1 + sovAgent(uint64(*m.Level))
	}
	if m.Duration != nil {
		l = m.Duration.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *Call_ListFiles) Size() (n int) {
	var l int
	_ = l
	if m.Path != nil {
		l = len(*m.Path)
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *Call_ReadFile) Size() (n int) {
	var l int
	_ = l
	l = len(m.Path)
	n += 1 + l + sovAgent(uint64(l))
	n += 1 + sovAgent(uint64(m.Offset))
	n += 1 + sovAgent(uint64(m.Length))
	return n
}

func (m *Call_LaunchNestedContainer) Size() (n int) {
	var l int
	_ = l
	if m.ContainerId != nil {
		l = m.ContainerId.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Command != nil {
		l = m.Command.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Container != nil {
		l = m.Container.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *Call_WaitNestedContainer) Size() (n int) {
	var l int
	_ = l
	if m.ContainerId != nil {
		l = m.ContainerId.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *Call_KillNestedContainer) Size() (n int) {
	var l int
	_ = l
	if m.ContainerId != nil {
		l = m.ContainerId.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *Call_LaunchNestedContainerSession) Size() (n int) {
	var l int
	_ = l
	if m.ContainerId != nil {
		l = m.ContainerId.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Command != nil {
		l = m.Command.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Container != nil {
		l = m.Container.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *Call_AttachContainerInput) Size() (n int) {
	var l int
	_ = l
	if m.Type != nil {
		n += 1 + sovAgent(uint64(*m.Type))
	}
	if m.ContainerId != nil {
		l = m.ContainerId.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.ProcessIo != nil {
		l = m.ProcessIo.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *Call_AttachContainerOutput) Size() (n int) {
	var l int
	_ = l
	if m.ContainerId != nil {
		l = m.ContainerId.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *Response) Size() (n int) {
	var l int
	_ = l
	if m.Type != nil {
		n += 1 + sovAgent(uint64(*m.Type))
	}
	if m.GetHealth != nil {
		l = m.GetHealth.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.GetFlags != nil {
		l = m.GetFlags.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.GetVersion != nil {
		l = m.GetVersion.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.GetMetrics != nil {
		l = m.GetMetrics.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.GetLoggingLevel != nil {
		l = m.GetLoggingLevel.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.ListFiles != nil {
		l = m.ListFiles.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.ReadFile != nil {
		l = m.ReadFile.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.GetState != nil {
		l = m.GetState.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.GetContainers != nil {
		l = m.GetContainers.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.GetFrameworks != nil {
		l = m.GetFrameworks.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.GetExecutors != nil {
		l = m.GetExecutors.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.GetTasks != nil {
		l = m.GetTasks.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.WaitNestedContainer != nil {
		l = m.WaitNestedContainer.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *Response_GetHealth) Size() (n int) {
	var l int
	_ = l
	if m.Healthy != nil {
		n += 2
	}
	return n
}

func (m *Response_GetFlags) Size() (n int) {
	var l int
	_ = l
	if len(m.Flags) > 0 {
		for _, e := range m.Flags {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	return n
}

func (m *Response_GetVersion) Size() (n int) {
	var l int
	_ = l
	if m.VersionInfo != nil {
		l = m.VersionInfo.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *Response_GetMetrics) Size() (n int) {
	var l int
	_ = l
	if len(m.Metrics) > 0 {
		for _, e := range m.Metrics {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	return n
}

func (m *Response_GetLoggingLevel) Size() (n int) {
	var l int
	_ = l
	if m.Level != nil {
		n += 1 + sovAgent(uint64(*m.Level))
	}
	return n
}

func (m *Response_ListFiles) Size() (n int) {
	var l int
	_ = l
	if len(m.FileInfos) > 0 {
		for _, e := range m.FileInfos {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	return n
}

func (m *Response_ReadFile) Size() (n int) {
	var l int
	_ = l
	n += 1 + sovAgent(uint64(m.Size_))
	if m.Data != nil {
		l = len(m.Data)
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *Response_GetState) Size() (n int) {
	var l int
	_ = l
	if m.GetTasks != nil {
		l = m.GetTasks.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.GetExecutors != nil {
		l = m.GetExecutors.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.GetFrameworks != nil {
		l = m.GetFrameworks.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *Response_GetContainers) Size() (n int) {
	var l int
	_ = l
	if len(m.Containers) > 0 {
		for _, e := range m.Containers {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	return n
}

func (m *Response_GetContainers_Container) Size() (n int) {
	var l int
	_ = l
	if m.FrameworkId != nil {
		l = m.FrameworkId.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.ExecutorId != nil {
		l = m.ExecutorId.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.ExecutorName != nil {
		l = len(*m.ExecutorName)
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.ContainerId != nil {
		l = m.ContainerId.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.ContainerStatus != nil {
		l = m.ContainerStatus.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.ResourceStatistics != nil {
		l = m.ResourceStatistics.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *Response_GetFrameworks) Size() (n int) {
	var l int
	_ = l
	if len(m.Frameworks) > 0 {
		for _, e := range m.Frameworks {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	if len(m.CompletedFrameworks) > 0 {
		for _, e := range m.CompletedFrameworks {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	return n
}

func (m *Response_GetFrameworks_Framework) Size() (n int) {
	var l int
	_ = l
	if m.FrameworkInfo != nil {
		l = m.FrameworkInfo.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *Response_GetExecutors) Size() (n int) {
	var l int
	_ = l
	if len(m.Executors) > 0 {
		for _, e := range m.Executors {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	if len(m.CompletedExecutors) > 0 {
		for _, e := range m.CompletedExecutors {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	return n
}

func (m *Response_GetExecutors_Executor) Size() (n int) {
	var l int
	_ = l
	if m.ExecutorInfo != nil {
		l = m.ExecutorInfo.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *Response_GetTasks) Size() (n int) {
	var l int
	_ = l
	if len(m.PendingTasks) > 0 {
		for _, e := range m.PendingTasks {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	if len(m.QueuedTasks) > 0 {
		for _, e := range m.QueuedTasks {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	if len(m.LaunchedTasks) > 0 {
		for _, e := range m.LaunchedTasks {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	if len(m.TerminatedTasks) > 0 {
		for _, e := range m.TerminatedTasks {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	if len(m.CompletedTasks) > 0 {
		for _, e := range m.CompletedTasks {
			l = e.Size()
			n += 1 + l + sovAgent(uint64(l))
		}
	}
	return n
}

func (m *Response_WaitNestedContainer) Size() (n int) {
	var l int
	_ = l
	if m.ExitStatus != nil {
		n += 1 + sovAgent(uint64(*m.ExitStatus))
	}
	return n
}

func (m *ProcessIO) Size() (n int) {
	var l int
	_ = l
	if m.Type != nil {
		n += 1 + sovAgent(uint64(*m.Type))
	}
	if m.Data != nil {
		l = m.Data.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Control != nil {
		l = m.Control.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *ProcessIO_Data) Size() (n int) {
	var l int
	_ = l
	if m.Type != nil {
		n += 1 + sovAgent(uint64(*m.Type))
	}
	if m.Data != nil {
		l = len(m.Data)
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *ProcessIO_Control) Size() (n int) {
	var l int
	_ = l
	if m.Type != nil {
		n += 1 + sovAgent(uint64(*m.Type))
	}
	if m.TtyInfo != nil {
		l = m.TtyInfo.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	if m.Heartbeat != nil {
		l = m.Heartbeat.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func (m *ProcessIO_Control_Heartbeat) Size() (n int) {
	var l int
	_ = l
	if m.Interval != nil {
		l = m.Interval.Size()
		n += 1 + l + sovAgent(uint64(l))
	}
	return n
}

func sovAgent(x uint64) (n int) {
	for {
		n++
		x >>= 7
		if x == 0 {
			break
		}
	}
	return n
}
func sozAgent(x uint64) (n int) {
	return sovAgent(uint64((x << 1) ^ uint64((int64(x) >> 63))))
}
func (this *Call) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Call{`,
		`Type:` + valueToStringAgent(this.Type) + `,`,
		`GetMetrics:` + strings.Replace(fmt.Sprintf("%v", this.GetMetrics), "Call_GetMetrics", "Call_GetMetrics", 1) + `,`,
		`SetLoggingLevel:` + strings.Replace(fmt.Sprintf("%v", this.SetLoggingLevel), "Call_SetLoggingLevel", "Call_SetLoggingLevel", 1) + `,`,
		`ListFiles:` + strings.Replace(fmt.Sprintf("%v", this.ListFiles), "Call_ListFiles", "Call_ListFiles", 1) + `,`,
		`ReadFile:` + strings.Replace(fmt.Sprintf("%v", this.ReadFile), "Call_ReadFile", "Call_ReadFile", 1) + `,`,
		`LaunchNestedContainer:` + strings.Replace(fmt.Sprintf("%v", this.LaunchNestedContainer), "Call_LaunchNestedContainer", "Call_LaunchNestedContainer", 1) + `,`,
		`WaitNestedContainer:` + strings.Replace(fmt.Sprintf("%v", this.WaitNestedContainer), "Call_WaitNestedContainer", "Call_WaitNestedContainer", 1) + `,`,
		`KillNestedContainer:` + strings.Replace(fmt.Sprintf("%v", this.KillNestedContainer), "Call_KillNestedContainer", "Call_KillNestedContainer", 1) + `,`,
		`LaunchNestedContainerSession:` + strings.Replace(fmt.Sprintf("%v", this.LaunchNestedContainerSession), "Call_LaunchNestedContainerSession", "Call_LaunchNestedContainerSession", 1) + `,`,
		`AttachContainerInput:` + strings.Replace(fmt.Sprintf("%v", this.AttachContainerInput), "Call_AttachContainerInput", "Call_AttachContainerInput", 1) + `,`,
		`AttachContainerOutput:` + strings.Replace(fmt.Sprintf("%v", this.AttachContainerOutput), "Call_AttachContainerOutput", "Call_AttachContainerOutput", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Call_GetMetrics) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Call_GetMetrics{`,
		`Timeout:` + strings.Replace(fmt.Sprintf("%v", this.Timeout), "DurationInfo", "mesos.DurationInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Call_SetLoggingLevel) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Call_SetLoggingLevel{`,
		`Level:` + valueToStringAgent(this.Level) + `,`,
		`Duration:` + strings.Replace(fmt.Sprintf("%v", this.Duration), "DurationInfo", "mesos.DurationInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Call_ListFiles) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Call_ListFiles{`,
		`Path:` + valueToStringAgent(this.Path) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Call_ReadFile) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Call_ReadFile{`,
		`Path:` + fmt.Sprintf("%v", this.Path) + `,`,
		`Offset:` + fmt.Sprintf("%v", this.Offset) + `,`,
		`Length:` + fmt.Sprintf("%v", this.Length) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Call_LaunchNestedContainer) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Call_LaunchNestedContainer{`,
		`ContainerId:` + strings.Replace(fmt.Sprintf("%v", this.ContainerId), "ContainerID", "mesos.ContainerID", 1) + `,`,
		`Command:` + strings.Replace(fmt.Sprintf("%v", this.Command), "CommandInfo", "mesos.CommandInfo", 1) + `,`,
		`Container:` + strings.Replace(fmt.Sprintf("%v", this.Container), "ContainerInfo", "mesos.ContainerInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Call_WaitNestedContainer) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Call_WaitNestedContainer{`,
		`ContainerId:` + strings.Replace(fmt.Sprintf("%v", this.ContainerId), "ContainerID", "mesos.ContainerID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Call_KillNestedContainer) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Call_KillNestedContainer{`,
		`ContainerId:` + strings.Replace(fmt.Sprintf("%v", this.ContainerId), "ContainerID", "mesos.ContainerID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Call_LaunchNestedContainerSession) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Call_LaunchNestedContainerSession{`,
		`ContainerId:` + strings.Replace(fmt.Sprintf("%v", this.ContainerId), "ContainerID", "mesos.ContainerID", 1) + `,`,
		`Command:` + strings.Replace(fmt.Sprintf("%v", this.Command), "CommandInfo", "mesos.CommandInfo", 1) + `,`,
		`Container:` + strings.Replace(fmt.Sprintf("%v", this.Container), "ContainerInfo", "mesos.ContainerInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Call_AttachContainerInput) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Call_AttachContainerInput{`,
		`Type:` + valueToStringAgent(this.Type) + `,`,
		`ContainerId:` + strings.Replace(fmt.Sprintf("%v", this.ContainerId), "ContainerID", "mesos.ContainerID", 1) + `,`,
		`ProcessIo:` + strings.Replace(fmt.Sprintf("%v", this.ProcessIo), "ProcessIO", "ProcessIO", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Call_AttachContainerOutput) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Call_AttachContainerOutput{`,
		`ContainerId:` + strings.Replace(fmt.Sprintf("%v", this.ContainerId), "ContainerID", "mesos.ContainerID", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response{`,
		`Type:` + valueToStringAgent(this.Type) + `,`,
		`GetHealth:` + strings.Replace(fmt.Sprintf("%v", this.GetHealth), "Response_GetHealth", "Response_GetHealth", 1) + `,`,
		`GetFlags:` + strings.Replace(fmt.Sprintf("%v", this.GetFlags), "Response_GetFlags", "Response_GetFlags", 1) + `,`,
		`GetVersion:` + strings.Replace(fmt.Sprintf("%v", this.GetVersion), "Response_GetVersion", "Response_GetVersion", 1) + `,`,
		`GetMetrics:` + strings.Replace(fmt.Sprintf("%v", this.GetMetrics), "Response_GetMetrics", "Response_GetMetrics", 1) + `,`,
		`GetLoggingLevel:` + strings.Replace(fmt.Sprintf("%v", this.GetLoggingLevel), "Response_GetLoggingLevel", "Response_GetLoggingLevel", 1) + `,`,
		`ListFiles:` + strings.Replace(fmt.Sprintf("%v", this.ListFiles), "Response_ListFiles", "Response_ListFiles", 1) + `,`,
		`ReadFile:` + strings.Replace(fmt.Sprintf("%v", this.ReadFile), "Response_ReadFile", "Response_ReadFile", 1) + `,`,
		`GetState:` + strings.Replace(fmt.Sprintf("%v", this.GetState), "Response_GetState", "Response_GetState", 1) + `,`,
		`GetContainers:` + strings.Replace(fmt.Sprintf("%v", this.GetContainers), "Response_GetContainers", "Response_GetContainers", 1) + `,`,
		`GetFrameworks:` + strings.Replace(fmt.Sprintf("%v", this.GetFrameworks), "Response_GetFrameworks", "Response_GetFrameworks", 1) + `,`,
		`GetExecutors:` + strings.Replace(fmt.Sprintf("%v", this.GetExecutors), "Response_GetExecutors", "Response_GetExecutors", 1) + `,`,
		`GetTasks:` + strings.Replace(fmt.Sprintf("%v", this.GetTasks), "Response_GetTasks", "Response_GetTasks", 1) + `,`,
		`WaitNestedContainer:` + strings.Replace(fmt.Sprintf("%v", this.WaitNestedContainer), "Response_WaitNestedContainer", "Response_WaitNestedContainer", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response_GetHealth) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response_GetHealth{`,
		`Healthy:` + valueToStringAgent(this.Healthy) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response_GetFlags) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response_GetFlags{`,
		`Flags:` + strings.Replace(fmt.Sprintf("%v", this.Flags), "Flag", "mesos.Flag", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response_GetVersion) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response_GetVersion{`,
		`VersionInfo:` + strings.Replace(fmt.Sprintf("%v", this.VersionInfo), "VersionInfo", "mesos.VersionInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response_GetMetrics) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response_GetMetrics{`,
		`Metrics:` + strings.Replace(fmt.Sprintf("%v", this.Metrics), "Metric", "mesos.Metric", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response_GetLoggingLevel) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response_GetLoggingLevel{`,
		`Level:` + valueToStringAgent(this.Level) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response_ListFiles) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response_ListFiles{`,
		`FileInfos:` + strings.Replace(fmt.Sprintf("%v", this.FileInfos), "FileInfo", "mesos.FileInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response_ReadFile) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response_ReadFile{`,
		`Size_:` + fmt.Sprintf("%v", this.Size_) + `,`,
		`Data:` + valueToStringAgent(this.Data) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response_GetState) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response_GetState{`,
		`GetTasks:` + strings.Replace(fmt.Sprintf("%v", this.GetTasks), "Response_GetTasks", "Response_GetTasks", 1) + `,`,
		`GetExecutors:` + strings.Replace(fmt.Sprintf("%v", this.GetExecutors), "Response_GetExecutors", "Response_GetExecutors", 1) + `,`,
		`GetFrameworks:` + strings.Replace(fmt.Sprintf("%v", this.GetFrameworks), "Response_GetFrameworks", "Response_GetFrameworks", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response_GetContainers) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response_GetContainers{`,
		`Containers:` + strings.Replace(fmt.Sprintf("%v", this.Containers), "Response_GetContainers_Container", "Response_GetContainers_Container", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response_GetContainers_Container) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response_GetContainers_Container{`,
		`FrameworkId:` + strings.Replace(fmt.Sprintf("%v", this.FrameworkId), "FrameworkID", "mesos.FrameworkID", 1) + `,`,
		`ExecutorId:` + strings.Replace(fmt.Sprintf("%v", this.ExecutorId), "ExecutorID", "mesos.ExecutorID", 1) + `,`,
		`ExecutorName:` + valueToStringAgent(this.ExecutorName) + `,`,
		`ContainerId:` + strings.Replace(fmt.Sprintf("%v", this.ContainerId), "ContainerID", "mesos.ContainerID", 1) + `,`,
		`ContainerStatus:` + strings.Replace(fmt.Sprintf("%v", this.ContainerStatus), "ContainerStatus", "mesos.ContainerStatus", 1) + `,`,
		`ResourceStatistics:` + strings.Replace(fmt.Sprintf("%v", this.ResourceStatistics), "ResourceStatistics", "mesos.ResourceStatistics", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response_GetFrameworks) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response_GetFrameworks{`,
		`Frameworks:` + strings.Replace(fmt.Sprintf("%v", this.Frameworks), "Response_GetFrameworks_Framework", "Response_GetFrameworks_Framework", 1) + `,`,
		`CompletedFrameworks:` + strings.Replace(fmt.Sprintf("%v", this.CompletedFrameworks), "Response_GetFrameworks_Framework", "Response_GetFrameworks_Framework", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response_GetFrameworks_Framework) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response_GetFrameworks_Framework{`,
		`FrameworkInfo:` + strings.Replace(fmt.Sprintf("%v", this.FrameworkInfo), "FrameworkInfo", "mesos.FrameworkInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response_GetExecutors) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response_GetExecutors{`,
		`Executors:` + strings.Replace(fmt.Sprintf("%v", this.Executors), "Response_GetExecutors_Executor", "Response_GetExecutors_Executor", 1) + `,`,
		`CompletedExecutors:` + strings.Replace(fmt.Sprintf("%v", this.CompletedExecutors), "Response_GetExecutors_Executor", "Response_GetExecutors_Executor", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response_GetExecutors_Executor) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response_GetExecutors_Executor{`,
		`ExecutorInfo:` + strings.Replace(fmt.Sprintf("%v", this.ExecutorInfo), "ExecutorInfo", "mesos.ExecutorInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response_GetTasks) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response_GetTasks{`,
		`PendingTasks:` + strings.Replace(fmt.Sprintf("%v", this.PendingTasks), "Task", "mesos.Task", 1) + `,`,
		`QueuedTasks:` + strings.Replace(fmt.Sprintf("%v", this.QueuedTasks), "Task", "mesos.Task", 1) + `,`,
		`LaunchedTasks:` + strings.Replace(fmt.Sprintf("%v", this.LaunchedTasks), "Task", "mesos.Task", 1) + `,`,
		`TerminatedTasks:` + strings.Replace(fmt.Sprintf("%v", this.TerminatedTasks), "Task", "mesos.Task", 1) + `,`,
		`CompletedTasks:` + strings.Replace(fmt.Sprintf("%v", this.CompletedTasks), "Task", "mesos.Task", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *Response_WaitNestedContainer) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&Response_WaitNestedContainer{`,
		`ExitStatus:` + valueToStringAgent(this.ExitStatus) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProcessIO) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ProcessIO{`,
		`Type:` + valueToStringAgent(this.Type) + `,`,
		`Data:` + strings.Replace(fmt.Sprintf("%v", this.Data), "ProcessIO_Data", "ProcessIO_Data", 1) + `,`,
		`Control:` + strings.Replace(fmt.Sprintf("%v", this.Control), "ProcessIO_Control", "ProcessIO_Control", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProcessIO_Data) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ProcessIO_Data{`,
		`Type:` + valueToStringAgent(this.Type) + `,`,
		`Data:` + valueToStringAgent(this.Data) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProcessIO_Control) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ProcessIO_Control{`,
		`Type:` + valueToStringAgent(this.Type) + `,`,
		`TtyInfo:` + strings.Replace(fmt.Sprintf("%v", this.TtyInfo), "TTYInfo", "mesos.TTYInfo", 1) + `,`,
		`Heartbeat:` + strings.Replace(fmt.Sprintf("%v", this.Heartbeat), "ProcessIO_Control_Heartbeat", "ProcessIO_Control_Heartbeat", 1) + `,`,
		`}`,
	}, "")
	return s
}
func (this *ProcessIO_Control_Heartbeat) String() string {
	if this == nil {
		return "nil"
	}
	s := strings.Join([]string{`&ProcessIO_Control_Heartbeat{`,
		`Interval:` + strings.Replace(fmt.Sprintf("%v", this.Interval), "DurationInfo", "mesos.DurationInfo", 1) + `,`,
		`}`,
	}, "")
	return s
}
func valueToStringAgent(v interface{}) string {
	rv := reflect.ValueOf(v)
	if rv.IsNil() {
		return "nil"
	}
	pv := reflect.Indirect(rv).Interface()
	return fmt.Sprintf("*%v", pv)
}
func (m *Call) Unmarshal(data []byte) error {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Call: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Call: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var v Call_Type
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				v |= (Call_Type(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Type = &v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetMetrics", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetMetrics == nil {
				m.GetMetrics = &Call_GetMetrics{}
			}
			if err := m.GetMetrics.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field SetLoggingLevel", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.SetLoggingLevel == nil {
				m.SetLoggingLevel = &Call_SetLoggingLevel{}
			}
			if err := m.SetLoggingLevel.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListFiles", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ListFiles == nil {
				m.ListFiles = &Call_ListFiles{}
			}
			if err := m.ListFiles.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadFile", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ReadFile == nil {
				m.ReadFile = &Call_ReadFile{}
			}
			if err := m.ReadFile.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LaunchNestedContainer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LaunchNestedContainer == nil {
				m.LaunchNestedContainer = &Call_LaunchNestedContainer{}
			}
			if err := m.LaunchNestedContainer.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WaitNestedContainer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.WaitNestedContainer == nil {
				m.WaitNestedContainer = &Call_WaitNestedContainer{}
			}
			if err := m.WaitNestedContainer.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field KillNestedContainer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.KillNestedContainer == nil {
				m.KillNestedContainer = &Call_KillNestedContainer{}
			}
			if err := m.KillNestedContainer.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LaunchNestedContainerSession", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.LaunchNestedContainerSession == nil {
				m.LaunchNestedContainerSession = &Call_LaunchNestedContainerSession{}
			}
			if err := m.LaunchNestedContainerSession.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AttachContainerInput", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AttachContainerInput == nil {
				m.AttachContainerInput = &Call_AttachContainerInput{}
			}
			if err := m.AttachContainerInput.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field AttachContainerOutput", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.AttachContainerOutput == nil {
				m.AttachContainerOutput = &Call_AttachContainerOutput{}
			}
			if err := m.AttachContainerOutput.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Call_GetMetrics) Unmarshal(data []byte) error {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetMetrics: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetMetrics: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Timeout", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Timeout == nil {
				m.Timeout = &mesos.DurationInfo{}
			}
			if err := m.Timeout.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Call_SetLoggingLevel) Unmarshal(data []byte) error {
	var hasFields [1]uint64
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: SetLoggingLevel: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: SetLoggingLevel: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Level", wireType)
			}
			var v uint32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				v |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Level = &v
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Duration", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Duration == nil {
				m.Duration = &mesos.DurationInfo{}
			}
			if err := m.Duration.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000002)
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("level")
	}
	if hasFields[0]&uint64(0x00000002) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("duration")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Call_ListFiles) Unmarshal(data []byte) error {
	var hasFields [1]uint64
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListFiles: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListFiles: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[iNdEx:postIndex])
			m.Path = &s
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000001)
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("path")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Call_ReadFile) Unmarshal(data []byte) error {
	var hasFields [1]uint64
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ReadFile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReadFile: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Path = string(data[iNdEx:postIndex])
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Offset", wireType)
			}
			m.Offset = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				m.Offset |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			hasFields[0] |= uint64(0x00000002)
		case 3:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Length", wireType)
			}
			m.Length = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				m.Length |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("path")
	}
	if hasFields[0]&uint64(0x00000002) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("offset")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Call_LaunchNestedContainer) Unmarshal(data []byte) error {
	var hasFields [1]uint64
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LaunchNestedContainer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LaunchNestedContainer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ContainerId == nil {
				m.ContainerId = &mesos.ContainerID{}
			}
			if err := m.ContainerId.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Command", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Command == nil {
				m.Command = &mesos.CommandInfo{}
			}
			if err := m.Command.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Container == nil {
				m.Container = &mesos.ContainerInfo{}
			}
			if err := m.Container.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("container_id")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Call_WaitNestedContainer) Unmarshal(data []byte) error {
	var hasFields [1]uint64
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WaitNestedContainer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WaitNestedContainer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ContainerId == nil {
				m.ContainerId = &mesos.ContainerID{}
			}
			if err := m.ContainerId.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000001)
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("container_id")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Call_KillNestedContainer) Unmarshal(data []byte) error {
	var hasFields [1]uint64
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: KillNestedContainer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: KillNestedContainer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ContainerId == nil {
				m.ContainerId = &mesos.ContainerID{}
			}
			if err := m.ContainerId.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000001)
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("container_id")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Call_LaunchNestedContainerSession) Unmarshal(data []byte) error {
	var hasFields [1]uint64
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: LaunchNestedContainerSession: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: LaunchNestedContainerSession: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ContainerId == nil {
				m.ContainerId = &mesos.ContainerID{}
			}
			if err := m.ContainerId.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Command", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Command == nil {
				m.Command = &mesos.CommandInfo{}
			}
			if err := m.Command.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Container", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Container == nil {
				m.Container = &mesos.ContainerInfo{}
			}
			if err := m.Container.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("container_id")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Call_AttachContainerInput) Unmarshal(data []byte) error {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AttachContainerInput: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AttachContainerInput: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var v Call_AttachContainerInput_Type
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				v |= (Call_AttachContainerInput_Type(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Type = &v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ContainerId == nil {
				m.ContainerId = &mesos.ContainerID{}
			}
			if err := m.ContainerId.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ProcessIo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ProcessIo == nil {
				m.ProcessIo = &ProcessIO{}
			}
			if err := m.ProcessIo.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Call_AttachContainerOutput) Unmarshal(data []byte) error {
	var hasFields [1]uint64
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: AttachContainerOutput: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: AttachContainerOutput: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ContainerId == nil {
				m.ContainerId = &mesos.ContainerID{}
			}
			if err := m.ContainerId.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000001)
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("container_id")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response) Unmarshal(data []byte) error {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Response: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Response: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var v Response_Type
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				v |= (Response_Type(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Type = &v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetHealth", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetHealth == nil {
				m.GetHealth = &Response_GetHealth{}
			}
			if err := m.GetHealth.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetFlags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetFlags == nil {
				m.GetFlags = &Response_GetFlags{}
			}
			if err := m.GetFlags.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetVersion", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetVersion == nil {
				m.GetVersion = &Response_GetVersion{}
			}
			if err := m.GetVersion.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetMetrics", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetMetrics == nil {
				m.GetMetrics = &Response_GetMetrics{}
			}
			if err := m.GetMetrics.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetLoggingLevel", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetLoggingLevel == nil {
				m.GetLoggingLevel = &Response_GetLoggingLevel{}
			}
			if err := m.GetLoggingLevel.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 7:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ListFiles", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ListFiles == nil {
				m.ListFiles = &Response_ListFiles{}
			}
			if err := m.ListFiles.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 8:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ReadFile", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ReadFile == nil {
				m.ReadFile = &Response_ReadFile{}
			}
			if err := m.ReadFile.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 9:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetState", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetState == nil {
				m.GetState = &Response_GetState{}
			}
			if err := m.GetState.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 10:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetContainers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetContainers == nil {
				m.GetContainers = &Response_GetContainers{}
			}
			if err := m.GetContainers.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 11:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetFrameworks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetFrameworks == nil {
				m.GetFrameworks = &Response_GetFrameworks{}
			}
			if err := m.GetFrameworks.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 12:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetExecutors", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetExecutors == nil {
				m.GetExecutors = &Response_GetExecutors{}
			}
			if err := m.GetExecutors.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 13:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetTasks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetTasks == nil {
				m.GetTasks = &Response_GetTasks{}
			}
			if err := m.GetTasks.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 14:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field WaitNestedContainer", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.WaitNestedContainer == nil {
				m.WaitNestedContainer = &Response_WaitNestedContainer{}
			}
			if err := m.WaitNestedContainer.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response_GetHealth) Unmarshal(data []byte) error {
	var hasFields [1]uint64
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetHealth: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetHealth: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Healthy", wireType)
			}
			var v int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				v |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			b := bool(v != 0)
			m.Healthy = &b
			hasFields[0] |= uint64(0x00000001)
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("healthy")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response_GetFlags) Unmarshal(data []byte) error {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetFlags: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetFlags: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Flags", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Flags = append(m.Flags, &mesos.Flag{})
			if err := m.Flags[len(m.Flags)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response_GetVersion) Unmarshal(data []byte) error {
	var hasFields [1]uint64
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetVersion: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetVersion: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field VersionInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.VersionInfo == nil {
				m.VersionInfo = &mesos.VersionInfo{}
			}
			if err := m.VersionInfo.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000001)
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("version_info")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response_GetMetrics) Unmarshal(data []byte) error {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetMetrics: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetMetrics: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Metrics", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Metrics = append(m.Metrics, &mesos.Metric{})
			if err := m.Metrics[len(m.Metrics)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response_GetLoggingLevel) Unmarshal(data []byte) error {
	var hasFields [1]uint64
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetLoggingLevel: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetLoggingLevel: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Level", wireType)
			}
			var v uint32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				v |= (uint32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Level = &v
			hasFields[0] |= uint64(0x00000001)
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("level")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response_ListFiles) Unmarshal(data []byte) error {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ListFiles: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ListFiles: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FileInfos", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.FileInfos = append(m.FileInfos, &mesos.FileInfo{})
			if err := m.FileInfos[len(m.FileInfos)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response_ReadFile) Unmarshal(data []byte) error {
	var hasFields [1]uint64
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ReadFile: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ReadFile: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Size_", wireType)
			}
			m.Size_ = 0
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				m.Size_ |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append([]byte{}, data[iNdEx:postIndex]...)
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000002)
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("size")
	}
	if hasFields[0]&uint64(0x00000002) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("data")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response_GetState) Unmarshal(data []byte) error {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetState: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetState: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetTasks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetTasks == nil {
				m.GetTasks = &Response_GetTasks{}
			}
			if err := m.GetTasks.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetExecutors", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetExecutors == nil {
				m.GetExecutors = &Response_GetExecutors{}
			}
			if err := m.GetExecutors.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field GetFrameworks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.GetFrameworks == nil {
				m.GetFrameworks = &Response_GetFrameworks{}
			}
			if err := m.GetFrameworks.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response_GetContainers) Unmarshal(data []byte) error {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetContainers: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetContainers: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Containers", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Containers = append(m.Containers, &Response_GetContainers_Container{})
			if err := m.Containers[len(m.Containers)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response_GetContainers_Container) Unmarshal(data []byte) error {
	var hasFields [1]uint64
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Container: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Container: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FrameworkId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FrameworkId == nil {
				m.FrameworkId = &mesos.FrameworkID{}
			}
			if err := m.FrameworkId.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000001)
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecutorId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ExecutorId == nil {
				m.ExecutorId = &mesos.ExecutorID{}
			}
			if err := m.ExecutorId.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000002)
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecutorName", wireType)
			}
			var stringLen uint64
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				stringLen |= (uint64(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			intStringLen := int(stringLen)
			if intStringLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + intStringLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			s := string(data[iNdEx:postIndex])
			m.ExecutorName = &s
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000004)
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerId", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ContainerId == nil {
				m.ContainerId = &mesos.ContainerID{}
			}
			if err := m.ContainerId.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000008)
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ContainerStatus", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ContainerStatus == nil {
				m.ContainerStatus = &mesos.ContainerStatus{}
			}
			if err := m.ContainerStatus.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 6:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ResourceStatistics", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ResourceStatistics == nil {
				m.ResourceStatistics = &mesos.ResourceStatistics{}
			}
			if err := m.ResourceStatistics.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("framework_id")
	}
	if hasFields[0]&uint64(0x00000002) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("executor_id")
	}
	if hasFields[0]&uint64(0x00000004) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("executor_name")
	}
	if hasFields[0]&uint64(0x00000008) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("container_id")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response_GetFrameworks) Unmarshal(data []byte) error {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetFrameworks: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetFrameworks: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Frameworks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Frameworks = append(m.Frameworks, &Response_GetFrameworks_Framework{})
			if err := m.Frameworks[len(m.Frameworks)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompletedFrameworks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CompletedFrameworks = append(m.CompletedFrameworks, &Response_GetFrameworks_Framework{})
			if err := m.CompletedFrameworks[len(m.CompletedFrameworks)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response_GetFrameworks_Framework) Unmarshal(data []byte) error {
	var hasFields [1]uint64
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Framework: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Framework: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field FrameworkInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.FrameworkInfo == nil {
				m.FrameworkInfo = &mesos.FrameworkInfo{}
			}
			if err := m.FrameworkInfo.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000001)
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("framework_info")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response_GetExecutors) Unmarshal(data []byte) error {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetExecutors: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetExecutors: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Executors", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Executors = append(m.Executors, &Response_GetExecutors_Executor{})
			if err := m.Executors[len(m.Executors)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompletedExecutors", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CompletedExecutors = append(m.CompletedExecutors, &Response_GetExecutors_Executor{})
			if err := m.CompletedExecutors[len(m.CompletedExecutors)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response_GetExecutors_Executor) Unmarshal(data []byte) error {
	var hasFields [1]uint64
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Executor: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Executor: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExecutorInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.ExecutorInfo == nil {
				m.ExecutorInfo = &mesos.ExecutorInfo{}
			}
			if err := m.ExecutorInfo.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
			hasFields[0] |= uint64(0x00000001)
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}
	if hasFields[0]&uint64(0x00000001) == 0 {
		return github_com_gogo_protobuf_proto.NewRequiredNotSetError("executor_info")
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response_GetTasks) Unmarshal(data []byte) error {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: GetTasks: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: GetTasks: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field PendingTasks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.PendingTasks = append(m.PendingTasks, &mesos.Task{})
			if err := m.PendingTasks[len(m.PendingTasks)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field QueuedTasks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.QueuedTasks = append(m.QueuedTasks, &mesos.Task{})
			if err := m.QueuedTasks[len(m.QueuedTasks)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field LaunchedTasks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.LaunchedTasks = append(m.LaunchedTasks, &mesos.Task{})
			if err := m.LaunchedTasks[len(m.LaunchedTasks)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 4:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TerminatedTasks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.TerminatedTasks = append(m.TerminatedTasks, &mesos.Task{})
			if err := m.TerminatedTasks[len(m.TerminatedTasks)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 5:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field CompletedTasks", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.CompletedTasks = append(m.CompletedTasks, &mesos.Task{})
			if err := m.CompletedTasks[len(m.CompletedTasks)-1].Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *Response_WaitNestedContainer) Unmarshal(data []byte) error {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: WaitNestedContainer: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: WaitNestedContainer: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field ExitStatus", wireType)
			}
			var v int32
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				v |= (int32(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.ExitStatus = &v
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProcessIO) Unmarshal(data []byte) error {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: ProcessIO: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: ProcessIO: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var v ProcessIO_Type
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				v |= (ProcessIO_Type(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Type = &v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Data == nil {
				m.Data = &ProcessIO_Data{}
			}
			if err := m.Data.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Control", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Control == nil {
				m.Control = &ProcessIO_Control{}
			}
			if err := m.Control.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProcessIO_Data) Unmarshal(data []byte) error {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Data: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Data: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var v ProcessIO_Data_Type
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				v |= (ProcessIO_Data_Type(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Type = &v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Data", wireType)
			}
			var byteLen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				byteLen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if byteLen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + byteLen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			m.Data = append([]byte{}, data[iNdEx:postIndex]...)
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProcessIO_Control) Unmarshal(data []byte) error {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Control: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Control: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 0 {
				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
			}
			var v ProcessIO_Control_Type
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				v |= (ProcessIO_Control_Type(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			m.Type = &v
		case 2:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field TtyInfo", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.TtyInfo == nil {
				m.TtyInfo = &mesos.TTYInfo{}
			}
			if err := m.TtyInfo.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		case 3:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Heartbeat", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Heartbeat == nil {
				m.Heartbeat = &ProcessIO_Control_Heartbeat{}
			}
			if err := m.Heartbeat.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func (m *ProcessIO_Control_Heartbeat) Unmarshal(data []byte) error {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		preIndex := iNdEx
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		fieldNum := int32(wire >> 3)
		wireType := int(wire & 0x7)
		if wireType == 4 {
			return fmt.Errorf("proto: Heartbeat: wiretype end group for non-group")
		}
		if fieldNum <= 0 {
			return fmt.Errorf("proto: Heartbeat: illegal tag %d (wire type %d)", fieldNum, wire)
		}
		switch fieldNum {
		case 1:
			if wireType != 2 {
				return fmt.Errorf("proto: wrong wireType = %d for field Interval", wireType)
			}
			var msglen int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				msglen |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			if msglen < 0 {
				return ErrInvalidLengthAgent
			}
			postIndex := iNdEx + msglen
			if postIndex > l {
				return io.ErrUnexpectedEOF
			}
			if m.Interval == nil {
				m.Interval = &mesos.DurationInfo{}
			}
			if err := m.Interval.Unmarshal(data[iNdEx:postIndex]); err != nil {
				return err
			}
			iNdEx = postIndex
		default:
			iNdEx = preIndex
			skippy, err := skipAgent(data[iNdEx:])
			if err != nil {
				return err
			}
			if skippy < 0 {
				return ErrInvalidLengthAgent
			}
			if (iNdEx + skippy) > l {
				return io.ErrUnexpectedEOF
			}
			iNdEx += skippy
		}
	}

	if iNdEx > l {
		return io.ErrUnexpectedEOF
	}
	return nil
}
func skipAgent(data []byte) (n int, err error) {
	l := len(data)
	iNdEx := 0
	for iNdEx < l {
		var wire uint64
		for shift := uint(0); ; shift += 7 {
			if shift >= 64 {
				return 0, ErrIntOverflowAgent
			}
			if iNdEx >= l {
				return 0, io.ErrUnexpectedEOF
			}
			b := data[iNdEx]
			iNdEx++
			wire |= (uint64(b) & 0x7F) << shift
			if b < 0x80 {
				break
			}
		}
		wireType := int(wire & 0x7)
		switch wireType {
		case 0:
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				iNdEx++
				if data[iNdEx-1] < 0x80 {
					break
				}
			}
			return iNdEx, nil
		case 1:
			iNdEx += 8
			return iNdEx, nil
		case 2:
			var length int
			for shift := uint(0); ; shift += 7 {
				if shift >= 64 {
					return 0, ErrIntOverflowAgent
				}
				if iNdEx >= l {
					return 0, io.ErrUnexpectedEOF
				}
				b := data[iNdEx]
				iNdEx++
				length |= (int(b) & 0x7F) << shift
				if b < 0x80 {
					break
				}
			}
			iNdEx += length
			if length < 0 {
				return 0, ErrInvalidLengthAgent
			}
			return iNdEx, nil
		case 3:
			for {
				var innerWire uint64
				var start int = iNdEx
				for shift := uint(0); ; shift += 7 {
					if shift >= 64 {
						return 0, ErrIntOverflowAgent
					}
					if iNdEx >= l {
						return 0, io.ErrUnexpectedEOF
					}
					b := data[iNdEx]
					iNdEx++
					innerWire |= (uint64(b) & 0x7F) << shift
					if b < 0x80 {
						break
					}
				}
				innerWireType := int(innerWire & 0x7)
				if innerWireType == 4 {
					break
				}
				next, err := skipAgent(data[start:])
				if err != nil {
					return 0, err
				}
				iNdEx = start + next
			}
			return iNdEx, nil
		case 4:
			return iNdEx, nil
		case 5:
			iNdEx += 4
			return iNdEx, nil
		default:
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
		}
	}
	panic("unreachable")
}

var (
	ErrInvalidLengthAgent = fmt.Errorf("proto: negative length found during unmarshaling")
	ErrIntOverflowAgent   = fmt.Errorf("proto: integer overflow")
)