mirror of
				https://gitea.com/Lydanne/buildx.git
				synced 2025-11-04 18:13:42 +08:00 
			
		
		
		
	
		
			
				
	
	
		
			11161 lines
		
	
	
		
			251 KiB
		
	
	
	
		
			Go
		
	
	
	
	
	
			
		
		
	
	
			11161 lines
		
	
	
		
			251 KiB
		
	
	
	
		
			Go
		
	
	
	
	
	
// Code generated by protoc-gen-gogo. DO NOT EDIT.
 | 
						|
// source: ops.proto
 | 
						|
 | 
						|
// Package pb provides the protobuf definition of LLB: low-level builder instruction.
 | 
						|
// LLB is DAG-structured; Op represents a vertex, and Definition represents a graph.
 | 
						|
 | 
						|
package pb
 | 
						|
 | 
						|
import (
 | 
						|
	fmt "fmt"
 | 
						|
	_ "github.com/gogo/protobuf/gogoproto"
 | 
						|
	proto "github.com/gogo/protobuf/proto"
 | 
						|
	github_com_gogo_protobuf_sortkeys "github.com/gogo/protobuf/sortkeys"
 | 
						|
	github_com_moby_buildkit_util_apicaps "github.com/moby/buildkit/util/apicaps"
 | 
						|
	github_com_opencontainers_go_digest "github.com/opencontainers/go-digest"
 | 
						|
	io "io"
 | 
						|
	math "math"
 | 
						|
	math_bits "math/bits"
 | 
						|
)
 | 
						|
 | 
						|
// Reference imports to suppress errors if they are not otherwise used.
 | 
						|
var _ = proto.Marshal
 | 
						|
var _ = fmt.Errorf
 | 
						|
var _ = math.Inf
 | 
						|
 | 
						|
// This is a compile-time assertion to ensure that this generated file
 | 
						|
// is compatible with the proto package it is being compiled against.
 | 
						|
// A compilation error at this line likely means your copy of the
 | 
						|
// proto package needs to be updated.
 | 
						|
const _ = proto.GoGoProtoPackageIsVersion3 // please upgrade the proto package
 | 
						|
 | 
						|
type NetMode int32
 | 
						|
 | 
						|
const (
 | 
						|
	NetMode_UNSET NetMode = 0
 | 
						|
	NetMode_HOST  NetMode = 1
 | 
						|
	NetMode_NONE  NetMode = 2
 | 
						|
)
 | 
						|
 | 
						|
var NetMode_name = map[int32]string{
 | 
						|
	0: "UNSET",
 | 
						|
	1: "HOST",
 | 
						|
	2: "NONE",
 | 
						|
}
 | 
						|
 | 
						|
var NetMode_value = map[string]int32{
 | 
						|
	"UNSET": 0,
 | 
						|
	"HOST":  1,
 | 
						|
	"NONE":  2,
 | 
						|
}
 | 
						|
 | 
						|
func (x NetMode) String() string {
 | 
						|
	return proto.EnumName(NetMode_name, int32(x))
 | 
						|
}
 | 
						|
 | 
						|
func (NetMode) EnumDescriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{0}
 | 
						|
}
 | 
						|
 | 
						|
type SecurityMode int32
 | 
						|
 | 
						|
const (
 | 
						|
	SecurityMode_SANDBOX  SecurityMode = 0
 | 
						|
	SecurityMode_INSECURE SecurityMode = 1
 | 
						|
)
 | 
						|
 | 
						|
var SecurityMode_name = map[int32]string{
 | 
						|
	0: "SANDBOX",
 | 
						|
	1: "INSECURE",
 | 
						|
}
 | 
						|
 | 
						|
var SecurityMode_value = map[string]int32{
 | 
						|
	"SANDBOX":  0,
 | 
						|
	"INSECURE": 1,
 | 
						|
}
 | 
						|
 | 
						|
func (x SecurityMode) String() string {
 | 
						|
	return proto.EnumName(SecurityMode_name, int32(x))
 | 
						|
}
 | 
						|
 | 
						|
func (SecurityMode) EnumDescriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{1}
 | 
						|
}
 | 
						|
 | 
						|
// MountType defines a type of a mount from a supported set
 | 
						|
type MountType int32
 | 
						|
 | 
						|
const (
 | 
						|
	MountType_BIND   MountType = 0
 | 
						|
	MountType_SECRET MountType = 1
 | 
						|
	MountType_SSH    MountType = 2
 | 
						|
	MountType_CACHE  MountType = 3
 | 
						|
	MountType_TMPFS  MountType = 4
 | 
						|
)
 | 
						|
 | 
						|
var MountType_name = map[int32]string{
 | 
						|
	0: "BIND",
 | 
						|
	1: "SECRET",
 | 
						|
	2: "SSH",
 | 
						|
	3: "CACHE",
 | 
						|
	4: "TMPFS",
 | 
						|
}
 | 
						|
 | 
						|
var MountType_value = map[string]int32{
 | 
						|
	"BIND":   0,
 | 
						|
	"SECRET": 1,
 | 
						|
	"SSH":    2,
 | 
						|
	"CACHE":  3,
 | 
						|
	"TMPFS":  4,
 | 
						|
}
 | 
						|
 | 
						|
func (x MountType) String() string {
 | 
						|
	return proto.EnumName(MountType_name, int32(x))
 | 
						|
}
 | 
						|
 | 
						|
func (MountType) EnumDescriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{2}
 | 
						|
}
 | 
						|
 | 
						|
// CacheSharingOpt defines different sharing modes for cache mount
 | 
						|
type CacheSharingOpt int32
 | 
						|
 | 
						|
const (
 | 
						|
	// SHARED cache mount can be used concurrently by multiple writers
 | 
						|
	CacheSharingOpt_SHARED CacheSharingOpt = 0
 | 
						|
	// PRIVATE creates a new mount if there are multiple writers
 | 
						|
	CacheSharingOpt_PRIVATE CacheSharingOpt = 1
 | 
						|
	// LOCKED pauses second writer until first one releases the mount
 | 
						|
	CacheSharingOpt_LOCKED CacheSharingOpt = 2
 | 
						|
)
 | 
						|
 | 
						|
var CacheSharingOpt_name = map[int32]string{
 | 
						|
	0: "SHARED",
 | 
						|
	1: "PRIVATE",
 | 
						|
	2: "LOCKED",
 | 
						|
}
 | 
						|
 | 
						|
var CacheSharingOpt_value = map[string]int32{
 | 
						|
	"SHARED":  0,
 | 
						|
	"PRIVATE": 1,
 | 
						|
	"LOCKED":  2,
 | 
						|
}
 | 
						|
 | 
						|
func (x CacheSharingOpt) String() string {
 | 
						|
	return proto.EnumName(CacheSharingOpt_name, int32(x))
 | 
						|
}
 | 
						|
 | 
						|
func (CacheSharingOpt) EnumDescriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{3}
 | 
						|
}
 | 
						|
 | 
						|
// Op represents a vertex of the LLB DAG.
 | 
						|
type Op struct {
 | 
						|
	// inputs is a set of input edges.
 | 
						|
	Inputs []*Input `protobuf:"bytes,1,rep,name=inputs,proto3" json:"inputs,omitempty"`
 | 
						|
	// Types that are valid to be assigned to Op:
 | 
						|
	//	*Op_Exec
 | 
						|
	//	*Op_Source
 | 
						|
	//	*Op_File
 | 
						|
	//	*Op_Build
 | 
						|
	Op          isOp_Op            `protobuf_oneof:"op"`
 | 
						|
	Platform    *Platform          `protobuf:"bytes,10,opt,name=platform,proto3" json:"platform,omitempty"`
 | 
						|
	Constraints *WorkerConstraints `protobuf:"bytes,11,opt,name=constraints,proto3" json:"constraints,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *Op) Reset()         { *m = Op{} }
 | 
						|
func (m *Op) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*Op) ProtoMessage()    {}
 | 
						|
func (*Op) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{0}
 | 
						|
}
 | 
						|
func (m *Op) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *Op) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *Op) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_Op.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *Op) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *Op) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_Op.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_Op proto.InternalMessageInfo
 | 
						|
 | 
						|
type isOp_Op interface {
 | 
						|
	isOp_Op()
 | 
						|
	MarshalTo([]byte) (int, error)
 | 
						|
	Size() int
 | 
						|
}
 | 
						|
 | 
						|
type Op_Exec struct {
 | 
						|
	Exec *ExecOp `protobuf:"bytes,2,opt,name=exec,proto3,oneof" json:"exec,omitempty"`
 | 
						|
}
 | 
						|
type Op_Source struct {
 | 
						|
	Source *SourceOp `protobuf:"bytes,3,opt,name=source,proto3,oneof" json:"source,omitempty"`
 | 
						|
}
 | 
						|
type Op_File struct {
 | 
						|
	File *FileOp `protobuf:"bytes,4,opt,name=file,proto3,oneof" json:"file,omitempty"`
 | 
						|
}
 | 
						|
type Op_Build struct {
 | 
						|
	Build *BuildOp `protobuf:"bytes,5,opt,name=build,proto3,oneof" json:"build,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (*Op_Exec) isOp_Op()   {}
 | 
						|
func (*Op_Source) isOp_Op() {}
 | 
						|
func (*Op_File) isOp_Op()   {}
 | 
						|
func (*Op_Build) isOp_Op()  {}
 | 
						|
 | 
						|
func (m *Op) GetOp() isOp_Op {
 | 
						|
	if m != nil {
 | 
						|
		return m.Op
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Op) GetInputs() []*Input {
 | 
						|
	if m != nil {
 | 
						|
		return m.Inputs
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Op) GetExec() *ExecOp {
 | 
						|
	if x, ok := m.GetOp().(*Op_Exec); ok {
 | 
						|
		return x.Exec
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Op) GetSource() *SourceOp {
 | 
						|
	if x, ok := m.GetOp().(*Op_Source); ok {
 | 
						|
		return x.Source
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Op) GetFile() *FileOp {
 | 
						|
	if x, ok := m.GetOp().(*Op_File); ok {
 | 
						|
		return x.File
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Op) GetBuild() *BuildOp {
 | 
						|
	if x, ok := m.GetOp().(*Op_Build); ok {
 | 
						|
		return x.Build
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Op) GetPlatform() *Platform {
 | 
						|
	if m != nil {
 | 
						|
		return m.Platform
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Op) GetConstraints() *WorkerConstraints {
 | 
						|
	if m != nil {
 | 
						|
		return m.Constraints
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
// XXX_OneofWrappers is for the internal use of the proto package.
 | 
						|
func (*Op) XXX_OneofWrappers() []interface{} {
 | 
						|
	return []interface{}{
 | 
						|
		(*Op_Exec)(nil),
 | 
						|
		(*Op_Source)(nil),
 | 
						|
		(*Op_File)(nil),
 | 
						|
		(*Op_Build)(nil),
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
// Platform is github.com/opencontainers/image-spec/specs-go/v1.Platform
 | 
						|
type Platform struct {
 | 
						|
	Architecture string   `protobuf:"bytes,1,opt,name=Architecture,proto3" json:"Architecture,omitempty"`
 | 
						|
	OS           string   `protobuf:"bytes,2,opt,name=OS,proto3" json:"OS,omitempty"`
 | 
						|
	Variant      string   `protobuf:"bytes,3,opt,name=Variant,proto3" json:"Variant,omitempty"`
 | 
						|
	OSVersion    string   `protobuf:"bytes,4,opt,name=OSVersion,proto3" json:"OSVersion,omitempty"`
 | 
						|
	OSFeatures   []string `protobuf:"bytes,5,rep,name=OSFeatures,proto3" json:"OSFeatures,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *Platform) Reset()         { *m = Platform{} }
 | 
						|
func (m *Platform) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*Platform) ProtoMessage()    {}
 | 
						|
func (*Platform) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{1}
 | 
						|
}
 | 
						|
func (m *Platform) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *Platform) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *Platform) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_Platform.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *Platform) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *Platform) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_Platform.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_Platform proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *Platform) GetArchitecture() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Architecture
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *Platform) GetOS() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.OS
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *Platform) GetVariant() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Variant
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *Platform) GetOSVersion() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.OSVersion
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *Platform) GetOSFeatures() []string {
 | 
						|
	if m != nil {
 | 
						|
		return m.OSFeatures
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
// Input represents an input edge for an Op.
 | 
						|
type Input struct {
 | 
						|
	// digest of the marshaled input Op
 | 
						|
	Digest github_com_opencontainers_go_digest.Digest `protobuf:"bytes,1,opt,name=digest,proto3,customtype=github.com/opencontainers/go-digest.Digest" json:"digest"`
 | 
						|
	// output index of the input Op
 | 
						|
	Index OutputIndex `protobuf:"varint,2,opt,name=index,proto3,customtype=OutputIndex" json:"index"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *Input) Reset()         { *m = Input{} }
 | 
						|
func (m *Input) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*Input) ProtoMessage()    {}
 | 
						|
func (*Input) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{2}
 | 
						|
}
 | 
						|
func (m *Input) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *Input) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *Input) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_Input.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *Input) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *Input) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_Input.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_Input proto.InternalMessageInfo
 | 
						|
 | 
						|
// ExecOp executes a command in a container.
 | 
						|
type ExecOp struct {
 | 
						|
	Meta     *Meta        `protobuf:"bytes,1,opt,name=meta,proto3" json:"meta,omitempty"`
 | 
						|
	Mounts   []*Mount     `protobuf:"bytes,2,rep,name=mounts,proto3" json:"mounts,omitempty"`
 | 
						|
	Network  NetMode      `protobuf:"varint,3,opt,name=network,proto3,enum=pb.NetMode" json:"network,omitempty"`
 | 
						|
	Security SecurityMode `protobuf:"varint,4,opt,name=security,proto3,enum=pb.SecurityMode" json:"security,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *ExecOp) Reset()         { *m = ExecOp{} }
 | 
						|
func (m *ExecOp) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*ExecOp) ProtoMessage()    {}
 | 
						|
func (*ExecOp) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{3}
 | 
						|
}
 | 
						|
func (m *ExecOp) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *ExecOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *ExecOp) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_ExecOp.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *ExecOp) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *ExecOp) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_ExecOp.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_ExecOp proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *ExecOp) GetMeta() *Meta {
 | 
						|
	if m != nil {
 | 
						|
		return m.Meta
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *ExecOp) GetMounts() []*Mount {
 | 
						|
	if m != nil {
 | 
						|
		return m.Mounts
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *ExecOp) GetNetwork() NetMode {
 | 
						|
	if m != nil {
 | 
						|
		return m.Network
 | 
						|
	}
 | 
						|
	return NetMode_UNSET
 | 
						|
}
 | 
						|
 | 
						|
func (m *ExecOp) GetSecurity() SecurityMode {
 | 
						|
	if m != nil {
 | 
						|
		return m.Security
 | 
						|
	}
 | 
						|
	return SecurityMode_SANDBOX
 | 
						|
}
 | 
						|
 | 
						|
// Meta is a set of arguments for ExecOp.
 | 
						|
// Meta is unrelated to LLB metadata.
 | 
						|
// FIXME: rename (ExecContext? ExecArgs?)
 | 
						|
type Meta struct {
 | 
						|
	Args       []string  `protobuf:"bytes,1,rep,name=args,proto3" json:"args,omitempty"`
 | 
						|
	Env        []string  `protobuf:"bytes,2,rep,name=env,proto3" json:"env,omitempty"`
 | 
						|
	Cwd        string    `protobuf:"bytes,3,opt,name=cwd,proto3" json:"cwd,omitempty"`
 | 
						|
	User       string    `protobuf:"bytes,4,opt,name=user,proto3" json:"user,omitempty"`
 | 
						|
	ProxyEnv   *ProxyEnv `protobuf:"bytes,5,opt,name=proxy_env,json=proxyEnv,proto3" json:"proxy_env,omitempty"`
 | 
						|
	ExtraHosts []*HostIP `protobuf:"bytes,6,rep,name=extraHosts,proto3" json:"extraHosts,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *Meta) Reset()         { *m = Meta{} }
 | 
						|
func (m *Meta) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*Meta) ProtoMessage()    {}
 | 
						|
func (*Meta) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{4}
 | 
						|
}
 | 
						|
func (m *Meta) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *Meta) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *Meta) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_Meta.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *Meta) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *Meta) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_Meta.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_Meta proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *Meta) GetArgs() []string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Args
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Meta) GetEnv() []string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Env
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Meta) GetCwd() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Cwd
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *Meta) GetUser() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.User
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *Meta) GetProxyEnv() *ProxyEnv {
 | 
						|
	if m != nil {
 | 
						|
		return m.ProxyEnv
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Meta) GetExtraHosts() []*HostIP {
 | 
						|
	if m != nil {
 | 
						|
		return m.ExtraHosts
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
// Mount specifies how to mount an input Op as a filesystem.
 | 
						|
type Mount struct {
 | 
						|
	Input     InputIndex  `protobuf:"varint,1,opt,name=input,proto3,customtype=InputIndex" json:"input"`
 | 
						|
	Selector  string      `protobuf:"bytes,2,opt,name=selector,proto3" json:"selector,omitempty"`
 | 
						|
	Dest      string      `protobuf:"bytes,3,opt,name=dest,proto3" json:"dest,omitempty"`
 | 
						|
	Output    OutputIndex `protobuf:"varint,4,opt,name=output,proto3,customtype=OutputIndex" json:"output"`
 | 
						|
	Readonly  bool        `protobuf:"varint,5,opt,name=readonly,proto3" json:"readonly,omitempty"`
 | 
						|
	MountType MountType   `protobuf:"varint,6,opt,name=mountType,proto3,enum=pb.MountType" json:"mountType,omitempty"`
 | 
						|
	CacheOpt  *CacheOpt   `protobuf:"bytes,20,opt,name=cacheOpt,proto3" json:"cacheOpt,omitempty"`
 | 
						|
	SecretOpt *SecretOpt  `protobuf:"bytes,21,opt,name=secretOpt,proto3" json:"secretOpt,omitempty"`
 | 
						|
	SSHOpt    *SSHOpt     `protobuf:"bytes,22,opt,name=SSHOpt,proto3" json:"SSHOpt,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *Mount) Reset()         { *m = Mount{} }
 | 
						|
func (m *Mount) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*Mount) ProtoMessage()    {}
 | 
						|
func (*Mount) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{5}
 | 
						|
}
 | 
						|
func (m *Mount) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *Mount) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *Mount) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_Mount.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *Mount) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *Mount) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_Mount.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_Mount proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *Mount) GetSelector() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Selector
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *Mount) GetDest() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Dest
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *Mount) GetReadonly() bool {
 | 
						|
	if m != nil {
 | 
						|
		return m.Readonly
 | 
						|
	}
 | 
						|
	return false
 | 
						|
}
 | 
						|
 | 
						|
func (m *Mount) GetMountType() MountType {
 | 
						|
	if m != nil {
 | 
						|
		return m.MountType
 | 
						|
	}
 | 
						|
	return MountType_BIND
 | 
						|
}
 | 
						|
 | 
						|
func (m *Mount) GetCacheOpt() *CacheOpt {
 | 
						|
	if m != nil {
 | 
						|
		return m.CacheOpt
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Mount) GetSecretOpt() *SecretOpt {
 | 
						|
	if m != nil {
 | 
						|
		return m.SecretOpt
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Mount) GetSSHOpt() *SSHOpt {
 | 
						|
	if m != nil {
 | 
						|
		return m.SSHOpt
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
// CacheOpt defines options specific to cache mounts
 | 
						|
type CacheOpt struct {
 | 
						|
	// ID is an optional namespace for the mount
 | 
						|
	ID string `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
 | 
						|
	// Sharing is the sharing mode for the mount
 | 
						|
	Sharing CacheSharingOpt `protobuf:"varint,2,opt,name=sharing,proto3,enum=pb.CacheSharingOpt" json:"sharing,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *CacheOpt) Reset()         { *m = CacheOpt{} }
 | 
						|
func (m *CacheOpt) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*CacheOpt) ProtoMessage()    {}
 | 
						|
func (*CacheOpt) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{6}
 | 
						|
}
 | 
						|
func (m *CacheOpt) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *CacheOpt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *CacheOpt) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_CacheOpt.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *CacheOpt) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *CacheOpt) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_CacheOpt.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_CacheOpt proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *CacheOpt) GetID() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.ID
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *CacheOpt) GetSharing() CacheSharingOpt {
 | 
						|
	if m != nil {
 | 
						|
		return m.Sharing
 | 
						|
	}
 | 
						|
	return CacheSharingOpt_SHARED
 | 
						|
}
 | 
						|
 | 
						|
// SecretOpt defines options describing secret mounts
 | 
						|
type SecretOpt struct {
 | 
						|
	// ID of secret. Used for quering the value.
 | 
						|
	ID string `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
 | 
						|
	// UID of secret file
 | 
						|
	Uid uint32 `protobuf:"varint,2,opt,name=uid,proto3" json:"uid,omitempty"`
 | 
						|
	// GID of secret file
 | 
						|
	Gid uint32 `protobuf:"varint,3,opt,name=gid,proto3" json:"gid,omitempty"`
 | 
						|
	// Mode is the filesystem mode of secret file
 | 
						|
	Mode uint32 `protobuf:"varint,4,opt,name=mode,proto3" json:"mode,omitempty"`
 | 
						|
	// Optional defines if secret value is required. Error is produced
 | 
						|
	// if value is not found and optional is false.
 | 
						|
	Optional bool `protobuf:"varint,5,opt,name=optional,proto3" json:"optional,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *SecretOpt) Reset()         { *m = SecretOpt{} }
 | 
						|
func (m *SecretOpt) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*SecretOpt) ProtoMessage()    {}
 | 
						|
func (*SecretOpt) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{7}
 | 
						|
}
 | 
						|
func (m *SecretOpt) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *SecretOpt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *SecretOpt) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_SecretOpt.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *SecretOpt) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *SecretOpt) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_SecretOpt.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_SecretOpt proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *SecretOpt) GetID() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.ID
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *SecretOpt) GetUid() uint32 {
 | 
						|
	if m != nil {
 | 
						|
		return m.Uid
 | 
						|
	}
 | 
						|
	return 0
 | 
						|
}
 | 
						|
 | 
						|
func (m *SecretOpt) GetGid() uint32 {
 | 
						|
	if m != nil {
 | 
						|
		return m.Gid
 | 
						|
	}
 | 
						|
	return 0
 | 
						|
}
 | 
						|
 | 
						|
func (m *SecretOpt) GetMode() uint32 {
 | 
						|
	if m != nil {
 | 
						|
		return m.Mode
 | 
						|
	}
 | 
						|
	return 0
 | 
						|
}
 | 
						|
 | 
						|
func (m *SecretOpt) GetOptional() bool {
 | 
						|
	if m != nil {
 | 
						|
		return m.Optional
 | 
						|
	}
 | 
						|
	return false
 | 
						|
}
 | 
						|
 | 
						|
// SSHOpt defines options describing secret mounts
 | 
						|
type SSHOpt struct {
 | 
						|
	// ID of exposed ssh rule. Used for quering the value.
 | 
						|
	ID string `protobuf:"bytes,1,opt,name=ID,proto3" json:"ID,omitempty"`
 | 
						|
	// UID of agent socket
 | 
						|
	Uid uint32 `protobuf:"varint,2,opt,name=uid,proto3" json:"uid,omitempty"`
 | 
						|
	// GID of agent socket
 | 
						|
	Gid uint32 `protobuf:"varint,3,opt,name=gid,proto3" json:"gid,omitempty"`
 | 
						|
	// Mode is the filesystem mode of agent socket
 | 
						|
	Mode uint32 `protobuf:"varint,4,opt,name=mode,proto3" json:"mode,omitempty"`
 | 
						|
	// Optional defines if ssh socket is required. Error is produced
 | 
						|
	// if client does not expose ssh.
 | 
						|
	Optional bool `protobuf:"varint,5,opt,name=optional,proto3" json:"optional,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *SSHOpt) Reset()         { *m = SSHOpt{} }
 | 
						|
func (m *SSHOpt) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*SSHOpt) ProtoMessage()    {}
 | 
						|
func (*SSHOpt) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{8}
 | 
						|
}
 | 
						|
func (m *SSHOpt) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *SSHOpt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *SSHOpt) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_SSHOpt.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *SSHOpt) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *SSHOpt) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_SSHOpt.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_SSHOpt proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *SSHOpt) GetID() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.ID
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *SSHOpt) GetUid() uint32 {
 | 
						|
	if m != nil {
 | 
						|
		return m.Uid
 | 
						|
	}
 | 
						|
	return 0
 | 
						|
}
 | 
						|
 | 
						|
func (m *SSHOpt) GetGid() uint32 {
 | 
						|
	if m != nil {
 | 
						|
		return m.Gid
 | 
						|
	}
 | 
						|
	return 0
 | 
						|
}
 | 
						|
 | 
						|
func (m *SSHOpt) GetMode() uint32 {
 | 
						|
	if m != nil {
 | 
						|
		return m.Mode
 | 
						|
	}
 | 
						|
	return 0
 | 
						|
}
 | 
						|
 | 
						|
func (m *SSHOpt) GetOptional() bool {
 | 
						|
	if m != nil {
 | 
						|
		return m.Optional
 | 
						|
	}
 | 
						|
	return false
 | 
						|
}
 | 
						|
 | 
						|
// SourceOp specifies a source such as build contexts and images.
 | 
						|
type SourceOp struct {
 | 
						|
	// TODO: use source type or any type instead of URL protocol.
 | 
						|
	// identifier e.g. local://, docker-image://, git://, https://...
 | 
						|
	Identifier string `protobuf:"bytes,1,opt,name=identifier,proto3" json:"identifier,omitempty"`
 | 
						|
	// attrs are defined in attr.go
 | 
						|
	Attrs map[string]string `protobuf:"bytes,2,rep,name=attrs,proto3" json:"attrs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *SourceOp) Reset()         { *m = SourceOp{} }
 | 
						|
func (m *SourceOp) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*SourceOp) ProtoMessage()    {}
 | 
						|
func (*SourceOp) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{9}
 | 
						|
}
 | 
						|
func (m *SourceOp) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *SourceOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *SourceOp) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_SourceOp.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *SourceOp) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *SourceOp) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_SourceOp.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_SourceOp proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *SourceOp) GetIdentifier() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Identifier
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *SourceOp) GetAttrs() map[string]string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Attrs
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
// BuildOp is used for nested build invocation.
 | 
						|
// BuildOp is experimental and can break without backwards compatibility
 | 
						|
type BuildOp struct {
 | 
						|
	Builder InputIndex             `protobuf:"varint,1,opt,name=builder,proto3,customtype=InputIndex" json:"builder"`
 | 
						|
	Inputs  map[string]*BuildInput `protobuf:"bytes,2,rep,name=inputs,proto3" json:"inputs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 | 
						|
	Def     *Definition            `protobuf:"bytes,3,opt,name=def,proto3" json:"def,omitempty"`
 | 
						|
	Attrs   map[string]string      `protobuf:"bytes,4,rep,name=attrs,proto3" json:"attrs,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *BuildOp) Reset()         { *m = BuildOp{} }
 | 
						|
func (m *BuildOp) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*BuildOp) ProtoMessage()    {}
 | 
						|
func (*BuildOp) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{10}
 | 
						|
}
 | 
						|
func (m *BuildOp) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *BuildOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *BuildOp) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_BuildOp.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *BuildOp) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *BuildOp) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_BuildOp.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_BuildOp proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *BuildOp) GetInputs() map[string]*BuildInput {
 | 
						|
	if m != nil {
 | 
						|
		return m.Inputs
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *BuildOp) GetDef() *Definition {
 | 
						|
	if m != nil {
 | 
						|
		return m.Def
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *BuildOp) GetAttrs() map[string]string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Attrs
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
// BuildInput is used for BuildOp.
 | 
						|
type BuildInput struct {
 | 
						|
	Input InputIndex `protobuf:"varint,1,opt,name=input,proto3,customtype=InputIndex" json:"input"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *BuildInput) Reset()         { *m = BuildInput{} }
 | 
						|
func (m *BuildInput) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*BuildInput) ProtoMessage()    {}
 | 
						|
func (*BuildInput) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{11}
 | 
						|
}
 | 
						|
func (m *BuildInput) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *BuildInput) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *BuildInput) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_BuildInput.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *BuildInput) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *BuildInput) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_BuildInput.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_BuildInput proto.InternalMessageInfo
 | 
						|
 | 
						|
// OpMetadata is a per-vertex metadata entry, which can be defined for arbitrary Op vertex and overridable on the run time.
 | 
						|
type OpMetadata struct {
 | 
						|
	// ignore_cache specifies to ignore the cache for this Op.
 | 
						|
	IgnoreCache bool `protobuf:"varint,1,opt,name=ignore_cache,json=ignoreCache,proto3" json:"ignore_cache,omitempty"`
 | 
						|
	// Description can be used for keeping any text fields that builder doesn't parse
 | 
						|
	Description map[string]string `protobuf:"bytes,2,rep,name=description,proto3" json:"description,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 | 
						|
	// index 3 reserved for WorkerConstraint in previous versions
 | 
						|
	// WorkerConstraint worker_constraint = 3;
 | 
						|
	ExportCache *ExportCache                                         `protobuf:"bytes,4,opt,name=export_cache,json=exportCache,proto3" json:"export_cache,omitempty"`
 | 
						|
	Caps        map[github_com_moby_buildkit_util_apicaps.CapID]bool `protobuf:"bytes,5,rep,name=caps,proto3,castkey=github.com/moby/buildkit/util/apicaps.CapID" json:"caps" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"varint,2,opt,name=value,proto3"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *OpMetadata) Reset()         { *m = OpMetadata{} }
 | 
						|
func (m *OpMetadata) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*OpMetadata) ProtoMessage()    {}
 | 
						|
func (*OpMetadata) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{12}
 | 
						|
}
 | 
						|
func (m *OpMetadata) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *OpMetadata) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *OpMetadata) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_OpMetadata.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *OpMetadata) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *OpMetadata) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_OpMetadata.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_OpMetadata proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *OpMetadata) GetIgnoreCache() bool {
 | 
						|
	if m != nil {
 | 
						|
		return m.IgnoreCache
 | 
						|
	}
 | 
						|
	return false
 | 
						|
}
 | 
						|
 | 
						|
func (m *OpMetadata) GetDescription() map[string]string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Description
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *OpMetadata) GetExportCache() *ExportCache {
 | 
						|
	if m != nil {
 | 
						|
		return m.ExportCache
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *OpMetadata) GetCaps() map[github_com_moby_buildkit_util_apicaps.CapID]bool {
 | 
						|
	if m != nil {
 | 
						|
		return m.Caps
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
// Source is a source mapping description for a file
 | 
						|
type Source struct {
 | 
						|
	Locations map[string]*Locations `protobuf:"bytes,1,rep,name=locations,proto3" json:"locations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 | 
						|
	Infos     []*SourceInfo         `protobuf:"bytes,2,rep,name=infos,proto3" json:"infos,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *Source) Reset()         { *m = Source{} }
 | 
						|
func (m *Source) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*Source) ProtoMessage()    {}
 | 
						|
func (*Source) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{13}
 | 
						|
}
 | 
						|
func (m *Source) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *Source) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *Source) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_Source.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *Source) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *Source) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_Source.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_Source proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *Source) GetLocations() map[string]*Locations {
 | 
						|
	if m != nil {
 | 
						|
		return m.Locations
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Source) GetInfos() []*SourceInfo {
 | 
						|
	if m != nil {
 | 
						|
		return m.Infos
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
// Locations is a list of ranges with a index to its source map.
 | 
						|
type Locations struct {
 | 
						|
	Locations []*Location `protobuf:"bytes,1,rep,name=locations,proto3" json:"locations,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *Locations) Reset()         { *m = Locations{} }
 | 
						|
func (m *Locations) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*Locations) ProtoMessage()    {}
 | 
						|
func (*Locations) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{14}
 | 
						|
}
 | 
						|
func (m *Locations) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *Locations) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *Locations) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_Locations.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *Locations) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *Locations) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_Locations.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_Locations proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *Locations) GetLocations() []*Location {
 | 
						|
	if m != nil {
 | 
						|
		return m.Locations
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
// Source info contains the shared metadata of a source mapping
 | 
						|
type SourceInfo struct {
 | 
						|
	Filename   string      `protobuf:"bytes,1,opt,name=filename,proto3" json:"filename,omitempty"`
 | 
						|
	Data       []byte      `protobuf:"bytes,2,opt,name=data,proto3" json:"data,omitempty"`
 | 
						|
	Definition *Definition `protobuf:"bytes,3,opt,name=definition,proto3" json:"definition,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *SourceInfo) Reset()         { *m = SourceInfo{} }
 | 
						|
func (m *SourceInfo) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*SourceInfo) ProtoMessage()    {}
 | 
						|
func (*SourceInfo) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{15}
 | 
						|
}
 | 
						|
func (m *SourceInfo) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *SourceInfo) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *SourceInfo) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_SourceInfo.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *SourceInfo) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *SourceInfo) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_SourceInfo.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_SourceInfo proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *SourceInfo) GetFilename() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Filename
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *SourceInfo) GetData() []byte {
 | 
						|
	if m != nil {
 | 
						|
		return m.Data
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *SourceInfo) GetDefinition() *Definition {
 | 
						|
	if m != nil {
 | 
						|
		return m.Definition
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
// Location defines list of areas in to source file
 | 
						|
type Location struct {
 | 
						|
	SourceIndex int32    `protobuf:"varint,1,opt,name=sourceIndex,proto3" json:"sourceIndex,omitempty"`
 | 
						|
	Ranges      []*Range `protobuf:"bytes,2,rep,name=ranges,proto3" json:"ranges,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *Location) Reset()         { *m = Location{} }
 | 
						|
func (m *Location) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*Location) ProtoMessage()    {}
 | 
						|
func (*Location) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{16}
 | 
						|
}
 | 
						|
func (m *Location) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *Location) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *Location) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_Location.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *Location) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *Location) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_Location.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_Location proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *Location) GetSourceIndex() int32 {
 | 
						|
	if m != nil {
 | 
						|
		return m.SourceIndex
 | 
						|
	}
 | 
						|
	return 0
 | 
						|
}
 | 
						|
 | 
						|
func (m *Location) GetRanges() []*Range {
 | 
						|
	if m != nil {
 | 
						|
		return m.Ranges
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
// Range is an area in the source file
 | 
						|
type Range struct {
 | 
						|
	Start Position `protobuf:"bytes,1,opt,name=start,proto3" json:"start"`
 | 
						|
	End   Position `protobuf:"bytes,2,opt,name=end,proto3" json:"end"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *Range) Reset()         { *m = Range{} }
 | 
						|
func (m *Range) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*Range) ProtoMessage()    {}
 | 
						|
func (*Range) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{17}
 | 
						|
}
 | 
						|
func (m *Range) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *Range) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *Range) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_Range.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *Range) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *Range) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_Range.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_Range proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *Range) GetStart() Position {
 | 
						|
	if m != nil {
 | 
						|
		return m.Start
 | 
						|
	}
 | 
						|
	return Position{}
 | 
						|
}
 | 
						|
 | 
						|
func (m *Range) GetEnd() Position {
 | 
						|
	if m != nil {
 | 
						|
		return m.End
 | 
						|
	}
 | 
						|
	return Position{}
 | 
						|
}
 | 
						|
 | 
						|
// Position is single location in a source file
 | 
						|
type Position struct {
 | 
						|
	Line      int32 `protobuf:"varint,1,opt,name=Line,proto3" json:"Line,omitempty"`
 | 
						|
	Character int32 `protobuf:"varint,2,opt,name=Character,proto3" json:"Character,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *Position) Reset()         { *m = Position{} }
 | 
						|
func (m *Position) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*Position) ProtoMessage()    {}
 | 
						|
func (*Position) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{18}
 | 
						|
}
 | 
						|
func (m *Position) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *Position) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *Position) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_Position.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *Position) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *Position) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_Position.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_Position proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *Position) GetLine() int32 {
 | 
						|
	if m != nil {
 | 
						|
		return m.Line
 | 
						|
	}
 | 
						|
	return 0
 | 
						|
}
 | 
						|
 | 
						|
func (m *Position) GetCharacter() int32 {
 | 
						|
	if m != nil {
 | 
						|
		return m.Character
 | 
						|
	}
 | 
						|
	return 0
 | 
						|
}
 | 
						|
 | 
						|
type ExportCache struct {
 | 
						|
	Value bool `protobuf:"varint,1,opt,name=Value,proto3" json:"Value,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *ExportCache) Reset()         { *m = ExportCache{} }
 | 
						|
func (m *ExportCache) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*ExportCache) ProtoMessage()    {}
 | 
						|
func (*ExportCache) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{19}
 | 
						|
}
 | 
						|
func (m *ExportCache) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *ExportCache) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *ExportCache) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_ExportCache.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *ExportCache) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *ExportCache) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_ExportCache.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_ExportCache proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *ExportCache) GetValue() bool {
 | 
						|
	if m != nil {
 | 
						|
		return m.Value
 | 
						|
	}
 | 
						|
	return false
 | 
						|
}
 | 
						|
 | 
						|
type ProxyEnv struct {
 | 
						|
	HttpProxy  string `protobuf:"bytes,1,opt,name=http_proxy,json=httpProxy,proto3" json:"http_proxy,omitempty"`
 | 
						|
	HttpsProxy string `protobuf:"bytes,2,opt,name=https_proxy,json=httpsProxy,proto3" json:"https_proxy,omitempty"`
 | 
						|
	FtpProxy   string `protobuf:"bytes,3,opt,name=ftp_proxy,json=ftpProxy,proto3" json:"ftp_proxy,omitempty"`
 | 
						|
	NoProxy    string `protobuf:"bytes,4,opt,name=no_proxy,json=noProxy,proto3" json:"no_proxy,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *ProxyEnv) Reset()         { *m = ProxyEnv{} }
 | 
						|
func (m *ProxyEnv) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*ProxyEnv) ProtoMessage()    {}
 | 
						|
func (*ProxyEnv) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{20}
 | 
						|
}
 | 
						|
func (m *ProxyEnv) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *ProxyEnv) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *ProxyEnv) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_ProxyEnv.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *ProxyEnv) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *ProxyEnv) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_ProxyEnv.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_ProxyEnv proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *ProxyEnv) GetHttpProxy() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.HttpProxy
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *ProxyEnv) GetHttpsProxy() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.HttpsProxy
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *ProxyEnv) GetFtpProxy() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.FtpProxy
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *ProxyEnv) GetNoProxy() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.NoProxy
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
// WorkerConstraints defines conditions for the worker
 | 
						|
type WorkerConstraints struct {
 | 
						|
	Filter []string `protobuf:"bytes,1,rep,name=filter,proto3" json:"filter,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *WorkerConstraints) Reset()         { *m = WorkerConstraints{} }
 | 
						|
func (m *WorkerConstraints) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*WorkerConstraints) ProtoMessage()    {}
 | 
						|
func (*WorkerConstraints) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{21}
 | 
						|
}
 | 
						|
func (m *WorkerConstraints) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *WorkerConstraints) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *WorkerConstraints) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_WorkerConstraints.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *WorkerConstraints) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *WorkerConstraints) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_WorkerConstraints.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_WorkerConstraints proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *WorkerConstraints) GetFilter() []string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Filter
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
// Definition is the LLB definition structure with per-vertex metadata entries
 | 
						|
type Definition struct {
 | 
						|
	// def is a list of marshaled Op messages
 | 
						|
	Def [][]byte `protobuf:"bytes,1,rep,name=def,proto3" json:"def,omitempty"`
 | 
						|
	// metadata contains metadata for the each of the Op messages.
 | 
						|
	// A key must be an LLB op digest string. Currently, empty string is not expected as a key, but it may change in the future.
 | 
						|
	Metadata map[github_com_opencontainers_go_digest.Digest]OpMetadata `protobuf:"bytes,2,rep,name=metadata,proto3,castkey=github.com/opencontainers/go-digest.Digest" json:"metadata" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 | 
						|
	// Source contains the source mapping information for the vertexes in the definition
 | 
						|
	Source *Source `protobuf:"bytes,3,opt,name=Source,proto3" json:"Source,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *Definition) Reset()         { *m = Definition{} }
 | 
						|
func (m *Definition) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*Definition) ProtoMessage()    {}
 | 
						|
func (*Definition) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{22}
 | 
						|
}
 | 
						|
func (m *Definition) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *Definition) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *Definition) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_Definition.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *Definition) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *Definition) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_Definition.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_Definition proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *Definition) GetDef() [][]byte {
 | 
						|
	if m != nil {
 | 
						|
		return m.Def
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Definition) GetMetadata() map[github_com_opencontainers_go_digest.Digest]OpMetadata {
 | 
						|
	if m != nil {
 | 
						|
		return m.Metadata
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Definition) GetSource() *Source {
 | 
						|
	if m != nil {
 | 
						|
		return m.Source
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
type HostIP struct {
 | 
						|
	Host string `protobuf:"bytes,1,opt,name=Host,proto3" json:"Host,omitempty"`
 | 
						|
	IP   string `protobuf:"bytes,2,opt,name=IP,proto3" json:"IP,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *HostIP) Reset()         { *m = HostIP{} }
 | 
						|
func (m *HostIP) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*HostIP) ProtoMessage()    {}
 | 
						|
func (*HostIP) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{23}
 | 
						|
}
 | 
						|
func (m *HostIP) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *HostIP) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *HostIP) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_HostIP.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *HostIP) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *HostIP) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_HostIP.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_HostIP proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *HostIP) GetHost() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Host
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *HostIP) GetIP() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.IP
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
type FileOp struct {
 | 
						|
	Actions []*FileAction `protobuf:"bytes,2,rep,name=actions,proto3" json:"actions,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileOp) Reset()         { *m = FileOp{} }
 | 
						|
func (m *FileOp) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*FileOp) ProtoMessage()    {}
 | 
						|
func (*FileOp) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{24}
 | 
						|
}
 | 
						|
func (m *FileOp) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *FileOp) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *FileOp) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_FileOp.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *FileOp) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *FileOp) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_FileOp.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_FileOp proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *FileOp) GetActions() []*FileAction {
 | 
						|
	if m != nil {
 | 
						|
		return m.Actions
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
type FileAction struct {
 | 
						|
	Input          InputIndex  `protobuf:"varint,1,opt,name=input,proto3,customtype=InputIndex" json:"input"`
 | 
						|
	SecondaryInput InputIndex  `protobuf:"varint,2,opt,name=secondaryInput,proto3,customtype=InputIndex" json:"secondaryInput"`
 | 
						|
	Output         OutputIndex `protobuf:"varint,3,opt,name=output,proto3,customtype=OutputIndex" json:"output"`
 | 
						|
	// Types that are valid to be assigned to Action:
 | 
						|
	//	*FileAction_Copy
 | 
						|
	//	*FileAction_Mkfile
 | 
						|
	//	*FileAction_Mkdir
 | 
						|
	//	*FileAction_Rm
 | 
						|
	Action isFileAction_Action `protobuf_oneof:"action"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileAction) Reset()         { *m = FileAction{} }
 | 
						|
func (m *FileAction) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*FileAction) ProtoMessage()    {}
 | 
						|
func (*FileAction) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{25}
 | 
						|
}
 | 
						|
func (m *FileAction) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *FileAction) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *FileAction) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_FileAction.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *FileAction) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *FileAction) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_FileAction.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_FileAction proto.InternalMessageInfo
 | 
						|
 | 
						|
type isFileAction_Action interface {
 | 
						|
	isFileAction_Action()
 | 
						|
	MarshalTo([]byte) (int, error)
 | 
						|
	Size() int
 | 
						|
}
 | 
						|
 | 
						|
type FileAction_Copy struct {
 | 
						|
	Copy *FileActionCopy `protobuf:"bytes,4,opt,name=copy,proto3,oneof" json:"copy,omitempty"`
 | 
						|
}
 | 
						|
type FileAction_Mkfile struct {
 | 
						|
	Mkfile *FileActionMkFile `protobuf:"bytes,5,opt,name=mkfile,proto3,oneof" json:"mkfile,omitempty"`
 | 
						|
}
 | 
						|
type FileAction_Mkdir struct {
 | 
						|
	Mkdir *FileActionMkDir `protobuf:"bytes,6,opt,name=mkdir,proto3,oneof" json:"mkdir,omitempty"`
 | 
						|
}
 | 
						|
type FileAction_Rm struct {
 | 
						|
	Rm *FileActionRm `protobuf:"bytes,7,opt,name=rm,proto3,oneof" json:"rm,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (*FileAction_Copy) isFileAction_Action()   {}
 | 
						|
func (*FileAction_Mkfile) isFileAction_Action() {}
 | 
						|
func (*FileAction_Mkdir) isFileAction_Action()  {}
 | 
						|
func (*FileAction_Rm) isFileAction_Action()     {}
 | 
						|
 | 
						|
func (m *FileAction) GetAction() isFileAction_Action {
 | 
						|
	if m != nil {
 | 
						|
		return m.Action
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileAction) GetCopy() *FileActionCopy {
 | 
						|
	if x, ok := m.GetAction().(*FileAction_Copy); ok {
 | 
						|
		return x.Copy
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileAction) GetMkfile() *FileActionMkFile {
 | 
						|
	if x, ok := m.GetAction().(*FileAction_Mkfile); ok {
 | 
						|
		return x.Mkfile
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileAction) GetMkdir() *FileActionMkDir {
 | 
						|
	if x, ok := m.GetAction().(*FileAction_Mkdir); ok {
 | 
						|
		return x.Mkdir
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileAction) GetRm() *FileActionRm {
 | 
						|
	if x, ok := m.GetAction().(*FileAction_Rm); ok {
 | 
						|
		return x.Rm
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
// XXX_OneofWrappers is for the internal use of the proto package.
 | 
						|
func (*FileAction) XXX_OneofWrappers() []interface{} {
 | 
						|
	return []interface{}{
 | 
						|
		(*FileAction_Copy)(nil),
 | 
						|
		(*FileAction_Mkfile)(nil),
 | 
						|
		(*FileAction_Mkdir)(nil),
 | 
						|
		(*FileAction_Rm)(nil),
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
type FileActionCopy struct {
 | 
						|
	// src is the source path
 | 
						|
	Src string `protobuf:"bytes,1,opt,name=src,proto3" json:"src,omitempty"`
 | 
						|
	// dest path
 | 
						|
	Dest string `protobuf:"bytes,2,opt,name=dest,proto3" json:"dest,omitempty"`
 | 
						|
	// optional owner override
 | 
						|
	Owner *ChownOpt `protobuf:"bytes,3,opt,name=owner,proto3" json:"owner,omitempty"`
 | 
						|
	// optional permission bits override
 | 
						|
	Mode int32 `protobuf:"varint,4,opt,name=mode,proto3" json:"mode,omitempty"`
 | 
						|
	// followSymlink resolves symlinks in src
 | 
						|
	FollowSymlink bool `protobuf:"varint,5,opt,name=followSymlink,proto3" json:"followSymlink,omitempty"`
 | 
						|
	// dirCopyContents only copies contents if src is a directory
 | 
						|
	DirCopyContents bool `protobuf:"varint,6,opt,name=dirCopyContents,proto3" json:"dirCopyContents,omitempty"`
 | 
						|
	// attemptUnpackDockerCompatibility detects if src is an archive to unpack it instead
 | 
						|
	AttemptUnpackDockerCompatibility bool `protobuf:"varint,7,opt,name=attemptUnpackDockerCompatibility,proto3" json:"attemptUnpackDockerCompatibility,omitempty"`
 | 
						|
	// createDestPath creates dest path directories if needed
 | 
						|
	CreateDestPath bool `protobuf:"varint,8,opt,name=createDestPath,proto3" json:"createDestPath,omitempty"`
 | 
						|
	// allowWildcard allows filepath.Match wildcards in src path
 | 
						|
	AllowWildcard bool `protobuf:"varint,9,opt,name=allowWildcard,proto3" json:"allowWildcard,omitempty"`
 | 
						|
	// allowEmptyWildcard doesn't fail the whole copy if wildcard doesn't resolve to files
 | 
						|
	AllowEmptyWildcard bool `protobuf:"varint,10,opt,name=allowEmptyWildcard,proto3" json:"allowEmptyWildcard,omitempty"`
 | 
						|
	// optional created time override
 | 
						|
	Timestamp int64 `protobuf:"varint,11,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionCopy) Reset()         { *m = FileActionCopy{} }
 | 
						|
func (m *FileActionCopy) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*FileActionCopy) ProtoMessage()    {}
 | 
						|
func (*FileActionCopy) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{26}
 | 
						|
}
 | 
						|
func (m *FileActionCopy) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *FileActionCopy) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *FileActionCopy) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_FileActionCopy.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *FileActionCopy) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *FileActionCopy) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_FileActionCopy.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_FileActionCopy proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *FileActionCopy) GetSrc() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Src
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionCopy) GetDest() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Dest
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionCopy) GetOwner() *ChownOpt {
 | 
						|
	if m != nil {
 | 
						|
		return m.Owner
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionCopy) GetMode() int32 {
 | 
						|
	if m != nil {
 | 
						|
		return m.Mode
 | 
						|
	}
 | 
						|
	return 0
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionCopy) GetFollowSymlink() bool {
 | 
						|
	if m != nil {
 | 
						|
		return m.FollowSymlink
 | 
						|
	}
 | 
						|
	return false
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionCopy) GetDirCopyContents() bool {
 | 
						|
	if m != nil {
 | 
						|
		return m.DirCopyContents
 | 
						|
	}
 | 
						|
	return false
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionCopy) GetAttemptUnpackDockerCompatibility() bool {
 | 
						|
	if m != nil {
 | 
						|
		return m.AttemptUnpackDockerCompatibility
 | 
						|
	}
 | 
						|
	return false
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionCopy) GetCreateDestPath() bool {
 | 
						|
	if m != nil {
 | 
						|
		return m.CreateDestPath
 | 
						|
	}
 | 
						|
	return false
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionCopy) GetAllowWildcard() bool {
 | 
						|
	if m != nil {
 | 
						|
		return m.AllowWildcard
 | 
						|
	}
 | 
						|
	return false
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionCopy) GetAllowEmptyWildcard() bool {
 | 
						|
	if m != nil {
 | 
						|
		return m.AllowEmptyWildcard
 | 
						|
	}
 | 
						|
	return false
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionCopy) GetTimestamp() int64 {
 | 
						|
	if m != nil {
 | 
						|
		return m.Timestamp
 | 
						|
	}
 | 
						|
	return 0
 | 
						|
}
 | 
						|
 | 
						|
type FileActionMkFile struct {
 | 
						|
	// path for the new file
 | 
						|
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
 | 
						|
	// permission bits
 | 
						|
	Mode int32 `protobuf:"varint,2,opt,name=mode,proto3" json:"mode,omitempty"`
 | 
						|
	// data is the new file contents
 | 
						|
	Data []byte `protobuf:"bytes,3,opt,name=data,proto3" json:"data,omitempty"`
 | 
						|
	// optional owner for the new file
 | 
						|
	Owner *ChownOpt `protobuf:"bytes,4,opt,name=owner,proto3" json:"owner,omitempty"`
 | 
						|
	// optional created time override
 | 
						|
	Timestamp int64 `protobuf:"varint,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkFile) Reset()         { *m = FileActionMkFile{} }
 | 
						|
func (m *FileActionMkFile) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*FileActionMkFile) ProtoMessage()    {}
 | 
						|
func (*FileActionMkFile) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{27}
 | 
						|
}
 | 
						|
func (m *FileActionMkFile) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *FileActionMkFile) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *FileActionMkFile) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_FileActionMkFile.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *FileActionMkFile) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *FileActionMkFile) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_FileActionMkFile.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_FileActionMkFile proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *FileActionMkFile) GetPath() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Path
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkFile) GetMode() int32 {
 | 
						|
	if m != nil {
 | 
						|
		return m.Mode
 | 
						|
	}
 | 
						|
	return 0
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkFile) GetData() []byte {
 | 
						|
	if m != nil {
 | 
						|
		return m.Data
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkFile) GetOwner() *ChownOpt {
 | 
						|
	if m != nil {
 | 
						|
		return m.Owner
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkFile) GetTimestamp() int64 {
 | 
						|
	if m != nil {
 | 
						|
		return m.Timestamp
 | 
						|
	}
 | 
						|
	return 0
 | 
						|
}
 | 
						|
 | 
						|
type FileActionMkDir struct {
 | 
						|
	// path for the new directory
 | 
						|
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
 | 
						|
	// permission bits
 | 
						|
	Mode int32 `protobuf:"varint,2,opt,name=mode,proto3" json:"mode,omitempty"`
 | 
						|
	// makeParents creates parent directories as well if needed
 | 
						|
	MakeParents bool `protobuf:"varint,3,opt,name=makeParents,proto3" json:"makeParents,omitempty"`
 | 
						|
	// optional owner for the new directory
 | 
						|
	Owner *ChownOpt `protobuf:"bytes,4,opt,name=owner,proto3" json:"owner,omitempty"`
 | 
						|
	// optional created time override
 | 
						|
	Timestamp int64 `protobuf:"varint,5,opt,name=timestamp,proto3" json:"timestamp,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkDir) Reset()         { *m = FileActionMkDir{} }
 | 
						|
func (m *FileActionMkDir) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*FileActionMkDir) ProtoMessage()    {}
 | 
						|
func (*FileActionMkDir) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{28}
 | 
						|
}
 | 
						|
func (m *FileActionMkDir) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *FileActionMkDir) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *FileActionMkDir) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_FileActionMkDir.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *FileActionMkDir) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *FileActionMkDir) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_FileActionMkDir.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_FileActionMkDir proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *FileActionMkDir) GetPath() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Path
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkDir) GetMode() int32 {
 | 
						|
	if m != nil {
 | 
						|
		return m.Mode
 | 
						|
	}
 | 
						|
	return 0
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkDir) GetMakeParents() bool {
 | 
						|
	if m != nil {
 | 
						|
		return m.MakeParents
 | 
						|
	}
 | 
						|
	return false
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkDir) GetOwner() *ChownOpt {
 | 
						|
	if m != nil {
 | 
						|
		return m.Owner
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkDir) GetTimestamp() int64 {
 | 
						|
	if m != nil {
 | 
						|
		return m.Timestamp
 | 
						|
	}
 | 
						|
	return 0
 | 
						|
}
 | 
						|
 | 
						|
type FileActionRm struct {
 | 
						|
	// path to remove
 | 
						|
	Path string `protobuf:"bytes,1,opt,name=path,proto3" json:"path,omitempty"`
 | 
						|
	// allowNotFound doesn't fail the rm if file is not found
 | 
						|
	AllowNotFound bool `protobuf:"varint,2,opt,name=allowNotFound,proto3" json:"allowNotFound,omitempty"`
 | 
						|
	// allowWildcard allows filepath.Match wildcards in path
 | 
						|
	AllowWildcard bool `protobuf:"varint,3,opt,name=allowWildcard,proto3" json:"allowWildcard,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionRm) Reset()         { *m = FileActionRm{} }
 | 
						|
func (m *FileActionRm) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*FileActionRm) ProtoMessage()    {}
 | 
						|
func (*FileActionRm) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{29}
 | 
						|
}
 | 
						|
func (m *FileActionRm) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *FileActionRm) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *FileActionRm) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_FileActionRm.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *FileActionRm) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *FileActionRm) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_FileActionRm.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_FileActionRm proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *FileActionRm) GetPath() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Path
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionRm) GetAllowNotFound() bool {
 | 
						|
	if m != nil {
 | 
						|
		return m.AllowNotFound
 | 
						|
	}
 | 
						|
	return false
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionRm) GetAllowWildcard() bool {
 | 
						|
	if m != nil {
 | 
						|
		return m.AllowWildcard
 | 
						|
	}
 | 
						|
	return false
 | 
						|
}
 | 
						|
 | 
						|
type ChownOpt struct {
 | 
						|
	User  *UserOpt `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
 | 
						|
	Group *UserOpt `protobuf:"bytes,2,opt,name=group,proto3" json:"group,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *ChownOpt) Reset()         { *m = ChownOpt{} }
 | 
						|
func (m *ChownOpt) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*ChownOpt) ProtoMessage()    {}
 | 
						|
func (*ChownOpt) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{30}
 | 
						|
}
 | 
						|
func (m *ChownOpt) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *ChownOpt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *ChownOpt) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_ChownOpt.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *ChownOpt) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *ChownOpt) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_ChownOpt.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_ChownOpt proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *ChownOpt) GetUser() *UserOpt {
 | 
						|
	if m != nil {
 | 
						|
		return m.User
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *ChownOpt) GetGroup() *UserOpt {
 | 
						|
	if m != nil {
 | 
						|
		return m.Group
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
type UserOpt struct {
 | 
						|
	// Types that are valid to be assigned to User:
 | 
						|
	//	*UserOpt_ByName
 | 
						|
	//	*UserOpt_ByID
 | 
						|
	User isUserOpt_User `protobuf_oneof:"user"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *UserOpt) Reset()         { *m = UserOpt{} }
 | 
						|
func (m *UserOpt) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*UserOpt) ProtoMessage()    {}
 | 
						|
func (*UserOpt) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{31}
 | 
						|
}
 | 
						|
func (m *UserOpt) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *UserOpt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *UserOpt) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_UserOpt.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *UserOpt) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *UserOpt) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_UserOpt.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_UserOpt proto.InternalMessageInfo
 | 
						|
 | 
						|
type isUserOpt_User interface {
 | 
						|
	isUserOpt_User()
 | 
						|
	MarshalTo([]byte) (int, error)
 | 
						|
	Size() int
 | 
						|
}
 | 
						|
 | 
						|
type UserOpt_ByName struct {
 | 
						|
	ByName *NamedUserOpt `protobuf:"bytes,1,opt,name=byName,proto3,oneof" json:"byName,omitempty"`
 | 
						|
}
 | 
						|
type UserOpt_ByID struct {
 | 
						|
	ByID uint32 `protobuf:"varint,2,opt,name=byID,proto3,oneof" json:"byID,omitempty"`
 | 
						|
}
 | 
						|
 | 
						|
func (*UserOpt_ByName) isUserOpt_User() {}
 | 
						|
func (*UserOpt_ByID) isUserOpt_User()   {}
 | 
						|
 | 
						|
func (m *UserOpt) GetUser() isUserOpt_User {
 | 
						|
	if m != nil {
 | 
						|
		return m.User
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *UserOpt) GetByName() *NamedUserOpt {
 | 
						|
	if x, ok := m.GetUser().(*UserOpt_ByName); ok {
 | 
						|
		return x.ByName
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *UserOpt) GetByID() uint32 {
 | 
						|
	if x, ok := m.GetUser().(*UserOpt_ByID); ok {
 | 
						|
		return x.ByID
 | 
						|
	}
 | 
						|
	return 0
 | 
						|
}
 | 
						|
 | 
						|
// XXX_OneofWrappers is for the internal use of the proto package.
 | 
						|
func (*UserOpt) XXX_OneofWrappers() []interface{} {
 | 
						|
	return []interface{}{
 | 
						|
		(*UserOpt_ByName)(nil),
 | 
						|
		(*UserOpt_ByID)(nil),
 | 
						|
	}
 | 
						|
}
 | 
						|
 | 
						|
type NamedUserOpt struct {
 | 
						|
	Name  string     `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
 | 
						|
	Input InputIndex `protobuf:"varint,2,opt,name=input,proto3,customtype=InputIndex" json:"input"`
 | 
						|
}
 | 
						|
 | 
						|
func (m *NamedUserOpt) Reset()         { *m = NamedUserOpt{} }
 | 
						|
func (m *NamedUserOpt) String() string { return proto.CompactTextString(m) }
 | 
						|
func (*NamedUserOpt) ProtoMessage()    {}
 | 
						|
func (*NamedUserOpt) Descriptor() ([]byte, []int) {
 | 
						|
	return fileDescriptor_8de16154b2733812, []int{32}
 | 
						|
}
 | 
						|
func (m *NamedUserOpt) XXX_Unmarshal(b []byte) error {
 | 
						|
	return m.Unmarshal(b)
 | 
						|
}
 | 
						|
func (m *NamedUserOpt) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
 | 
						|
	b = b[:cap(b)]
 | 
						|
	n, err := m.MarshalToSizedBuffer(b)
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return b[:n], nil
 | 
						|
}
 | 
						|
func (m *NamedUserOpt) XXX_Merge(src proto.Message) {
 | 
						|
	xxx_messageInfo_NamedUserOpt.Merge(m, src)
 | 
						|
}
 | 
						|
func (m *NamedUserOpt) XXX_Size() int {
 | 
						|
	return m.Size()
 | 
						|
}
 | 
						|
func (m *NamedUserOpt) XXX_DiscardUnknown() {
 | 
						|
	xxx_messageInfo_NamedUserOpt.DiscardUnknown(m)
 | 
						|
}
 | 
						|
 | 
						|
var xxx_messageInfo_NamedUserOpt proto.InternalMessageInfo
 | 
						|
 | 
						|
func (m *NamedUserOpt) GetName() string {
 | 
						|
	if m != nil {
 | 
						|
		return m.Name
 | 
						|
	}
 | 
						|
	return ""
 | 
						|
}
 | 
						|
 | 
						|
func init() {
 | 
						|
	proto.RegisterEnum("pb.NetMode", NetMode_name, NetMode_value)
 | 
						|
	proto.RegisterEnum("pb.SecurityMode", SecurityMode_name, SecurityMode_value)
 | 
						|
	proto.RegisterEnum("pb.MountType", MountType_name, MountType_value)
 | 
						|
	proto.RegisterEnum("pb.CacheSharingOpt", CacheSharingOpt_name, CacheSharingOpt_value)
 | 
						|
	proto.RegisterType((*Op)(nil), "pb.Op")
 | 
						|
	proto.RegisterType((*Platform)(nil), "pb.Platform")
 | 
						|
	proto.RegisterType((*Input)(nil), "pb.Input")
 | 
						|
	proto.RegisterType((*ExecOp)(nil), "pb.ExecOp")
 | 
						|
	proto.RegisterType((*Meta)(nil), "pb.Meta")
 | 
						|
	proto.RegisterType((*Mount)(nil), "pb.Mount")
 | 
						|
	proto.RegisterType((*CacheOpt)(nil), "pb.CacheOpt")
 | 
						|
	proto.RegisterType((*SecretOpt)(nil), "pb.SecretOpt")
 | 
						|
	proto.RegisterType((*SSHOpt)(nil), "pb.SSHOpt")
 | 
						|
	proto.RegisterType((*SourceOp)(nil), "pb.SourceOp")
 | 
						|
	proto.RegisterMapType((map[string]string)(nil), "pb.SourceOp.AttrsEntry")
 | 
						|
	proto.RegisterType((*BuildOp)(nil), "pb.BuildOp")
 | 
						|
	proto.RegisterMapType((map[string]string)(nil), "pb.BuildOp.AttrsEntry")
 | 
						|
	proto.RegisterMapType((map[string]*BuildInput)(nil), "pb.BuildOp.InputsEntry")
 | 
						|
	proto.RegisterType((*BuildInput)(nil), "pb.BuildInput")
 | 
						|
	proto.RegisterType((*OpMetadata)(nil), "pb.OpMetadata")
 | 
						|
	proto.RegisterMapType((map[github_com_moby_buildkit_util_apicaps.CapID]bool)(nil), "pb.OpMetadata.CapsEntry")
 | 
						|
	proto.RegisterMapType((map[string]string)(nil), "pb.OpMetadata.DescriptionEntry")
 | 
						|
	proto.RegisterType((*Source)(nil), "pb.Source")
 | 
						|
	proto.RegisterMapType((map[string]*Locations)(nil), "pb.Source.LocationsEntry")
 | 
						|
	proto.RegisterType((*Locations)(nil), "pb.Locations")
 | 
						|
	proto.RegisterType((*SourceInfo)(nil), "pb.SourceInfo")
 | 
						|
	proto.RegisterType((*Location)(nil), "pb.Location")
 | 
						|
	proto.RegisterType((*Range)(nil), "pb.Range")
 | 
						|
	proto.RegisterType((*Position)(nil), "pb.Position")
 | 
						|
	proto.RegisterType((*ExportCache)(nil), "pb.ExportCache")
 | 
						|
	proto.RegisterType((*ProxyEnv)(nil), "pb.ProxyEnv")
 | 
						|
	proto.RegisterType((*WorkerConstraints)(nil), "pb.WorkerConstraints")
 | 
						|
	proto.RegisterType((*Definition)(nil), "pb.Definition")
 | 
						|
	proto.RegisterMapType((map[github_com_opencontainers_go_digest.Digest]OpMetadata)(nil), "pb.Definition.MetadataEntry")
 | 
						|
	proto.RegisterType((*HostIP)(nil), "pb.HostIP")
 | 
						|
	proto.RegisterType((*FileOp)(nil), "pb.FileOp")
 | 
						|
	proto.RegisterType((*FileAction)(nil), "pb.FileAction")
 | 
						|
	proto.RegisterType((*FileActionCopy)(nil), "pb.FileActionCopy")
 | 
						|
	proto.RegisterType((*FileActionMkFile)(nil), "pb.FileActionMkFile")
 | 
						|
	proto.RegisterType((*FileActionMkDir)(nil), "pb.FileActionMkDir")
 | 
						|
	proto.RegisterType((*FileActionRm)(nil), "pb.FileActionRm")
 | 
						|
	proto.RegisterType((*ChownOpt)(nil), "pb.ChownOpt")
 | 
						|
	proto.RegisterType((*UserOpt)(nil), "pb.UserOpt")
 | 
						|
	proto.RegisterType((*NamedUserOpt)(nil), "pb.NamedUserOpt")
 | 
						|
}
 | 
						|
 | 
						|
func init() { proto.RegisterFile("ops.proto", fileDescriptor_8de16154b2733812) }
 | 
						|
 | 
						|
var fileDescriptor_8de16154b2733812 = []byte{
 | 
						|
	// 2189 bytes of a gzipped FileDescriptorProto
 | 
						|
	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x58, 0x4b, 0x6f, 0x1b, 0xc9,
 | 
						|
	0xf1, 0x17, 0xdf, 0x64, 0x51, 0x92, 0xf9, 0xef, 0xf5, 0xee, 0x9f, 0xab, 0x38, 0x92, 0x76, 0xec,
 | 
						|
	0x2c, 0x64, 0xd9, 0xa6, 0x00, 0x2d, 0xb0, 0x5e, 0x2c, 0x82, 0x20, 0xe2, 0xc3, 0x10, 0xd7, 0xb6,
 | 
						|
	0x28, 0x34, 0xfd, 0xc8, 0xcd, 0x18, 0x0d, 0x9b, 0xd4, 0x40, 0xe4, 0xf4, 0xa0, 0xa7, 0x69, 0x8b,
 | 
						|
	0x97, 0x1c, 0xfc, 0x09, 0x16, 0x08, 0x90, 0x5b, 0x02, 0xe4, 0x12, 0x20, 0xf7, 0x5c, 0x73, 0xdf,
 | 
						|
	0xe3, 0x22, 0xc8, 0x61, 0x91, 0xc3, 0x26, 0xb0, 0x3f, 0x47, 0x80, 0xa0, 0xaa, 0x7b, 0x1e, 0x94,
 | 
						|
	0x65, 0xd8, 0x46, 0x82, 0x9c, 0xd8, 0xfd, 0xab, 0x5f, 0x57, 0x57, 0x57, 0x55, 0xd7, 0x54, 0x13,
 | 
						|
	0x6a, 0x32, 0x8c, 0x5a, 0xa1, 0x92, 0x5a, 0xb2, 0x7c, 0x78, 0xb2, 0x71, 0x67, 0xe2, 0xeb, 0xd3,
 | 
						|
	0xf9, 0x49, 0xcb, 0x93, 0xb3, 0xbd, 0x89, 0x9c, 0xc8, 0x3d, 0x12, 0x9d, 0xcc, 0xc7, 0x34, 0xa3,
 | 
						|
	0x09, 0x8d, 0xcc, 0x12, 0xe7, 0x0f, 0x79, 0xc8, 0x0f, 0x42, 0xf6, 0x19, 0x94, 0xfd, 0x20, 0x9c,
 | 
						|
	0xeb, 0xa8, 0x99, 0xdb, 0x2e, 0xec, 0xd4, 0xf7, 0x6b, 0xad, 0xf0, 0xa4, 0xd5, 0x47, 0x84, 0x5b,
 | 
						|
	0x01, 0xdb, 0x86, 0xa2, 0x38, 0x17, 0x5e, 0x33, 0xbf, 0x9d, 0xdb, 0xa9, 0xef, 0x03, 0x12, 0x7a,
 | 
						|
	0xe7, 0xc2, 0x1b, 0x84, 0x87, 0x2b, 0x9c, 0x24, 0xec, 0x73, 0x28, 0x47, 0x72, 0xae, 0x3c, 0xd1,
 | 
						|
	0x2c, 0x10, 0x67, 0x15, 0x39, 0x43, 0x42, 0x88, 0x65, 0xa5, 0xa8, 0x69, 0xec, 0x4f, 0x45, 0xb3,
 | 
						|
	0x98, 0x6a, 0xba, 0xe7, 0x4f, 0x0d, 0x87, 0x24, 0xec, 0x3a, 0x94, 0x4e, 0xe6, 0xfe, 0x74, 0xd4,
 | 
						|
	0x2c, 0x11, 0xa5, 0x8e, 0x94, 0x36, 0x02, 0xc4, 0x31, 0x32, 0xb6, 0x03, 0xd5, 0x70, 0xea, 0xea,
 | 
						|
	0xb1, 0x54, 0xb3, 0x26, 0xa4, 0x1b, 0x1e, 0x5b, 0x8c, 0x27, 0x52, 0x76, 0x17, 0xea, 0x9e, 0x0c,
 | 
						|
	0x22, 0xad, 0x5c, 0x3f, 0xd0, 0x51, 0xb3, 0x4e, 0xe4, 0x8f, 0x91, 0xfc, 0x54, 0xaa, 0x33, 0xa1,
 | 
						|
	0x3a, 0xa9, 0x90, 0x67, 0x99, 0xed, 0x22, 0xe4, 0x65, 0xe8, 0xfc, 0x36, 0x07, 0xd5, 0x58, 0x2b,
 | 
						|
	0x73, 0x60, 0xf5, 0x40, 0x79, 0xa7, 0xbe, 0x16, 0x9e, 0x9e, 0x2b, 0xd1, 0xcc, 0x6d, 0xe7, 0x76,
 | 
						|
	0x6a, 0x7c, 0x09, 0x63, 0xeb, 0x90, 0x1f, 0x0c, 0xc9, 0x51, 0x35, 0x9e, 0x1f, 0x0c, 0x59, 0x13,
 | 
						|
	0x2a, 0x4f, 0x5c, 0xe5, 0xbb, 0x81, 0x26, 0xcf, 0xd4, 0x78, 0x3c, 0x65, 0xd7, 0xa0, 0x36, 0x18,
 | 
						|
	0x3e, 0x11, 0x2a, 0xf2, 0x65, 0x40, 0xfe, 0xa8, 0xf1, 0x14, 0x60, 0x9b, 0x00, 0x83, 0xe1, 0x3d,
 | 
						|
	0xe1, 0xa2, 0xd2, 0xa8, 0x59, 0xda, 0x2e, 0xec, 0xd4, 0x78, 0x06, 0x71, 0x7e, 0x0d, 0x25, 0x8a,
 | 
						|
	0x11, 0xfb, 0x06, 0xca, 0x23, 0x7f, 0x22, 0x22, 0x6d, 0xcc, 0x69, 0xef, 0x7f, 0xf7, 0xe3, 0xd6,
 | 
						|
	0xca, 0xdf, 0x7f, 0xdc, 0xda, 0xcd, 0x24, 0x83, 0x0c, 0x45, 0xe0, 0xc9, 0x40, 0xbb, 0x7e, 0x20,
 | 
						|
	0x54, 0xb4, 0x37, 0x91, 0x77, 0xcc, 0x92, 0x56, 0x97, 0x7e, 0xb8, 0xd5, 0xc0, 0x6e, 0x42, 0xc9,
 | 
						|
	0x0f, 0x46, 0xe2, 0x9c, 0xec, 0x2f, 0xb4, 0x3f, 0xb2, 0xaa, 0xea, 0x83, 0xb9, 0x0e, 0xe7, 0xba,
 | 
						|
	0x8f, 0x22, 0x6e, 0x18, 0xce, 0xef, 0x73, 0x50, 0x36, 0x39, 0xc0, 0xae, 0x41, 0x71, 0x26, 0xb4,
 | 
						|
	0x4b, 0xfb, 0xd7, 0xf7, 0xab, 0xe8, 0xdb, 0x87, 0x42, 0xbb, 0x9c, 0x50, 0x4c, 0xaf, 0x99, 0x9c,
 | 
						|
	0xa3, 0xef, 0xf3, 0x69, 0x7a, 0x3d, 0x44, 0x84, 0x5b, 0x01, 0xfb, 0x19, 0x54, 0x02, 0xa1, 0x5f,
 | 
						|
	0x48, 0x75, 0x46, 0x3e, 0x5a, 0x37, 0x41, 0x3f, 0x12, 0xfa, 0xa1, 0x1c, 0x09, 0x1e, 0xcb, 0xd8,
 | 
						|
	0x6d, 0xa8, 0x46, 0xc2, 0x9b, 0x2b, 0x5f, 0x2f, 0xc8, 0x5f, 0xeb, 0xfb, 0x0d, 0xca, 0x32, 0x8b,
 | 
						|
	0x11, 0x39, 0x61, 0x38, 0x7f, 0xca, 0x41, 0x11, 0xcd, 0x60, 0x0c, 0x8a, 0xae, 0x9a, 0x98, 0xec,
 | 
						|
	0xae, 0x71, 0x1a, 0xb3, 0x06, 0x14, 0x44, 0xf0, 0x9c, 0x2c, 0xaa, 0x71, 0x1c, 0x22, 0xe2, 0xbd,
 | 
						|
	0x18, 0xd9, 0x18, 0xe1, 0x10, 0xd7, 0xcd, 0x23, 0xa1, 0x6c, 0x68, 0x68, 0xcc, 0x6e, 0x42, 0x2d,
 | 
						|
	0x54, 0xf2, 0x7c, 0xf1, 0x0c, 0x57, 0x97, 0x32, 0x89, 0x87, 0x60, 0x2f, 0x78, 0xce, 0xab, 0xa1,
 | 
						|
	0x1d, 0xb1, 0x5d, 0x00, 0x71, 0xae, 0x95, 0x7b, 0x28, 0x23, 0x1d, 0x35, 0xcb, 0x74, 0x76, 0xca,
 | 
						|
	0x77, 0x04, 0xfa, 0xc7, 0x3c, 0x23, 0x75, 0xfe, 0x9a, 0x87, 0x12, 0xb9, 0x84, 0xed, 0x60, 0x04,
 | 
						|
	0xc2, 0xb9, 0x09, 0x66, 0xa1, 0xcd, 0x6c, 0x04, 0x80, 0x62, 0x9d, 0x04, 0x00, 0xe3, 0xbe, 0x81,
 | 
						|
	0xde, 0x98, 0x0a, 0x4f, 0x4b, 0x65, 0xd3, 0x2d, 0x99, 0xa3, 0xe9, 0x23, 0xcc, 0x08, 0x73, 0x1a,
 | 
						|
	0x1a, 0xb3, 0x5b, 0x50, 0x96, 0x14, 0x46, 0x3a, 0xd0, 0x5b, 0x82, 0x6b, 0x29, 0xa8, 0x5c, 0x09,
 | 
						|
	0x77, 0x24, 0x83, 0xe9, 0x82, 0x8e, 0x59, 0xe5, 0xc9, 0x9c, 0xdd, 0x82, 0x1a, 0xc5, 0xed, 0xd1,
 | 
						|
	0x22, 0x14, 0xcd, 0x32, 0xc5, 0x61, 0x2d, 0x89, 0x29, 0x82, 0x3c, 0x95, 0xe3, 0x45, 0xf5, 0x5c,
 | 
						|
	0xef, 0x54, 0x0c, 0x42, 0xdd, 0xbc, 0x9a, 0xfa, 0xab, 0x63, 0x31, 0x9e, 0x48, 0x51, 0x6d, 0x24,
 | 
						|
	0x3c, 0x25, 0x34, 0x52, 0x3f, 0x26, 0xea, 0x9a, 0x0d, 0xaf, 0x01, 0x79, 0x2a, 0x67, 0x0e, 0x94,
 | 
						|
	0x87, 0xc3, 0x43, 0x64, 0x7e, 0x92, 0x16, 0x12, 0x83, 0x70, 0x2b, 0x71, 0xfa, 0x50, 0x8d, 0xb7,
 | 
						|
	0xc1, 0x5b, 0xd9, 0xef, 0xda, 0xfb, 0x9a, 0xef, 0x77, 0xd9, 0x1d, 0xa8, 0x44, 0xa7, 0xae, 0xf2,
 | 
						|
	0x83, 0x09, 0xf9, 0x6e, 0x7d, 0xff, 0xa3, 0xc4, 0xaa, 0xa1, 0xc1, 0x51, 0x53, 0xcc, 0x71, 0x24,
 | 
						|
	0xd4, 0x12, 0x33, 0xde, 0xd0, 0xd5, 0x80, 0xc2, 0xdc, 0x1f, 0x91, 0x9e, 0x35, 0x8e, 0x43, 0x44,
 | 
						|
	0x26, 0xbe, 0xc9, 0xa5, 0x35, 0x8e, 0x43, 0x0c, 0xc8, 0x4c, 0x8e, 0x4c, 0xd9, 0x5b, 0xe3, 0x34,
 | 
						|
	0x46, 0x1f, 0xcb, 0x50, 0xfb, 0x32, 0x70, 0xa7, 0xb1, 0x8f, 0xe3, 0xb9, 0x33, 0x8d, 0xcf, 0xf7,
 | 
						|
	0x3f, 0xd9, 0xed, 0x37, 0x39, 0xa8, 0xc6, 0xb5, 0x1a, 0x0b, 0x8f, 0x3f, 0x12, 0x81, 0xf6, 0xc7,
 | 
						|
	0xbe, 0x50, 0x76, 0xe3, 0x0c, 0xc2, 0xee, 0x40, 0xc9, 0xd5, 0x5a, 0xc5, 0xd7, 0xf9, 0xff, 0xb3,
 | 
						|
	0x85, 0xbe, 0x75, 0x80, 0x92, 0x5e, 0xa0, 0xd5, 0x82, 0x1b, 0xd6, 0xc6, 0x57, 0x00, 0x29, 0x88,
 | 
						|
	0xb6, 0x9e, 0x89, 0x85, 0xd5, 0x8a, 0x43, 0x76, 0x15, 0x4a, 0xcf, 0xdd, 0xe9, 0x5c, 0xd8, 0x1c,
 | 
						|
	0x36, 0x93, 0xaf, 0xf3, 0x5f, 0xe5, 0x9c, 0xbf, 0xe4, 0xa1, 0x62, 0x0b, 0x3f, 0xbb, 0x0d, 0x15,
 | 
						|
	0x2a, 0xfc, 0xd6, 0xa2, 0xcb, 0x2f, 0x46, 0x4c, 0x61, 0x7b, 0xc9, 0x17, 0x2d, 0x63, 0xa3, 0x55,
 | 
						|
	0x65, 0xbe, 0x6c, 0xd6, 0xc6, 0xf4, 0xfb, 0x56, 0x18, 0x89, 0xb1, 0xfd, 0x74, 0xad, 0x23, 0xbb,
 | 
						|
	0x2b, 0xc6, 0x7e, 0xe0, 0xa3, 0x7f, 0x38, 0x8a, 0xd8, 0xed, 0xf8, 0xd4, 0x45, 0xd2, 0xf8, 0x49,
 | 
						|
	0x56, 0xe3, 0x9b, 0x87, 0xee, 0x43, 0x3d, 0xb3, 0xcd, 0x25, 0xa7, 0xbe, 0x91, 0x3d, 0xb5, 0xdd,
 | 
						|
	0x92, 0xd4, 0x99, 0xef, 0x6e, 0xea, 0x85, 0xff, 0xc0, 0x7f, 0x5f, 0x02, 0xa4, 0x2a, 0xdf, 0xbf,
 | 
						|
	0xb0, 0x38, 0x2f, 0x0b, 0x00, 0x83, 0x10, 0x4b, 0xe7, 0xc8, 0xa5, 0xfa, 0xbd, 0xea, 0x4f, 0x02,
 | 
						|
	0xa9, 0xc4, 0x33, 0xba, 0xaa, 0xb4, 0xbe, 0xca, 0xeb, 0x06, 0xa3, 0x1b, 0xc3, 0x0e, 0xa0, 0x3e,
 | 
						|
	0x12, 0x91, 0xa7, 0x7c, 0x4a, 0x28, 0xeb, 0xf4, 0x2d, 0x3c, 0x53, 0xaa, 0xa7, 0xd5, 0x4d, 0x19,
 | 
						|
	0xc6, 0x57, 0xd9, 0x35, 0x6c, 0x1f, 0x56, 0xc5, 0x79, 0x28, 0x95, 0xb6, 0xbb, 0x98, 0xfe, 0xe0,
 | 
						|
	0x8a, 0xe9, 0x34, 0x10, 0xa7, 0x9d, 0x78, 0x5d, 0xa4, 0x13, 0xe6, 0x42, 0xd1, 0x73, 0x43, 0xf3,
 | 
						|
	0x71, 0xac, 0xef, 0x37, 0x2f, 0xec, 0xd7, 0x71, 0x43, 0xe3, 0xb4, 0xf6, 0x17, 0x78, 0xd6, 0x97,
 | 
						|
	0xff, 0xd8, 0xba, 0x95, 0xf9, 0x22, 0xce, 0xe4, 0xc9, 0x62, 0x8f, 0xf2, 0xe5, 0xcc, 0xd7, 0x7b,
 | 
						|
	0x73, 0xed, 0x4f, 0xf7, 0xdc, 0xd0, 0x47, 0x75, 0xb8, 0xb0, 0xdf, 0xe5, 0xa4, 0x7a, 0xe3, 0x17,
 | 
						|
	0xd0, 0xb8, 0x68, 0xf7, 0x87, 0xc4, 0x60, 0xe3, 0x2e, 0xd4, 0x12, 0x3b, 0xde, 0xb5, 0xb0, 0x9a,
 | 
						|
	0x0d, 0xde, 0x9f, 0x73, 0x50, 0x36, 0xb7, 0x8a, 0xdd, 0x85, 0xda, 0x54, 0x7a, 0x2e, 0x1a, 0x10,
 | 
						|
	0xb7, 0x68, 0x9f, 0xa6, 0x97, 0xae, 0xf5, 0x20, 0x96, 0x19, 0xaf, 0xa6, 0x5c, 0x4c, 0x32, 0x3f,
 | 
						|
	0x18, 0xcb, 0xf8, 0x16, 0xac, 0xa7, 0x8b, 0xfa, 0xc1, 0x58, 0x72, 0x23, 0xdc, 0xb8, 0x0f, 0xeb,
 | 
						|
	0xcb, 0x2a, 0x2e, 0xb1, 0xf3, 0xfa, 0x72, 0xba, 0x52, 0x5d, 0x4e, 0x16, 0x65, 0xcd, 0xbe, 0x0b,
 | 
						|
	0xb5, 0x04, 0x67, 0xbb, 0x6f, 0x1a, 0xbe, 0x9a, 0x5d, 0x99, 0xb1, 0xd5, 0x99, 0x02, 0xa4, 0xa6,
 | 
						|
	0x61, 0xb1, 0xc2, 0x5e, 0x30, 0x70, 0x67, 0x71, 0x93, 0x95, 0xcc, 0xe9, 0xdb, 0xe6, 0x6a, 0x97,
 | 
						|
	0x4c, 0x59, 0xe5, 0x34, 0x66, 0x2d, 0x80, 0x51, 0x72, 0x61, 0xdf, 0x72, 0x8d, 0x33, 0x0c, 0x67,
 | 
						|
	0x00, 0xd5, 0xd8, 0x08, 0xb6, 0x0d, 0xf5, 0xc8, 0xee, 0x8c, 0x9d, 0x0f, 0x6e, 0x57, 0xe2, 0x59,
 | 
						|
	0x08, 0x3b, 0x18, 0xe5, 0x06, 0x13, 0xb1, 0xd4, 0xc1, 0x70, 0x44, 0xb8, 0x15, 0x38, 0x4f, 0xa1,
 | 
						|
	0x44, 0x00, 0x5e, 0xb3, 0x48, 0xbb, 0x4a, 0xdb, 0x66, 0xc8, 0x34, 0x07, 0x32, 0xa2, 0x6d, 0xdb,
 | 
						|
	0x45, 0x4c, 0x44, 0x6e, 0x08, 0xec, 0x06, 0xb6, 0x20, 0x23, 0xeb, 0xd1, 0xcb, 0x78, 0x28, 0x76,
 | 
						|
	0x7e, 0x0e, 0xd5, 0x18, 0xc6, 0x93, 0x3f, 0xf0, 0x03, 0x61, 0x4d, 0xa4, 0x31, 0x36, 0x91, 0x9d,
 | 
						|
	0x53, 0x57, 0xb9, 0x9e, 0x16, 0xa6, 0x0d, 0x28, 0xf1, 0x14, 0x70, 0xae, 0x43, 0x3d, 0x73, 0x7b,
 | 
						|
	0x30, 0xdd, 0x9e, 0x50, 0x18, 0xcd, 0x1d, 0x36, 0x13, 0xe7, 0x25, 0xb6, 0xb8, 0x71, 0xd7, 0xf2,
 | 
						|
	0x53, 0x80, 0x53, 0xad, 0xc3, 0x67, 0xd4, 0xc6, 0x58, 0xdf, 0xd7, 0x10, 0x21, 0x06, 0xdb, 0x82,
 | 
						|
	0x3a, 0x4e, 0x22, 0x2b, 0x37, 0xf9, 0x4e, 0x2b, 0x22, 0x43, 0xf8, 0x09, 0xd4, 0xc6, 0xc9, 0xf2,
 | 
						|
	0x82, 0x0d, 0x5d, 0xbc, 0xfa, 0x53, 0xa8, 0x06, 0xd2, 0xca, 0x4c, 0x57, 0x55, 0x09, 0x24, 0x89,
 | 
						|
	0x9c, 0x5b, 0xf0, 0x7f, 0x6f, 0xf4, 0xe3, 0xec, 0x13, 0x28, 0x8f, 0xfd, 0xa9, 0xa6, 0xa2, 0x8f,
 | 
						|
	0x8d, 0x9a, 0x9d, 0x39, 0xff, 0xca, 0x01, 0xa4, 0x91, 0xc5, 0x7c, 0xc5, 0xea, 0x8d, 0x9c, 0x55,
 | 
						|
	0x53, 0xad, 0xa7, 0x50, 0x9d, 0xd9, 0x3a, 0x60, 0x63, 0x76, 0x6d, 0x39, 0x1b, 0x5a, 0x71, 0x99,
 | 
						|
	0x30, 0x15, 0x62, 0xdf, 0x56, 0x88, 0x0f, 0xe9, 0x99, 0x93, 0x1d, 0xa8, 0x19, 0xc9, 0xbe, 0x7d,
 | 
						|
	0x20, 0xbd, 0x68, 0xdc, 0x4a, 0x36, 0xee, 0xc3, 0xda, 0xd2, 0x96, 0xef, 0xf9, 0x4d, 0x48, 0xeb,
 | 
						|
	0x59, 0xf6, 0x96, 0xdd, 0x86, 0xb2, 0x69, 0x22, 0x31, 0x25, 0x70, 0x64, 0xd5, 0xd0, 0x98, 0x3a,
 | 
						|
	0x86, 0xe3, 0xf8, 0x05, 0xd2, 0x3f, 0x76, 0xf6, 0xa1, 0x6c, 0x9e, 0x58, 0x6c, 0x07, 0x2a, 0xae,
 | 
						|
	0x67, 0xae, 0x63, 0xa6, 0x24, 0xa0, 0xf0, 0x80, 0x60, 0x1e, 0x8b, 0x9d, 0xbf, 0xe5, 0x01, 0x52,
 | 
						|
	0xfc, 0x03, 0xba, 0xd2, 0xaf, 0x61, 0x3d, 0x12, 0x9e, 0x0c, 0x46, 0xae, 0x5a, 0x90, 0xd4, 0x3e,
 | 
						|
	0x25, 0x2e, 0x5b, 0x72, 0x81, 0x99, 0xe9, 0x50, 0x0b, 0xef, 0xee, 0x50, 0x77, 0xa0, 0xe8, 0xc9,
 | 
						|
	0x70, 0x61, 0x3f, 0x14, 0x6c, 0xf9, 0x20, 0x1d, 0x19, 0x2e, 0xf0, 0x41, 0x89, 0x0c, 0xd6, 0x82,
 | 
						|
	0xf2, 0xec, 0x8c, 0x1e, 0x9d, 0xa6, 0x61, 0xbf, 0xba, 0xcc, 0x7d, 0x78, 0x86, 0x63, 0x7c, 0xa2,
 | 
						|
	0x1a, 0x16, 0xbb, 0x05, 0xa5, 0xd9, 0xd9, 0xc8, 0x57, 0xd4, 0xdb, 0xd6, 0x4d, 0x67, 0x98, 0xa5,
 | 
						|
	0x77, 0x7d, 0x85, 0x0f, 0x51, 0xe2, 0x30, 0x07, 0xf2, 0x6a, 0xd6, 0xac, 0x10, 0xb3, 0x71, 0xc1,
 | 
						|
	0x9b, 0xb3, 0xc3, 0x15, 0x9e, 0x57, 0xb3, 0x76, 0x15, 0xca, 0xc6, 0xaf, 0xce, 0x1f, 0x0b, 0xb0,
 | 
						|
	0xbe, 0x6c, 0x25, 0xe6, 0x41, 0xa4, 0xbc, 0x38, 0x0f, 0x22, 0xe5, 0x25, 0xcd, 0x7b, 0x3e, 0xd3,
 | 
						|
	0xbc, 0x3b, 0x50, 0x92, 0x2f, 0x02, 0xa1, 0xb2, 0xaf, 0xeb, 0xce, 0xa9, 0x7c, 0x11, 0x60, 0x9b,
 | 
						|
	0x6a, 0x44, 0x4b, 0x5d, 0x5f, 0xc9, 0x76, 0x7d, 0x37, 0x60, 0x6d, 0x2c, 0xa7, 0x53, 0xf9, 0x62,
 | 
						|
	0xb8, 0x98, 0x4d, 0xfd, 0xe0, 0xcc, 0xb6, 0x7e, 0xcb, 0x20, 0xdb, 0x81, 0x2b, 0x23, 0x5f, 0xa1,
 | 
						|
	0x39, 0x1d, 0x19, 0x68, 0x11, 0xd0, 0x7b, 0x05, 0x79, 0x17, 0x61, 0xf6, 0x0d, 0x6c, 0xbb, 0x5a,
 | 
						|
	0x8b, 0x59, 0xa8, 0x1f, 0x07, 0xa1, 0xeb, 0x9d, 0x75, 0xa5, 0x47, 0x77, 0x76, 0x16, 0xba, 0xda,
 | 
						|
	0x3f, 0xf1, 0xa7, 0xf8, 0x34, 0xab, 0xd0, 0xd2, 0x77, 0xf2, 0xd8, 0xe7, 0xb0, 0xee, 0x29, 0xe1,
 | 
						|
	0x6a, 0xd1, 0x15, 0x91, 0x3e, 0x76, 0xf5, 0x69, 0xb3, 0x4a, 0x2b, 0x2f, 0xa0, 0x78, 0x06, 0x17,
 | 
						|
	0xad, 0x7d, 0xea, 0x4f, 0x47, 0x9e, 0xab, 0x46, 0xcd, 0x9a, 0x39, 0xc3, 0x12, 0xc8, 0x5a, 0xc0,
 | 
						|
	0x08, 0xe8, 0xcd, 0x42, 0xbd, 0x48, 0xa8, 0x40, 0xd4, 0x4b, 0x24, 0x58, 0x38, 0xb5, 0x3f, 0x13,
 | 
						|
	0x91, 0x76, 0x67, 0x21, 0xfd, 0x2b, 0x50, 0xe0, 0x29, 0xe0, 0x7c, 0x9b, 0x83, 0xc6, 0xc5, 0x14,
 | 
						|
	0x41, 0x07, 0x87, 0x68, 0xa6, 0xbd, 0x6c, 0x38, 0x4e, 0x9c, 0x9e, 0xcf, 0x38, 0x3d, 0xfe, 0x42,
 | 
						|
	0x15, 0x32, 0x5f, 0xa8, 0x24, 0x80, 0xc5, 0xb7, 0x07, 0x70, 0xc9, 0xa4, 0xd2, 0x45, 0x93, 0x7e,
 | 
						|
	0x97, 0x83, 0x2b, 0x17, 0xd2, 0xf0, 0xbd, 0x2d, 0xda, 0x86, 0xfa, 0xcc, 0x3d, 0x13, 0xc7, 0xae,
 | 
						|
	0xa2, 0xe0, 0x16, 0x4c, 0x0b, 0x97, 0x81, 0xfe, 0x0b, 0xf6, 0x05, 0xb0, 0x9a, 0xcd, 0xfd, 0x4b,
 | 
						|
	0x6d, 0x8b, 0x43, 0x79, 0x24, 0xf5, 0x3d, 0x39, 0xb7, 0x5f, 0xbf, 0x38, 0x94, 0x31, 0xf8, 0x66,
 | 
						|
	0xc0, 0x0b, 0x97, 0x04, 0xdc, 0x39, 0x82, 0x6a, 0x6c, 0x20, 0xdb, 0xb2, 0x4f, 0xf5, 0x5c, 0xfa,
 | 
						|
	0x97, 0xd1, 0xe3, 0x48, 0x28, 0xb4, 0xdd, 0xbc, 0xdb, 0x3f, 0x83, 0xd2, 0x44, 0xc9, 0x79, 0x68,
 | 
						|
	0x6b, 0xeb, 0x12, 0xc3, 0x48, 0x9c, 0x21, 0x54, 0x2c, 0xc2, 0x76, 0xa1, 0x7c, 0xb2, 0x38, 0x8a,
 | 
						|
	0x9b, 0x0f, 0x7b, 0xb1, 0x71, 0x3e, 0xb2, 0x0c, 0xac, 0x16, 0x86, 0xc1, 0xae, 0x42, 0xf1, 0x64,
 | 
						|
	0xd1, 0xef, 0x9a, 0x07, 0x19, 0xd6, 0x1c, 0x9c, 0xb5, 0xcb, 0xc6, 0x20, 0xe7, 0x01, 0xac, 0x66,
 | 
						|
	0xd7, 0xa1, 0x53, 0x32, 0x4d, 0x0d, 0x8d, 0xd3, 0xe2, 0x9a, 0x7f, 0x47, 0x71, 0xdd, 0xdd, 0x81,
 | 
						|
	0x8a, 0xfd, 0x53, 0x84, 0xd5, 0xa0, 0xf4, 0xf8, 0x68, 0xd8, 0x7b, 0xd4, 0x58, 0x61, 0x55, 0x28,
 | 
						|
	0x1e, 0x0e, 0x86, 0x8f, 0x1a, 0x39, 0x1c, 0x1d, 0x0d, 0x8e, 0x7a, 0x8d, 0xfc, 0xee, 0x4d, 0x58,
 | 
						|
	0xcd, 0xfe, 0x2d, 0xc2, 0xea, 0x50, 0x19, 0x1e, 0x1c, 0x75, 0xdb, 0x83, 0x5f, 0x35, 0x56, 0xd8,
 | 
						|
	0x2a, 0x54, 0xfb, 0x47, 0xc3, 0x5e, 0xe7, 0x31, 0xef, 0x35, 0x72, 0xbb, 0xbf, 0x84, 0x5a, 0xf2,
 | 
						|
	0x72, 0x47, 0x0d, 0xed, 0xfe, 0x51, 0xb7, 0xb1, 0xc2, 0x00, 0xca, 0xc3, 0x5e, 0x87, 0xf7, 0x50,
 | 
						|
	0x6f, 0x05, 0x0a, 0xc3, 0xe1, 0x61, 0x23, 0x8f, 0xbb, 0x76, 0x0e, 0x3a, 0x87, 0xbd, 0x46, 0x01,
 | 
						|
	0x87, 0x8f, 0x1e, 0x1e, 0xdf, 0x1b, 0x36, 0x8a, 0xbb, 0x5f, 0xc2, 0x95, 0x0b, 0x2f, 0x67, 0x5a,
 | 
						|
	0x7d, 0x78, 0xc0, 0x7b, 0xa8, 0xa9, 0x0e, 0x95, 0x63, 0xde, 0x7f, 0x72, 0xf0, 0xa8, 0xd7, 0xc8,
 | 
						|
	0xa1, 0xe0, 0xc1, 0xa0, 0x73, 0xbf, 0xd7, 0x6d, 0xe4, 0xdb, 0xd7, 0xbe, 0x7b, 0xb5, 0x99, 0xfb,
 | 
						|
	0xfe, 0xd5, 0x66, 0xee, 0x87, 0x57, 0x9b, 0xb9, 0x7f, 0xbe, 0xda, 0xcc, 0x7d, 0xfb, 0x7a, 0x73,
 | 
						|
	0xe5, 0xfb, 0xd7, 0x9b, 0x2b, 0x3f, 0xbc, 0xde, 0x5c, 0x39, 0x29, 0xd3, 0x9f, 0x94, 0x5f, 0xfc,
 | 
						|
	0x3b, 0x00, 0x00, 0xff, 0xff, 0x7e, 0x60, 0x46, 0x7d, 0xe4, 0x14, 0x00, 0x00,
 | 
						|
}
 | 
						|
 | 
						|
func (m *Op) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Op) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *Op) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Constraints != nil {
 | 
						|
		{
 | 
						|
			size, err := m.Constraints.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x5a
 | 
						|
	}
 | 
						|
	if m.Platform != nil {
 | 
						|
		{
 | 
						|
			size, err := m.Platform.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x52
 | 
						|
	}
 | 
						|
	if m.Op != nil {
 | 
						|
		{
 | 
						|
			size := m.Op.Size()
 | 
						|
			i -= size
 | 
						|
			if _, err := m.Op.MarshalTo(dAtA[i:]); err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if len(m.Inputs) > 0 {
 | 
						|
		for iNdEx := len(m.Inputs) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			{
 | 
						|
				size, err := m.Inputs[iNdEx].MarshalToSizedBuffer(dAtA[:i])
 | 
						|
				if err != nil {
 | 
						|
					return 0, err
 | 
						|
				}
 | 
						|
				i -= size
 | 
						|
				i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
			}
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0xa
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Op_Exec) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *Op_Exec) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	if m.Exec != nil {
 | 
						|
		{
 | 
						|
			size, err := m.Exec.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x12
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
func (m *Op_Source) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *Op_Source) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	if m.Source != nil {
 | 
						|
		{
 | 
						|
			size, err := m.Source.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x1a
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
func (m *Op_File) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *Op_File) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	if m.File != nil {
 | 
						|
		{
 | 
						|
			size, err := m.File.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x22
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
func (m *Op_Build) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *Op_Build) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	if m.Build != nil {
 | 
						|
		{
 | 
						|
			size, err := m.Build.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x2a
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
func (m *Platform) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Platform) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *Platform) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.OSFeatures) > 0 {
 | 
						|
		for iNdEx := len(m.OSFeatures) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			i -= len(m.OSFeatures[iNdEx])
 | 
						|
			copy(dAtA[i:], m.OSFeatures[iNdEx])
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(len(m.OSFeatures[iNdEx])))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x2a
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if len(m.OSVersion) > 0 {
 | 
						|
		i -= len(m.OSVersion)
 | 
						|
		copy(dAtA[i:], m.OSVersion)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.OSVersion)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x22
 | 
						|
	}
 | 
						|
	if len(m.Variant) > 0 {
 | 
						|
		i -= len(m.Variant)
 | 
						|
		copy(dAtA[i:], m.Variant)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.Variant)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x1a
 | 
						|
	}
 | 
						|
	if len(m.OS) > 0 {
 | 
						|
		i -= len(m.OS)
 | 
						|
		copy(dAtA[i:], m.OS)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.OS)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x12
 | 
						|
	}
 | 
						|
	if len(m.Architecture) > 0 {
 | 
						|
		i -= len(m.Architecture)
 | 
						|
		copy(dAtA[i:], m.Architecture)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.Architecture)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Input) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Input) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *Input) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Index != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Index))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x10
 | 
						|
	}
 | 
						|
	if len(m.Digest) > 0 {
 | 
						|
		i -= len(m.Digest)
 | 
						|
		copy(dAtA[i:], m.Digest)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.Digest)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *ExecOp) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *ExecOp) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *ExecOp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Security != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Security))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x20
 | 
						|
	}
 | 
						|
	if m.Network != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Network))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x18
 | 
						|
	}
 | 
						|
	if len(m.Mounts) > 0 {
 | 
						|
		for iNdEx := len(m.Mounts) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			{
 | 
						|
				size, err := m.Mounts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
 | 
						|
				if err != nil {
 | 
						|
					return 0, err
 | 
						|
				}
 | 
						|
				i -= size
 | 
						|
				i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
			}
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x12
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if m.Meta != nil {
 | 
						|
		{
 | 
						|
			size, err := m.Meta.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Meta) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Meta) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *Meta) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.ExtraHosts) > 0 {
 | 
						|
		for iNdEx := len(m.ExtraHosts) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			{
 | 
						|
				size, err := m.ExtraHosts[iNdEx].MarshalToSizedBuffer(dAtA[:i])
 | 
						|
				if err != nil {
 | 
						|
					return 0, err
 | 
						|
				}
 | 
						|
				i -= size
 | 
						|
				i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
			}
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x32
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if m.ProxyEnv != nil {
 | 
						|
		{
 | 
						|
			size, err := m.ProxyEnv.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x2a
 | 
						|
	}
 | 
						|
	if len(m.User) > 0 {
 | 
						|
		i -= len(m.User)
 | 
						|
		copy(dAtA[i:], m.User)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.User)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x22
 | 
						|
	}
 | 
						|
	if len(m.Cwd) > 0 {
 | 
						|
		i -= len(m.Cwd)
 | 
						|
		copy(dAtA[i:], m.Cwd)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.Cwd)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x1a
 | 
						|
	}
 | 
						|
	if len(m.Env) > 0 {
 | 
						|
		for iNdEx := len(m.Env) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			i -= len(m.Env[iNdEx])
 | 
						|
			copy(dAtA[i:], m.Env[iNdEx])
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(len(m.Env[iNdEx])))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x12
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if len(m.Args) > 0 {
 | 
						|
		for iNdEx := len(m.Args) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			i -= len(m.Args[iNdEx])
 | 
						|
			copy(dAtA[i:], m.Args[iNdEx])
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(len(m.Args[iNdEx])))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0xa
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Mount) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Mount) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *Mount) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.SSHOpt != nil {
 | 
						|
		{
 | 
						|
			size, err := m.SSHOpt.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x1
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xb2
 | 
						|
	}
 | 
						|
	if m.SecretOpt != nil {
 | 
						|
		{
 | 
						|
			size, err := m.SecretOpt.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x1
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xaa
 | 
						|
	}
 | 
						|
	if m.CacheOpt != nil {
 | 
						|
		{
 | 
						|
			size, err := m.CacheOpt.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x1
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa2
 | 
						|
	}
 | 
						|
	if m.MountType != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.MountType))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x30
 | 
						|
	}
 | 
						|
	if m.Readonly {
 | 
						|
		i--
 | 
						|
		if m.Readonly {
 | 
						|
			dAtA[i] = 1
 | 
						|
		} else {
 | 
						|
			dAtA[i] = 0
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x28
 | 
						|
	}
 | 
						|
	if m.Output != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Output))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x20
 | 
						|
	}
 | 
						|
	if len(m.Dest) > 0 {
 | 
						|
		i -= len(m.Dest)
 | 
						|
		copy(dAtA[i:], m.Dest)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.Dest)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x1a
 | 
						|
	}
 | 
						|
	if len(m.Selector) > 0 {
 | 
						|
		i -= len(m.Selector)
 | 
						|
		copy(dAtA[i:], m.Selector)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.Selector)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x12
 | 
						|
	}
 | 
						|
	if m.Input != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Input))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x8
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *CacheOpt) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *CacheOpt) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *CacheOpt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Sharing != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Sharing))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x10
 | 
						|
	}
 | 
						|
	if len(m.ID) > 0 {
 | 
						|
		i -= len(m.ID)
 | 
						|
		copy(dAtA[i:], m.ID)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.ID)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *SecretOpt) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *SecretOpt) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *SecretOpt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Optional {
 | 
						|
		i--
 | 
						|
		if m.Optional {
 | 
						|
			dAtA[i] = 1
 | 
						|
		} else {
 | 
						|
			dAtA[i] = 0
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x28
 | 
						|
	}
 | 
						|
	if m.Mode != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Mode))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x20
 | 
						|
	}
 | 
						|
	if m.Gid != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Gid))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x18
 | 
						|
	}
 | 
						|
	if m.Uid != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Uid))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x10
 | 
						|
	}
 | 
						|
	if len(m.ID) > 0 {
 | 
						|
		i -= len(m.ID)
 | 
						|
		copy(dAtA[i:], m.ID)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.ID)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *SSHOpt) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *SSHOpt) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *SSHOpt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Optional {
 | 
						|
		i--
 | 
						|
		if m.Optional {
 | 
						|
			dAtA[i] = 1
 | 
						|
		} else {
 | 
						|
			dAtA[i] = 0
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x28
 | 
						|
	}
 | 
						|
	if m.Mode != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Mode))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x20
 | 
						|
	}
 | 
						|
	if m.Gid != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Gid))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x18
 | 
						|
	}
 | 
						|
	if m.Uid != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Uid))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x10
 | 
						|
	}
 | 
						|
	if len(m.ID) > 0 {
 | 
						|
		i -= len(m.ID)
 | 
						|
		copy(dAtA[i:], m.ID)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.ID)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *SourceOp) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *SourceOp) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *SourceOp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.Attrs) > 0 {
 | 
						|
		keysForAttrs := make([]string, 0, len(m.Attrs))
 | 
						|
		for k := range m.Attrs {
 | 
						|
			keysForAttrs = append(keysForAttrs, string(k))
 | 
						|
		}
 | 
						|
		github_com_gogo_protobuf_sortkeys.Strings(keysForAttrs)
 | 
						|
		for iNdEx := len(keysForAttrs) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			v := m.Attrs[string(keysForAttrs[iNdEx])]
 | 
						|
			baseI := i
 | 
						|
			i -= len(v)
 | 
						|
			copy(dAtA[i:], v)
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(len(v)))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x12
 | 
						|
			i -= len(keysForAttrs[iNdEx])
 | 
						|
			copy(dAtA[i:], keysForAttrs[iNdEx])
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(len(keysForAttrs[iNdEx])))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0xa
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(baseI-i))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x12
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if len(m.Identifier) > 0 {
 | 
						|
		i -= len(m.Identifier)
 | 
						|
		copy(dAtA[i:], m.Identifier)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.Identifier)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *BuildOp) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *BuildOp) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *BuildOp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.Attrs) > 0 {
 | 
						|
		keysForAttrs := make([]string, 0, len(m.Attrs))
 | 
						|
		for k := range m.Attrs {
 | 
						|
			keysForAttrs = append(keysForAttrs, string(k))
 | 
						|
		}
 | 
						|
		github_com_gogo_protobuf_sortkeys.Strings(keysForAttrs)
 | 
						|
		for iNdEx := len(keysForAttrs) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			v := m.Attrs[string(keysForAttrs[iNdEx])]
 | 
						|
			baseI := i
 | 
						|
			i -= len(v)
 | 
						|
			copy(dAtA[i:], v)
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(len(v)))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x12
 | 
						|
			i -= len(keysForAttrs[iNdEx])
 | 
						|
			copy(dAtA[i:], keysForAttrs[iNdEx])
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(len(keysForAttrs[iNdEx])))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0xa
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(baseI-i))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x22
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if m.Def != nil {
 | 
						|
		{
 | 
						|
			size, err := m.Def.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x1a
 | 
						|
	}
 | 
						|
	if len(m.Inputs) > 0 {
 | 
						|
		keysForInputs := make([]string, 0, len(m.Inputs))
 | 
						|
		for k := range m.Inputs {
 | 
						|
			keysForInputs = append(keysForInputs, string(k))
 | 
						|
		}
 | 
						|
		github_com_gogo_protobuf_sortkeys.Strings(keysForInputs)
 | 
						|
		for iNdEx := len(keysForInputs) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			v := m.Inputs[string(keysForInputs[iNdEx])]
 | 
						|
			baseI := i
 | 
						|
			if v != nil {
 | 
						|
				{
 | 
						|
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
					if err != nil {
 | 
						|
						return 0, err
 | 
						|
					}
 | 
						|
					i -= size
 | 
						|
					i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
				}
 | 
						|
				i--
 | 
						|
				dAtA[i] = 0x12
 | 
						|
			}
 | 
						|
			i -= len(keysForInputs[iNdEx])
 | 
						|
			copy(dAtA[i:], keysForInputs[iNdEx])
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(len(keysForInputs[iNdEx])))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0xa
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(baseI-i))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x12
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if m.Builder != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Builder))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x8
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *BuildInput) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *BuildInput) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *BuildInput) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Input != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Input))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x8
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *OpMetadata) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *OpMetadata) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *OpMetadata) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.Caps) > 0 {
 | 
						|
		keysForCaps := make([]string, 0, len(m.Caps))
 | 
						|
		for k := range m.Caps {
 | 
						|
			keysForCaps = append(keysForCaps, string(k))
 | 
						|
		}
 | 
						|
		github_com_gogo_protobuf_sortkeys.Strings(keysForCaps)
 | 
						|
		for iNdEx := len(keysForCaps) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			v := m.Caps[github_com_moby_buildkit_util_apicaps.CapID(keysForCaps[iNdEx])]
 | 
						|
			baseI := i
 | 
						|
			i--
 | 
						|
			if v {
 | 
						|
				dAtA[i] = 1
 | 
						|
			} else {
 | 
						|
				dAtA[i] = 0
 | 
						|
			}
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x10
 | 
						|
			i -= len(keysForCaps[iNdEx])
 | 
						|
			copy(dAtA[i:], keysForCaps[iNdEx])
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(len(keysForCaps[iNdEx])))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0xa
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(baseI-i))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x2a
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if m.ExportCache != nil {
 | 
						|
		{
 | 
						|
			size, err := m.ExportCache.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x22
 | 
						|
	}
 | 
						|
	if len(m.Description) > 0 {
 | 
						|
		keysForDescription := make([]string, 0, len(m.Description))
 | 
						|
		for k := range m.Description {
 | 
						|
			keysForDescription = append(keysForDescription, string(k))
 | 
						|
		}
 | 
						|
		github_com_gogo_protobuf_sortkeys.Strings(keysForDescription)
 | 
						|
		for iNdEx := len(keysForDescription) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			v := m.Description[string(keysForDescription[iNdEx])]
 | 
						|
			baseI := i
 | 
						|
			i -= len(v)
 | 
						|
			copy(dAtA[i:], v)
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(len(v)))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x12
 | 
						|
			i -= len(keysForDescription[iNdEx])
 | 
						|
			copy(dAtA[i:], keysForDescription[iNdEx])
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(len(keysForDescription[iNdEx])))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0xa
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(baseI-i))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x12
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if m.IgnoreCache {
 | 
						|
		i--
 | 
						|
		if m.IgnoreCache {
 | 
						|
			dAtA[i] = 1
 | 
						|
		} else {
 | 
						|
			dAtA[i] = 0
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x8
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Source) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Source) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *Source) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.Infos) > 0 {
 | 
						|
		for iNdEx := len(m.Infos) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			{
 | 
						|
				size, err := m.Infos[iNdEx].MarshalToSizedBuffer(dAtA[:i])
 | 
						|
				if err != nil {
 | 
						|
					return 0, err
 | 
						|
				}
 | 
						|
				i -= size
 | 
						|
				i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
			}
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x12
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if len(m.Locations) > 0 {
 | 
						|
		keysForLocations := make([]string, 0, len(m.Locations))
 | 
						|
		for k := range m.Locations {
 | 
						|
			keysForLocations = append(keysForLocations, string(k))
 | 
						|
		}
 | 
						|
		github_com_gogo_protobuf_sortkeys.Strings(keysForLocations)
 | 
						|
		for iNdEx := len(keysForLocations) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			v := m.Locations[string(keysForLocations[iNdEx])]
 | 
						|
			baseI := i
 | 
						|
			if v != nil {
 | 
						|
				{
 | 
						|
					size, err := v.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
					if err != nil {
 | 
						|
						return 0, err
 | 
						|
					}
 | 
						|
					i -= size
 | 
						|
					i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
				}
 | 
						|
				i--
 | 
						|
				dAtA[i] = 0x12
 | 
						|
			}
 | 
						|
			i -= len(keysForLocations[iNdEx])
 | 
						|
			copy(dAtA[i:], keysForLocations[iNdEx])
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(len(keysForLocations[iNdEx])))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0xa
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(baseI-i))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0xa
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Locations) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Locations) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *Locations) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.Locations) > 0 {
 | 
						|
		for iNdEx := len(m.Locations) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			{
 | 
						|
				size, err := m.Locations[iNdEx].MarshalToSizedBuffer(dAtA[:i])
 | 
						|
				if err != nil {
 | 
						|
					return 0, err
 | 
						|
				}
 | 
						|
				i -= size
 | 
						|
				i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
			}
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0xa
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *SourceInfo) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *SourceInfo) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *SourceInfo) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Definition != nil {
 | 
						|
		{
 | 
						|
			size, err := m.Definition.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x1a
 | 
						|
	}
 | 
						|
	if len(m.Data) > 0 {
 | 
						|
		i -= len(m.Data)
 | 
						|
		copy(dAtA[i:], m.Data)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.Data)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x12
 | 
						|
	}
 | 
						|
	if len(m.Filename) > 0 {
 | 
						|
		i -= len(m.Filename)
 | 
						|
		copy(dAtA[i:], m.Filename)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.Filename)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Location) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Location) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *Location) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.Ranges) > 0 {
 | 
						|
		for iNdEx := len(m.Ranges) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			{
 | 
						|
				size, err := m.Ranges[iNdEx].MarshalToSizedBuffer(dAtA[:i])
 | 
						|
				if err != nil {
 | 
						|
					return 0, err
 | 
						|
				}
 | 
						|
				i -= size
 | 
						|
				i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
			}
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x12
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if m.SourceIndex != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.SourceIndex))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x8
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Range) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Range) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *Range) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	{
 | 
						|
		size, err := m.End.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
		if err != nil {
 | 
						|
			return 0, err
 | 
						|
		}
 | 
						|
		i -= size
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
	}
 | 
						|
	i--
 | 
						|
	dAtA[i] = 0x12
 | 
						|
	{
 | 
						|
		size, err := m.Start.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
		if err != nil {
 | 
						|
			return 0, err
 | 
						|
		}
 | 
						|
		i -= size
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
	}
 | 
						|
	i--
 | 
						|
	dAtA[i] = 0xa
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Position) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Position) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *Position) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Character != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Character))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x10
 | 
						|
	}
 | 
						|
	if m.Line != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Line))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x8
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *ExportCache) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *ExportCache) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *ExportCache) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Value {
 | 
						|
		i--
 | 
						|
		if m.Value {
 | 
						|
			dAtA[i] = 1
 | 
						|
		} else {
 | 
						|
			dAtA[i] = 0
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x8
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *ProxyEnv) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *ProxyEnv) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *ProxyEnv) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.NoProxy) > 0 {
 | 
						|
		i -= len(m.NoProxy)
 | 
						|
		copy(dAtA[i:], m.NoProxy)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.NoProxy)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x22
 | 
						|
	}
 | 
						|
	if len(m.FtpProxy) > 0 {
 | 
						|
		i -= len(m.FtpProxy)
 | 
						|
		copy(dAtA[i:], m.FtpProxy)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.FtpProxy)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x1a
 | 
						|
	}
 | 
						|
	if len(m.HttpsProxy) > 0 {
 | 
						|
		i -= len(m.HttpsProxy)
 | 
						|
		copy(dAtA[i:], m.HttpsProxy)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.HttpsProxy)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x12
 | 
						|
	}
 | 
						|
	if len(m.HttpProxy) > 0 {
 | 
						|
		i -= len(m.HttpProxy)
 | 
						|
		copy(dAtA[i:], m.HttpProxy)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.HttpProxy)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *WorkerConstraints) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *WorkerConstraints) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *WorkerConstraints) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.Filter) > 0 {
 | 
						|
		for iNdEx := len(m.Filter) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			i -= len(m.Filter[iNdEx])
 | 
						|
			copy(dAtA[i:], m.Filter[iNdEx])
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(len(m.Filter[iNdEx])))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0xa
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Definition) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *Definition) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *Definition) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Source != nil {
 | 
						|
		{
 | 
						|
			size, err := m.Source.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x1a
 | 
						|
	}
 | 
						|
	if len(m.Metadata) > 0 {
 | 
						|
		keysForMetadata := make([]string, 0, len(m.Metadata))
 | 
						|
		for k := range m.Metadata {
 | 
						|
			keysForMetadata = append(keysForMetadata, string(k))
 | 
						|
		}
 | 
						|
		github_com_gogo_protobuf_sortkeys.Strings(keysForMetadata)
 | 
						|
		for iNdEx := len(keysForMetadata) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			v := m.Metadata[github_com_opencontainers_go_digest.Digest(keysForMetadata[iNdEx])]
 | 
						|
			baseI := i
 | 
						|
			{
 | 
						|
				size, err := (&v).MarshalToSizedBuffer(dAtA[:i])
 | 
						|
				if err != nil {
 | 
						|
					return 0, err
 | 
						|
				}
 | 
						|
				i -= size
 | 
						|
				i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
			}
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x12
 | 
						|
			i -= len(keysForMetadata[iNdEx])
 | 
						|
			copy(dAtA[i:], keysForMetadata[iNdEx])
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(len(keysForMetadata[iNdEx])))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0xa
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(baseI-i))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x12
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if len(m.Def) > 0 {
 | 
						|
		for iNdEx := len(m.Def) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			i -= len(m.Def[iNdEx])
 | 
						|
			copy(dAtA[i:], m.Def[iNdEx])
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(len(m.Def[iNdEx])))
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0xa
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *HostIP) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *HostIP) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *HostIP) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.IP) > 0 {
 | 
						|
		i -= len(m.IP)
 | 
						|
		copy(dAtA[i:], m.IP)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.IP)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x12
 | 
						|
	}
 | 
						|
	if len(m.Host) > 0 {
 | 
						|
		i -= len(m.Host)
 | 
						|
		copy(dAtA[i:], m.Host)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.Host)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileOp) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileOp) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileOp) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.Actions) > 0 {
 | 
						|
		for iNdEx := len(m.Actions) - 1; iNdEx >= 0; iNdEx-- {
 | 
						|
			{
 | 
						|
				size, err := m.Actions[iNdEx].MarshalToSizedBuffer(dAtA[:i])
 | 
						|
				if err != nil {
 | 
						|
					return 0, err
 | 
						|
				}
 | 
						|
				i -= size
 | 
						|
				i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
			}
 | 
						|
			i--
 | 
						|
			dAtA[i] = 0x12
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileAction) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileAction) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileAction) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Action != nil {
 | 
						|
		{
 | 
						|
			size := m.Action.Size()
 | 
						|
			i -= size
 | 
						|
			if _, err := m.Action.MarshalTo(dAtA[i:]); err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if m.Output != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Output))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x18
 | 
						|
	}
 | 
						|
	if m.SecondaryInput != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.SecondaryInput))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x10
 | 
						|
	}
 | 
						|
	if m.Input != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Input))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x8
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileAction_Copy) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileAction_Copy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	if m.Copy != nil {
 | 
						|
		{
 | 
						|
			size, err := m.Copy.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x22
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
func (m *FileAction_Mkfile) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileAction_Mkfile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	if m.Mkfile != nil {
 | 
						|
		{
 | 
						|
			size, err := m.Mkfile.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x2a
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
func (m *FileAction_Mkdir) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileAction_Mkdir) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	if m.Mkdir != nil {
 | 
						|
		{
 | 
						|
			size, err := m.Mkdir.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x32
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
func (m *FileAction_Rm) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileAction_Rm) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	if m.Rm != nil {
 | 
						|
		{
 | 
						|
			size, err := m.Rm.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x3a
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
func (m *FileActionCopy) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionCopy) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionCopy) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Timestamp != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Timestamp))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x58
 | 
						|
	}
 | 
						|
	if m.AllowEmptyWildcard {
 | 
						|
		i--
 | 
						|
		if m.AllowEmptyWildcard {
 | 
						|
			dAtA[i] = 1
 | 
						|
		} else {
 | 
						|
			dAtA[i] = 0
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x50
 | 
						|
	}
 | 
						|
	if m.AllowWildcard {
 | 
						|
		i--
 | 
						|
		if m.AllowWildcard {
 | 
						|
			dAtA[i] = 1
 | 
						|
		} else {
 | 
						|
			dAtA[i] = 0
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x48
 | 
						|
	}
 | 
						|
	if m.CreateDestPath {
 | 
						|
		i--
 | 
						|
		if m.CreateDestPath {
 | 
						|
			dAtA[i] = 1
 | 
						|
		} else {
 | 
						|
			dAtA[i] = 0
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x40
 | 
						|
	}
 | 
						|
	if m.AttemptUnpackDockerCompatibility {
 | 
						|
		i--
 | 
						|
		if m.AttemptUnpackDockerCompatibility {
 | 
						|
			dAtA[i] = 1
 | 
						|
		} else {
 | 
						|
			dAtA[i] = 0
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x38
 | 
						|
	}
 | 
						|
	if m.DirCopyContents {
 | 
						|
		i--
 | 
						|
		if m.DirCopyContents {
 | 
						|
			dAtA[i] = 1
 | 
						|
		} else {
 | 
						|
			dAtA[i] = 0
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x30
 | 
						|
	}
 | 
						|
	if m.FollowSymlink {
 | 
						|
		i--
 | 
						|
		if m.FollowSymlink {
 | 
						|
			dAtA[i] = 1
 | 
						|
		} else {
 | 
						|
			dAtA[i] = 0
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x28
 | 
						|
	}
 | 
						|
	if m.Mode != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Mode))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x20
 | 
						|
	}
 | 
						|
	if m.Owner != nil {
 | 
						|
		{
 | 
						|
			size, err := m.Owner.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x1a
 | 
						|
	}
 | 
						|
	if len(m.Dest) > 0 {
 | 
						|
		i -= len(m.Dest)
 | 
						|
		copy(dAtA[i:], m.Dest)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.Dest)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x12
 | 
						|
	}
 | 
						|
	if len(m.Src) > 0 {
 | 
						|
		i -= len(m.Src)
 | 
						|
		copy(dAtA[i:], m.Src)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.Src)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkFile) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkFile) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkFile) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Timestamp != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Timestamp))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x28
 | 
						|
	}
 | 
						|
	if m.Owner != nil {
 | 
						|
		{
 | 
						|
			size, err := m.Owner.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x22
 | 
						|
	}
 | 
						|
	if len(m.Data) > 0 {
 | 
						|
		i -= len(m.Data)
 | 
						|
		copy(dAtA[i:], m.Data)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.Data)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x1a
 | 
						|
	}
 | 
						|
	if m.Mode != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Mode))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x10
 | 
						|
	}
 | 
						|
	if len(m.Path) > 0 {
 | 
						|
		i -= len(m.Path)
 | 
						|
		copy(dAtA[i:], m.Path)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.Path)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkDir) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkDir) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkDir) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Timestamp != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Timestamp))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x28
 | 
						|
	}
 | 
						|
	if m.Owner != nil {
 | 
						|
		{
 | 
						|
			size, err := m.Owner.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x22
 | 
						|
	}
 | 
						|
	if m.MakeParents {
 | 
						|
		i--
 | 
						|
		if m.MakeParents {
 | 
						|
			dAtA[i] = 1
 | 
						|
		} else {
 | 
						|
			dAtA[i] = 0
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x18
 | 
						|
	}
 | 
						|
	if m.Mode != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Mode))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x10
 | 
						|
	}
 | 
						|
	if len(m.Path) > 0 {
 | 
						|
		i -= len(m.Path)
 | 
						|
		copy(dAtA[i:], m.Path)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.Path)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionRm) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionRm) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionRm) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.AllowWildcard {
 | 
						|
		i--
 | 
						|
		if m.AllowWildcard {
 | 
						|
			dAtA[i] = 1
 | 
						|
		} else {
 | 
						|
			dAtA[i] = 0
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x18
 | 
						|
	}
 | 
						|
	if m.AllowNotFound {
 | 
						|
		i--
 | 
						|
		if m.AllowNotFound {
 | 
						|
			dAtA[i] = 1
 | 
						|
		} else {
 | 
						|
			dAtA[i] = 0
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x10
 | 
						|
	}
 | 
						|
	if len(m.Path) > 0 {
 | 
						|
		i -= len(m.Path)
 | 
						|
		copy(dAtA[i:], m.Path)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.Path)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *ChownOpt) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *ChownOpt) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *ChownOpt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Group != nil {
 | 
						|
		{
 | 
						|
			size, err := m.Group.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x12
 | 
						|
	}
 | 
						|
	if m.User != nil {
 | 
						|
		{
 | 
						|
			size, err := m.User.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *UserOpt) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *UserOpt) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *UserOpt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.User != nil {
 | 
						|
		{
 | 
						|
			size := m.User.Size()
 | 
						|
			i -= size
 | 
						|
			if _, err := m.User.MarshalTo(dAtA[i:]); err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *UserOpt_ByName) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *UserOpt_ByName) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	if m.ByName != nil {
 | 
						|
		{
 | 
						|
			size, err := m.ByName.MarshalToSizedBuffer(dAtA[:i])
 | 
						|
			if err != nil {
 | 
						|
				return 0, err
 | 
						|
			}
 | 
						|
			i -= size
 | 
						|
			i = encodeVarintOps(dAtA, i, uint64(size))
 | 
						|
		}
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
func (m *UserOpt_ByID) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *UserOpt_ByID) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	i = encodeVarintOps(dAtA, i, uint64(m.ByID))
 | 
						|
	i--
 | 
						|
	dAtA[i] = 0x10
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
func (m *NamedUserOpt) Marshal() (dAtA []byte, err error) {
 | 
						|
	size := m.Size()
 | 
						|
	dAtA = make([]byte, size)
 | 
						|
	n, err := m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
	if err != nil {
 | 
						|
		return nil, err
 | 
						|
	}
 | 
						|
	return dAtA[:n], nil
 | 
						|
}
 | 
						|
 | 
						|
func (m *NamedUserOpt) MarshalTo(dAtA []byte) (int, error) {
 | 
						|
	size := m.Size()
 | 
						|
	return m.MarshalToSizedBuffer(dAtA[:size])
 | 
						|
}
 | 
						|
 | 
						|
func (m *NamedUserOpt) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 | 
						|
	i := len(dAtA)
 | 
						|
	_ = i
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Input != 0 {
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(m.Input))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0x10
 | 
						|
	}
 | 
						|
	if len(m.Name) > 0 {
 | 
						|
		i -= len(m.Name)
 | 
						|
		copy(dAtA[i:], m.Name)
 | 
						|
		i = encodeVarintOps(dAtA, i, uint64(len(m.Name)))
 | 
						|
		i--
 | 
						|
		dAtA[i] = 0xa
 | 
						|
	}
 | 
						|
	return len(dAtA) - i, nil
 | 
						|
}
 | 
						|
 | 
						|
func encodeVarintOps(dAtA []byte, offset int, v uint64) int {
 | 
						|
	offset -= sovOps(v)
 | 
						|
	base := offset
 | 
						|
	for v >= 1<<7 {
 | 
						|
		dAtA[offset] = uint8(v&0x7f | 0x80)
 | 
						|
		v >>= 7
 | 
						|
		offset++
 | 
						|
	}
 | 
						|
	dAtA[offset] = uint8(v)
 | 
						|
	return base
 | 
						|
}
 | 
						|
func (m *Op) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.Inputs) > 0 {
 | 
						|
		for _, e := range m.Inputs {
 | 
						|
			l = e.Size()
 | 
						|
			n += 1 + l + sovOps(uint64(l))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if m.Op != nil {
 | 
						|
		n += m.Op.Size()
 | 
						|
	}
 | 
						|
	if m.Platform != nil {
 | 
						|
		l = m.Platform.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.Constraints != nil {
 | 
						|
		l = m.Constraints.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *Op_Exec) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Exec != nil {
 | 
						|
		l = m.Exec.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
func (m *Op_Source) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Source != nil {
 | 
						|
		l = m.Source.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
func (m *Op_File) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.File != nil {
 | 
						|
		l = m.File.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
func (m *Op_Build) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Build != nil {
 | 
						|
		l = m.Build.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
func (m *Platform) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	l = len(m.Architecture)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	l = len(m.OS)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	l = len(m.Variant)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	l = len(m.OSVersion)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if len(m.OSFeatures) > 0 {
 | 
						|
		for _, s := range m.OSFeatures {
 | 
						|
			l = len(s)
 | 
						|
			n += 1 + l + sovOps(uint64(l))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *Input) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	l = len(m.Digest)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.Index != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Index))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *ExecOp) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Meta != nil {
 | 
						|
		l = m.Meta.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if len(m.Mounts) > 0 {
 | 
						|
		for _, e := range m.Mounts {
 | 
						|
			l = e.Size()
 | 
						|
			n += 1 + l + sovOps(uint64(l))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if m.Network != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Network))
 | 
						|
	}
 | 
						|
	if m.Security != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Security))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *Meta) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.Args) > 0 {
 | 
						|
		for _, s := range m.Args {
 | 
						|
			l = len(s)
 | 
						|
			n += 1 + l + sovOps(uint64(l))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if len(m.Env) > 0 {
 | 
						|
		for _, s := range m.Env {
 | 
						|
			l = len(s)
 | 
						|
			n += 1 + l + sovOps(uint64(l))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	l = len(m.Cwd)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	l = len(m.User)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.ProxyEnv != nil {
 | 
						|
		l = m.ProxyEnv.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if len(m.ExtraHosts) > 0 {
 | 
						|
		for _, e := range m.ExtraHosts {
 | 
						|
			l = e.Size()
 | 
						|
			n += 1 + l + sovOps(uint64(l))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *Mount) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Input != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Input))
 | 
						|
	}
 | 
						|
	l = len(m.Selector)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	l = len(m.Dest)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.Output != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Output))
 | 
						|
	}
 | 
						|
	if m.Readonly {
 | 
						|
		n += 2
 | 
						|
	}
 | 
						|
	if m.MountType != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.MountType))
 | 
						|
	}
 | 
						|
	if m.CacheOpt != nil {
 | 
						|
		l = m.CacheOpt.Size()
 | 
						|
		n += 2 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.SecretOpt != nil {
 | 
						|
		l = m.SecretOpt.Size()
 | 
						|
		n += 2 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.SSHOpt != nil {
 | 
						|
		l = m.SSHOpt.Size()
 | 
						|
		n += 2 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *CacheOpt) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	l = len(m.ID)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.Sharing != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Sharing))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *SecretOpt) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	l = len(m.ID)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.Uid != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Uid))
 | 
						|
	}
 | 
						|
	if m.Gid != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Gid))
 | 
						|
	}
 | 
						|
	if m.Mode != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Mode))
 | 
						|
	}
 | 
						|
	if m.Optional {
 | 
						|
		n += 2
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *SSHOpt) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	l = len(m.ID)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.Uid != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Uid))
 | 
						|
	}
 | 
						|
	if m.Gid != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Gid))
 | 
						|
	}
 | 
						|
	if m.Mode != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Mode))
 | 
						|
	}
 | 
						|
	if m.Optional {
 | 
						|
		n += 2
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *SourceOp) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	l = len(m.Identifier)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if len(m.Attrs) > 0 {
 | 
						|
		for k, v := range m.Attrs {
 | 
						|
			_ = k
 | 
						|
			_ = v
 | 
						|
			mapEntrySize := 1 + len(k) + sovOps(uint64(len(k))) + 1 + len(v) + sovOps(uint64(len(v)))
 | 
						|
			n += mapEntrySize + 1 + sovOps(uint64(mapEntrySize))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *BuildOp) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Builder != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Builder))
 | 
						|
	}
 | 
						|
	if len(m.Inputs) > 0 {
 | 
						|
		for k, v := range m.Inputs {
 | 
						|
			_ = k
 | 
						|
			_ = v
 | 
						|
			l = 0
 | 
						|
			if v != nil {
 | 
						|
				l = v.Size()
 | 
						|
				l += 1 + sovOps(uint64(l))
 | 
						|
			}
 | 
						|
			mapEntrySize := 1 + len(k) + sovOps(uint64(len(k))) + l
 | 
						|
			n += mapEntrySize + 1 + sovOps(uint64(mapEntrySize))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if m.Def != nil {
 | 
						|
		l = m.Def.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if len(m.Attrs) > 0 {
 | 
						|
		for k, v := range m.Attrs {
 | 
						|
			_ = k
 | 
						|
			_ = v
 | 
						|
			mapEntrySize := 1 + len(k) + sovOps(uint64(len(k))) + 1 + len(v) + sovOps(uint64(len(v)))
 | 
						|
			n += mapEntrySize + 1 + sovOps(uint64(mapEntrySize))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *BuildInput) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Input != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Input))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *OpMetadata) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.IgnoreCache {
 | 
						|
		n += 2
 | 
						|
	}
 | 
						|
	if len(m.Description) > 0 {
 | 
						|
		for k, v := range m.Description {
 | 
						|
			_ = k
 | 
						|
			_ = v
 | 
						|
			mapEntrySize := 1 + len(k) + sovOps(uint64(len(k))) + 1 + len(v) + sovOps(uint64(len(v)))
 | 
						|
			n += mapEntrySize + 1 + sovOps(uint64(mapEntrySize))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if m.ExportCache != nil {
 | 
						|
		l = m.ExportCache.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if len(m.Caps) > 0 {
 | 
						|
		for k, v := range m.Caps {
 | 
						|
			_ = k
 | 
						|
			_ = v
 | 
						|
			mapEntrySize := 1 + len(k) + sovOps(uint64(len(k))) + 1 + 1
 | 
						|
			n += mapEntrySize + 1 + sovOps(uint64(mapEntrySize))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *Source) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.Locations) > 0 {
 | 
						|
		for k, v := range m.Locations {
 | 
						|
			_ = k
 | 
						|
			_ = v
 | 
						|
			l = 0
 | 
						|
			if v != nil {
 | 
						|
				l = v.Size()
 | 
						|
				l += 1 + sovOps(uint64(l))
 | 
						|
			}
 | 
						|
			mapEntrySize := 1 + len(k) + sovOps(uint64(len(k))) + l
 | 
						|
			n += mapEntrySize + 1 + sovOps(uint64(mapEntrySize))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if len(m.Infos) > 0 {
 | 
						|
		for _, e := range m.Infos {
 | 
						|
			l = e.Size()
 | 
						|
			n += 1 + l + sovOps(uint64(l))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *Locations) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.Locations) > 0 {
 | 
						|
		for _, e := range m.Locations {
 | 
						|
			l = e.Size()
 | 
						|
			n += 1 + l + sovOps(uint64(l))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *SourceInfo) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	l = len(m.Filename)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	l = len(m.Data)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.Definition != nil {
 | 
						|
		l = m.Definition.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *Location) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.SourceIndex != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.SourceIndex))
 | 
						|
	}
 | 
						|
	if len(m.Ranges) > 0 {
 | 
						|
		for _, e := range m.Ranges {
 | 
						|
			l = e.Size()
 | 
						|
			n += 1 + l + sovOps(uint64(l))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *Range) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	l = m.Start.Size()
 | 
						|
	n += 1 + l + sovOps(uint64(l))
 | 
						|
	l = m.End.Size()
 | 
						|
	n += 1 + l + sovOps(uint64(l))
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *Position) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Line != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Line))
 | 
						|
	}
 | 
						|
	if m.Character != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Character))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *ExportCache) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Value {
 | 
						|
		n += 2
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *ProxyEnv) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	l = len(m.HttpProxy)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	l = len(m.HttpsProxy)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	l = len(m.FtpProxy)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	l = len(m.NoProxy)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *WorkerConstraints) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.Filter) > 0 {
 | 
						|
		for _, s := range m.Filter {
 | 
						|
			l = len(s)
 | 
						|
			n += 1 + l + sovOps(uint64(l))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *Definition) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.Def) > 0 {
 | 
						|
		for _, b := range m.Def {
 | 
						|
			l = len(b)
 | 
						|
			n += 1 + l + sovOps(uint64(l))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if len(m.Metadata) > 0 {
 | 
						|
		for k, v := range m.Metadata {
 | 
						|
			_ = k
 | 
						|
			_ = v
 | 
						|
			l = v.Size()
 | 
						|
			mapEntrySize := 1 + len(k) + sovOps(uint64(len(k))) + 1 + l + sovOps(uint64(l))
 | 
						|
			n += mapEntrySize + 1 + sovOps(uint64(mapEntrySize))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	if m.Source != nil {
 | 
						|
		l = m.Source.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *HostIP) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	l = len(m.Host)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	l = len(m.IP)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileOp) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if len(m.Actions) > 0 {
 | 
						|
		for _, e := range m.Actions {
 | 
						|
			l = e.Size()
 | 
						|
			n += 1 + l + sovOps(uint64(l))
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileAction) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Input != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Input))
 | 
						|
	}
 | 
						|
	if m.SecondaryInput != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.SecondaryInput))
 | 
						|
	}
 | 
						|
	if m.Output != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Output))
 | 
						|
	}
 | 
						|
	if m.Action != nil {
 | 
						|
		n += m.Action.Size()
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileAction_Copy) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Copy != nil {
 | 
						|
		l = m.Copy.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
func (m *FileAction_Mkfile) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Mkfile != nil {
 | 
						|
		l = m.Mkfile.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
func (m *FileAction_Mkdir) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Mkdir != nil {
 | 
						|
		l = m.Mkdir.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
func (m *FileAction_Rm) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.Rm != nil {
 | 
						|
		l = m.Rm.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
func (m *FileActionCopy) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	l = len(m.Src)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	l = len(m.Dest)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.Owner != nil {
 | 
						|
		l = m.Owner.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.Mode != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Mode))
 | 
						|
	}
 | 
						|
	if m.FollowSymlink {
 | 
						|
		n += 2
 | 
						|
	}
 | 
						|
	if m.DirCopyContents {
 | 
						|
		n += 2
 | 
						|
	}
 | 
						|
	if m.AttemptUnpackDockerCompatibility {
 | 
						|
		n += 2
 | 
						|
	}
 | 
						|
	if m.CreateDestPath {
 | 
						|
		n += 2
 | 
						|
	}
 | 
						|
	if m.AllowWildcard {
 | 
						|
		n += 2
 | 
						|
	}
 | 
						|
	if m.AllowEmptyWildcard {
 | 
						|
		n += 2
 | 
						|
	}
 | 
						|
	if m.Timestamp != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Timestamp))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkFile) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	l = len(m.Path)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.Mode != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Mode))
 | 
						|
	}
 | 
						|
	l = len(m.Data)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.Owner != nil {
 | 
						|
		l = m.Owner.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.Timestamp != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Timestamp))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionMkDir) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	l = len(m.Path)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.Mode != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Mode))
 | 
						|
	}
 | 
						|
	if m.MakeParents {
 | 
						|
		n += 2
 | 
						|
	}
 | 
						|
	if m.Owner != nil {
 | 
						|
		l = m.Owner.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.Timestamp != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Timestamp))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *FileActionRm) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	l = len(m.Path)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.AllowNotFound {
 | 
						|
		n += 2
 | 
						|
	}
 | 
						|
	if m.AllowWildcard {
 | 
						|
		n += 2
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *ChownOpt) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.User != nil {
 | 
						|
		l = m.User.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.Group != nil {
 | 
						|
		l = m.Group.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *UserOpt) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.User != nil {
 | 
						|
		n += m.User.Size()
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func (m *UserOpt_ByName) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	if m.ByName != nil {
 | 
						|
		l = m.ByName.Size()
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
func (m *UserOpt_ByID) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	n += 1 + sovOps(uint64(m.ByID))
 | 
						|
	return n
 | 
						|
}
 | 
						|
func (m *NamedUserOpt) Size() (n int) {
 | 
						|
	if m == nil {
 | 
						|
		return 0
 | 
						|
	}
 | 
						|
	var l int
 | 
						|
	_ = l
 | 
						|
	l = len(m.Name)
 | 
						|
	if l > 0 {
 | 
						|
		n += 1 + l + sovOps(uint64(l))
 | 
						|
	}
 | 
						|
	if m.Input != 0 {
 | 
						|
		n += 1 + sovOps(uint64(m.Input))
 | 
						|
	}
 | 
						|
	return n
 | 
						|
}
 | 
						|
 | 
						|
func sovOps(x uint64) (n int) {
 | 
						|
	return (math_bits.Len64(x|1) + 6) / 7
 | 
						|
}
 | 
						|
func sozOps(x uint64) (n int) {
 | 
						|
	return sovOps(uint64((x << 1) ^ uint64((int64(x) >> 63))))
 | 
						|
}
 | 
						|
func (m *Op) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: Op: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: Op: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Inputs", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Inputs = append(m.Inputs, &Input{})
 | 
						|
			if err := m.Inputs[len(m.Inputs)-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 Exec", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			v := &ExecOp{}
 | 
						|
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			m.Op = &Op_Exec{v}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 3:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			v := &SourceOp{}
 | 
						|
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			m.Op = &Op_Source{v}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 4:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field File", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			v := &FileOp{}
 | 
						|
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			m.Op = &Op_File{v}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 5:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Build", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			v := &BuildOp{}
 | 
						|
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			m.Op = &Op_Build{v}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 10:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Platform", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.Platform == nil {
 | 
						|
				m.Platform = &Platform{}
 | 
						|
			}
 | 
						|
			if err := m.Platform.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 11:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Constraints", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.Constraints == nil {
 | 
						|
				m.Constraints = &WorkerConstraints{}
 | 
						|
			}
 | 
						|
			if err := m.Constraints.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *Platform) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: Platform: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: Platform: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Architecture", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Architecture = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field OS", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.OS = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 3:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Variant", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Variant = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 4:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field OSVersion", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.OSVersion = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 5:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field OSFeatures", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.OSFeatures = append(m.OSFeatures, string(dAtA[iNdEx:postIndex]))
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *Input) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: Input: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: Input: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Digest", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Digest = github_com_opencontainers_go_digest.Digest(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Index", wireType)
 | 
						|
			}
 | 
						|
			m.Index = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Index |= OutputIndex(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *ExecOp) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: ExecOp: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: ExecOp: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Meta", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.Meta == nil {
 | 
						|
				m.Meta = &Meta{}
 | 
						|
			}
 | 
						|
			if err := m.Meta.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Mounts", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Mounts = append(m.Mounts, &Mount{})
 | 
						|
			if err := m.Mounts[len(m.Mounts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 3:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Network", wireType)
 | 
						|
			}
 | 
						|
			m.Network = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Network |= NetMode(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 4:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Security", wireType)
 | 
						|
			}
 | 
						|
			m.Security = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Security |= SecurityMode(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *Meta) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: Meta: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: Meta: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Args", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Args = append(m.Args, string(dAtA[iNdEx:postIndex]))
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Env", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Env = append(m.Env, string(dAtA[iNdEx:postIndex]))
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 3:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Cwd", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Cwd = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 4:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.User = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 5:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field ProxyEnv", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.ProxyEnv == nil {
 | 
						|
				m.ProxyEnv = &ProxyEnv{}
 | 
						|
			}
 | 
						|
			if err := m.ProxyEnv.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 6:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field ExtraHosts", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.ExtraHosts = append(m.ExtraHosts, &HostIP{})
 | 
						|
			if err := m.ExtraHosts[len(m.ExtraHosts)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *Mount) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: Mount: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: Mount: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Input", wireType)
 | 
						|
			}
 | 
						|
			m.Input = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Input |= InputIndex(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 2:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Selector", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Selector = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 3:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Dest", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Dest = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 4:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType)
 | 
						|
			}
 | 
						|
			m.Output = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Output |= OutputIndex(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 5:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Readonly", wireType)
 | 
						|
			}
 | 
						|
			var v int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				v |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.Readonly = bool(v != 0)
 | 
						|
		case 6:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field MountType", wireType)
 | 
						|
			}
 | 
						|
			m.MountType = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.MountType |= MountType(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 20:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field CacheOpt", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.CacheOpt == nil {
 | 
						|
				m.CacheOpt = &CacheOpt{}
 | 
						|
			}
 | 
						|
			if err := m.CacheOpt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 21:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field SecretOpt", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.SecretOpt == nil {
 | 
						|
				m.SecretOpt = &SecretOpt{}
 | 
						|
			}
 | 
						|
			if err := m.SecretOpt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 22:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field SSHOpt", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.SSHOpt == nil {
 | 
						|
				m.SSHOpt = &SSHOpt{}
 | 
						|
			}
 | 
						|
			if err := m.SSHOpt.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *CacheOpt) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: CacheOpt: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: CacheOpt: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.ID = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Sharing", wireType)
 | 
						|
			}
 | 
						|
			m.Sharing = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Sharing |= CacheSharingOpt(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *SecretOpt) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: SecretOpt: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: SecretOpt: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.ID = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
 | 
						|
			}
 | 
						|
			m.Uid = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Uid |= uint32(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 3:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Gid", wireType)
 | 
						|
			}
 | 
						|
			m.Gid = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Gid |= uint32(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 4:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
 | 
						|
			}
 | 
						|
			m.Mode = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Mode |= uint32(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 5:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Optional", wireType)
 | 
						|
			}
 | 
						|
			var v int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				v |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.Optional = bool(v != 0)
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *SSHOpt) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: SSHOpt: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: SSHOpt: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.ID = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Uid", wireType)
 | 
						|
			}
 | 
						|
			m.Uid = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Uid |= uint32(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 3:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Gid", wireType)
 | 
						|
			}
 | 
						|
			m.Gid = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Gid |= uint32(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 4:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
 | 
						|
			}
 | 
						|
			m.Mode = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Mode |= uint32(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 5:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Optional", wireType)
 | 
						|
			}
 | 
						|
			var v int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				v |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.Optional = bool(v != 0)
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *SourceOp) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: SourceOp: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: SourceOp: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Identifier", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Identifier = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Attrs", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.Attrs == nil {
 | 
						|
				m.Attrs = make(map[string]string)
 | 
						|
			}
 | 
						|
			var mapkey string
 | 
						|
			var mapvalue string
 | 
						|
			for iNdEx < postIndex {
 | 
						|
				entryPreIndex := iNdEx
 | 
						|
				var wire uint64
 | 
						|
				for shift := uint(0); ; shift += 7 {
 | 
						|
					if shift >= 64 {
 | 
						|
						return ErrIntOverflowOps
 | 
						|
					}
 | 
						|
					if iNdEx >= l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					b := dAtA[iNdEx]
 | 
						|
					iNdEx++
 | 
						|
					wire |= uint64(b&0x7F) << shift
 | 
						|
					if b < 0x80 {
 | 
						|
						break
 | 
						|
					}
 | 
						|
				}
 | 
						|
				fieldNum := int32(wire >> 3)
 | 
						|
				if fieldNum == 1 {
 | 
						|
					var stringLenmapkey uint64
 | 
						|
					for shift := uint(0); ; shift += 7 {
 | 
						|
						if shift >= 64 {
 | 
						|
							return ErrIntOverflowOps
 | 
						|
						}
 | 
						|
						if iNdEx >= l {
 | 
						|
							return io.ErrUnexpectedEOF
 | 
						|
						}
 | 
						|
						b := dAtA[iNdEx]
 | 
						|
						iNdEx++
 | 
						|
						stringLenmapkey |= uint64(b&0x7F) << shift
 | 
						|
						if b < 0x80 {
 | 
						|
							break
 | 
						|
						}
 | 
						|
					}
 | 
						|
					intStringLenmapkey := int(stringLenmapkey)
 | 
						|
					if intStringLenmapkey < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					postStringIndexmapkey := iNdEx + intStringLenmapkey
 | 
						|
					if postStringIndexmapkey < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if postStringIndexmapkey > l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
 | 
						|
					iNdEx = postStringIndexmapkey
 | 
						|
				} else if fieldNum == 2 {
 | 
						|
					var stringLenmapvalue uint64
 | 
						|
					for shift := uint(0); ; shift += 7 {
 | 
						|
						if shift >= 64 {
 | 
						|
							return ErrIntOverflowOps
 | 
						|
						}
 | 
						|
						if iNdEx >= l {
 | 
						|
							return io.ErrUnexpectedEOF
 | 
						|
						}
 | 
						|
						b := dAtA[iNdEx]
 | 
						|
						iNdEx++
 | 
						|
						stringLenmapvalue |= uint64(b&0x7F) << shift
 | 
						|
						if b < 0x80 {
 | 
						|
							break
 | 
						|
						}
 | 
						|
					}
 | 
						|
					intStringLenmapvalue := int(stringLenmapvalue)
 | 
						|
					if intStringLenmapvalue < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
 | 
						|
					if postStringIndexmapvalue < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if postStringIndexmapvalue > l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
 | 
						|
					iNdEx = postStringIndexmapvalue
 | 
						|
				} else {
 | 
						|
					iNdEx = entryPreIndex
 | 
						|
					skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
					if err != nil {
 | 
						|
						return err
 | 
						|
					}
 | 
						|
					if skippy < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if (iNdEx + skippy) > postIndex {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					iNdEx += skippy
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.Attrs[mapkey] = mapvalue
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *BuildOp) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: BuildOp: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: BuildOp: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Builder", wireType)
 | 
						|
			}
 | 
						|
			m.Builder = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Builder |= InputIndex(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 2:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Inputs", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.Inputs == nil {
 | 
						|
				m.Inputs = make(map[string]*BuildInput)
 | 
						|
			}
 | 
						|
			var mapkey string
 | 
						|
			var mapvalue *BuildInput
 | 
						|
			for iNdEx < postIndex {
 | 
						|
				entryPreIndex := iNdEx
 | 
						|
				var wire uint64
 | 
						|
				for shift := uint(0); ; shift += 7 {
 | 
						|
					if shift >= 64 {
 | 
						|
						return ErrIntOverflowOps
 | 
						|
					}
 | 
						|
					if iNdEx >= l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					b := dAtA[iNdEx]
 | 
						|
					iNdEx++
 | 
						|
					wire |= uint64(b&0x7F) << shift
 | 
						|
					if b < 0x80 {
 | 
						|
						break
 | 
						|
					}
 | 
						|
				}
 | 
						|
				fieldNum := int32(wire >> 3)
 | 
						|
				if fieldNum == 1 {
 | 
						|
					var stringLenmapkey uint64
 | 
						|
					for shift := uint(0); ; shift += 7 {
 | 
						|
						if shift >= 64 {
 | 
						|
							return ErrIntOverflowOps
 | 
						|
						}
 | 
						|
						if iNdEx >= l {
 | 
						|
							return io.ErrUnexpectedEOF
 | 
						|
						}
 | 
						|
						b := dAtA[iNdEx]
 | 
						|
						iNdEx++
 | 
						|
						stringLenmapkey |= uint64(b&0x7F) << shift
 | 
						|
						if b < 0x80 {
 | 
						|
							break
 | 
						|
						}
 | 
						|
					}
 | 
						|
					intStringLenmapkey := int(stringLenmapkey)
 | 
						|
					if intStringLenmapkey < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					postStringIndexmapkey := iNdEx + intStringLenmapkey
 | 
						|
					if postStringIndexmapkey < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if postStringIndexmapkey > l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
 | 
						|
					iNdEx = postStringIndexmapkey
 | 
						|
				} else if fieldNum == 2 {
 | 
						|
					var mapmsglen int
 | 
						|
					for shift := uint(0); ; shift += 7 {
 | 
						|
						if shift >= 64 {
 | 
						|
							return ErrIntOverflowOps
 | 
						|
						}
 | 
						|
						if iNdEx >= l {
 | 
						|
							return io.ErrUnexpectedEOF
 | 
						|
						}
 | 
						|
						b := dAtA[iNdEx]
 | 
						|
						iNdEx++
 | 
						|
						mapmsglen |= int(b&0x7F) << shift
 | 
						|
						if b < 0x80 {
 | 
						|
							break
 | 
						|
						}
 | 
						|
					}
 | 
						|
					if mapmsglen < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					postmsgIndex := iNdEx + mapmsglen
 | 
						|
					if postmsgIndex < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if postmsgIndex > l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					mapvalue = &BuildInput{}
 | 
						|
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
 | 
						|
						return err
 | 
						|
					}
 | 
						|
					iNdEx = postmsgIndex
 | 
						|
				} else {
 | 
						|
					iNdEx = entryPreIndex
 | 
						|
					skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
					if err != nil {
 | 
						|
						return err
 | 
						|
					}
 | 
						|
					if skippy < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if (iNdEx + skippy) > postIndex {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					iNdEx += skippy
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.Inputs[mapkey] = mapvalue
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 3:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Def", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.Def == nil {
 | 
						|
				m.Def = &Definition{}
 | 
						|
			}
 | 
						|
			if err := m.Def.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 4:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Attrs", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.Attrs == nil {
 | 
						|
				m.Attrs = make(map[string]string)
 | 
						|
			}
 | 
						|
			var mapkey string
 | 
						|
			var mapvalue string
 | 
						|
			for iNdEx < postIndex {
 | 
						|
				entryPreIndex := iNdEx
 | 
						|
				var wire uint64
 | 
						|
				for shift := uint(0); ; shift += 7 {
 | 
						|
					if shift >= 64 {
 | 
						|
						return ErrIntOverflowOps
 | 
						|
					}
 | 
						|
					if iNdEx >= l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					b := dAtA[iNdEx]
 | 
						|
					iNdEx++
 | 
						|
					wire |= uint64(b&0x7F) << shift
 | 
						|
					if b < 0x80 {
 | 
						|
						break
 | 
						|
					}
 | 
						|
				}
 | 
						|
				fieldNum := int32(wire >> 3)
 | 
						|
				if fieldNum == 1 {
 | 
						|
					var stringLenmapkey uint64
 | 
						|
					for shift := uint(0); ; shift += 7 {
 | 
						|
						if shift >= 64 {
 | 
						|
							return ErrIntOverflowOps
 | 
						|
						}
 | 
						|
						if iNdEx >= l {
 | 
						|
							return io.ErrUnexpectedEOF
 | 
						|
						}
 | 
						|
						b := dAtA[iNdEx]
 | 
						|
						iNdEx++
 | 
						|
						stringLenmapkey |= uint64(b&0x7F) << shift
 | 
						|
						if b < 0x80 {
 | 
						|
							break
 | 
						|
						}
 | 
						|
					}
 | 
						|
					intStringLenmapkey := int(stringLenmapkey)
 | 
						|
					if intStringLenmapkey < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					postStringIndexmapkey := iNdEx + intStringLenmapkey
 | 
						|
					if postStringIndexmapkey < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if postStringIndexmapkey > l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
 | 
						|
					iNdEx = postStringIndexmapkey
 | 
						|
				} else if fieldNum == 2 {
 | 
						|
					var stringLenmapvalue uint64
 | 
						|
					for shift := uint(0); ; shift += 7 {
 | 
						|
						if shift >= 64 {
 | 
						|
							return ErrIntOverflowOps
 | 
						|
						}
 | 
						|
						if iNdEx >= l {
 | 
						|
							return io.ErrUnexpectedEOF
 | 
						|
						}
 | 
						|
						b := dAtA[iNdEx]
 | 
						|
						iNdEx++
 | 
						|
						stringLenmapvalue |= uint64(b&0x7F) << shift
 | 
						|
						if b < 0x80 {
 | 
						|
							break
 | 
						|
						}
 | 
						|
					}
 | 
						|
					intStringLenmapvalue := int(stringLenmapvalue)
 | 
						|
					if intStringLenmapvalue < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
 | 
						|
					if postStringIndexmapvalue < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if postStringIndexmapvalue > l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
 | 
						|
					iNdEx = postStringIndexmapvalue
 | 
						|
				} else {
 | 
						|
					iNdEx = entryPreIndex
 | 
						|
					skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
					if err != nil {
 | 
						|
						return err
 | 
						|
					}
 | 
						|
					if skippy < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if (iNdEx + skippy) > postIndex {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					iNdEx += skippy
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.Attrs[mapkey] = mapvalue
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *BuildInput) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: BuildInput: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: BuildInput: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Input", wireType)
 | 
						|
			}
 | 
						|
			m.Input = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Input |= InputIndex(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *OpMetadata) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: OpMetadata: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: OpMetadata: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field IgnoreCache", wireType)
 | 
						|
			}
 | 
						|
			var v int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				v |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.IgnoreCache = bool(v != 0)
 | 
						|
		case 2:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Description", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.Description == nil {
 | 
						|
				m.Description = make(map[string]string)
 | 
						|
			}
 | 
						|
			var mapkey string
 | 
						|
			var mapvalue string
 | 
						|
			for iNdEx < postIndex {
 | 
						|
				entryPreIndex := iNdEx
 | 
						|
				var wire uint64
 | 
						|
				for shift := uint(0); ; shift += 7 {
 | 
						|
					if shift >= 64 {
 | 
						|
						return ErrIntOverflowOps
 | 
						|
					}
 | 
						|
					if iNdEx >= l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					b := dAtA[iNdEx]
 | 
						|
					iNdEx++
 | 
						|
					wire |= uint64(b&0x7F) << shift
 | 
						|
					if b < 0x80 {
 | 
						|
						break
 | 
						|
					}
 | 
						|
				}
 | 
						|
				fieldNum := int32(wire >> 3)
 | 
						|
				if fieldNum == 1 {
 | 
						|
					var stringLenmapkey uint64
 | 
						|
					for shift := uint(0); ; shift += 7 {
 | 
						|
						if shift >= 64 {
 | 
						|
							return ErrIntOverflowOps
 | 
						|
						}
 | 
						|
						if iNdEx >= l {
 | 
						|
							return io.ErrUnexpectedEOF
 | 
						|
						}
 | 
						|
						b := dAtA[iNdEx]
 | 
						|
						iNdEx++
 | 
						|
						stringLenmapkey |= uint64(b&0x7F) << shift
 | 
						|
						if b < 0x80 {
 | 
						|
							break
 | 
						|
						}
 | 
						|
					}
 | 
						|
					intStringLenmapkey := int(stringLenmapkey)
 | 
						|
					if intStringLenmapkey < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					postStringIndexmapkey := iNdEx + intStringLenmapkey
 | 
						|
					if postStringIndexmapkey < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if postStringIndexmapkey > l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
 | 
						|
					iNdEx = postStringIndexmapkey
 | 
						|
				} else if fieldNum == 2 {
 | 
						|
					var stringLenmapvalue uint64
 | 
						|
					for shift := uint(0); ; shift += 7 {
 | 
						|
						if shift >= 64 {
 | 
						|
							return ErrIntOverflowOps
 | 
						|
						}
 | 
						|
						if iNdEx >= l {
 | 
						|
							return io.ErrUnexpectedEOF
 | 
						|
						}
 | 
						|
						b := dAtA[iNdEx]
 | 
						|
						iNdEx++
 | 
						|
						stringLenmapvalue |= uint64(b&0x7F) << shift
 | 
						|
						if b < 0x80 {
 | 
						|
							break
 | 
						|
						}
 | 
						|
					}
 | 
						|
					intStringLenmapvalue := int(stringLenmapvalue)
 | 
						|
					if intStringLenmapvalue < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					postStringIndexmapvalue := iNdEx + intStringLenmapvalue
 | 
						|
					if postStringIndexmapvalue < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if postStringIndexmapvalue > l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					mapvalue = string(dAtA[iNdEx:postStringIndexmapvalue])
 | 
						|
					iNdEx = postStringIndexmapvalue
 | 
						|
				} else {
 | 
						|
					iNdEx = entryPreIndex
 | 
						|
					skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
					if err != nil {
 | 
						|
						return err
 | 
						|
					}
 | 
						|
					if skippy < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if (iNdEx + skippy) > postIndex {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					iNdEx += skippy
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.Description[mapkey] = mapvalue
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 4:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field ExportCache", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.ExportCache == nil {
 | 
						|
				m.ExportCache = &ExportCache{}
 | 
						|
			}
 | 
						|
			if err := m.ExportCache.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 5:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Caps", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.Caps == nil {
 | 
						|
				m.Caps = make(map[github_com_moby_buildkit_util_apicaps.CapID]bool)
 | 
						|
			}
 | 
						|
			var mapkey github_com_moby_buildkit_util_apicaps.CapID
 | 
						|
			var mapvalue bool
 | 
						|
			for iNdEx < postIndex {
 | 
						|
				entryPreIndex := iNdEx
 | 
						|
				var wire uint64
 | 
						|
				for shift := uint(0); ; shift += 7 {
 | 
						|
					if shift >= 64 {
 | 
						|
						return ErrIntOverflowOps
 | 
						|
					}
 | 
						|
					if iNdEx >= l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					b := dAtA[iNdEx]
 | 
						|
					iNdEx++
 | 
						|
					wire |= uint64(b&0x7F) << shift
 | 
						|
					if b < 0x80 {
 | 
						|
						break
 | 
						|
					}
 | 
						|
				}
 | 
						|
				fieldNum := int32(wire >> 3)
 | 
						|
				if fieldNum == 1 {
 | 
						|
					var stringLenmapkey uint64
 | 
						|
					for shift := uint(0); ; shift += 7 {
 | 
						|
						if shift >= 64 {
 | 
						|
							return ErrIntOverflowOps
 | 
						|
						}
 | 
						|
						if iNdEx >= l {
 | 
						|
							return io.ErrUnexpectedEOF
 | 
						|
						}
 | 
						|
						b := dAtA[iNdEx]
 | 
						|
						iNdEx++
 | 
						|
						stringLenmapkey |= uint64(b&0x7F) << shift
 | 
						|
						if b < 0x80 {
 | 
						|
							break
 | 
						|
						}
 | 
						|
					}
 | 
						|
					intStringLenmapkey := int(stringLenmapkey)
 | 
						|
					if intStringLenmapkey < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					postStringIndexmapkey := iNdEx + intStringLenmapkey
 | 
						|
					if postStringIndexmapkey < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if postStringIndexmapkey > l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					mapkey = github_com_moby_buildkit_util_apicaps.CapID(dAtA[iNdEx:postStringIndexmapkey])
 | 
						|
					iNdEx = postStringIndexmapkey
 | 
						|
				} else if fieldNum == 2 {
 | 
						|
					var mapvaluetemp int
 | 
						|
					for shift := uint(0); ; shift += 7 {
 | 
						|
						if shift >= 64 {
 | 
						|
							return ErrIntOverflowOps
 | 
						|
						}
 | 
						|
						if iNdEx >= l {
 | 
						|
							return io.ErrUnexpectedEOF
 | 
						|
						}
 | 
						|
						b := dAtA[iNdEx]
 | 
						|
						iNdEx++
 | 
						|
						mapvaluetemp |= int(b&0x7F) << shift
 | 
						|
						if b < 0x80 {
 | 
						|
							break
 | 
						|
						}
 | 
						|
					}
 | 
						|
					mapvalue = bool(mapvaluetemp != 0)
 | 
						|
				} else {
 | 
						|
					iNdEx = entryPreIndex
 | 
						|
					skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
					if err != nil {
 | 
						|
						return err
 | 
						|
					}
 | 
						|
					if skippy < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if (iNdEx + skippy) > postIndex {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					iNdEx += skippy
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.Caps[github_com_moby_buildkit_util_apicaps.CapID(mapkey)] = mapvalue
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *Source) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: Source: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: Source: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Locations", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.Locations == nil {
 | 
						|
				m.Locations = make(map[string]*Locations)
 | 
						|
			}
 | 
						|
			var mapkey string
 | 
						|
			var mapvalue *Locations
 | 
						|
			for iNdEx < postIndex {
 | 
						|
				entryPreIndex := iNdEx
 | 
						|
				var wire uint64
 | 
						|
				for shift := uint(0); ; shift += 7 {
 | 
						|
					if shift >= 64 {
 | 
						|
						return ErrIntOverflowOps
 | 
						|
					}
 | 
						|
					if iNdEx >= l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					b := dAtA[iNdEx]
 | 
						|
					iNdEx++
 | 
						|
					wire |= uint64(b&0x7F) << shift
 | 
						|
					if b < 0x80 {
 | 
						|
						break
 | 
						|
					}
 | 
						|
				}
 | 
						|
				fieldNum := int32(wire >> 3)
 | 
						|
				if fieldNum == 1 {
 | 
						|
					var stringLenmapkey uint64
 | 
						|
					for shift := uint(0); ; shift += 7 {
 | 
						|
						if shift >= 64 {
 | 
						|
							return ErrIntOverflowOps
 | 
						|
						}
 | 
						|
						if iNdEx >= l {
 | 
						|
							return io.ErrUnexpectedEOF
 | 
						|
						}
 | 
						|
						b := dAtA[iNdEx]
 | 
						|
						iNdEx++
 | 
						|
						stringLenmapkey |= uint64(b&0x7F) << shift
 | 
						|
						if b < 0x80 {
 | 
						|
							break
 | 
						|
						}
 | 
						|
					}
 | 
						|
					intStringLenmapkey := int(stringLenmapkey)
 | 
						|
					if intStringLenmapkey < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					postStringIndexmapkey := iNdEx + intStringLenmapkey
 | 
						|
					if postStringIndexmapkey < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if postStringIndexmapkey > l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					mapkey = string(dAtA[iNdEx:postStringIndexmapkey])
 | 
						|
					iNdEx = postStringIndexmapkey
 | 
						|
				} else if fieldNum == 2 {
 | 
						|
					var mapmsglen int
 | 
						|
					for shift := uint(0); ; shift += 7 {
 | 
						|
						if shift >= 64 {
 | 
						|
							return ErrIntOverflowOps
 | 
						|
						}
 | 
						|
						if iNdEx >= l {
 | 
						|
							return io.ErrUnexpectedEOF
 | 
						|
						}
 | 
						|
						b := dAtA[iNdEx]
 | 
						|
						iNdEx++
 | 
						|
						mapmsglen |= int(b&0x7F) << shift
 | 
						|
						if b < 0x80 {
 | 
						|
							break
 | 
						|
						}
 | 
						|
					}
 | 
						|
					if mapmsglen < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					postmsgIndex := iNdEx + mapmsglen
 | 
						|
					if postmsgIndex < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if postmsgIndex > l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					mapvalue = &Locations{}
 | 
						|
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
 | 
						|
						return err
 | 
						|
					}
 | 
						|
					iNdEx = postmsgIndex
 | 
						|
				} else {
 | 
						|
					iNdEx = entryPreIndex
 | 
						|
					skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
					if err != nil {
 | 
						|
						return err
 | 
						|
					}
 | 
						|
					if skippy < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if (iNdEx + skippy) > postIndex {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					iNdEx += skippy
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.Locations[mapkey] = mapvalue
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Infos", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Infos = append(m.Infos, &SourceInfo{})
 | 
						|
			if err := m.Infos[len(m.Infos)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *Locations) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: Locations: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: Locations: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Locations", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Locations = append(m.Locations, &Location{})
 | 
						|
			if err := m.Locations[len(m.Locations)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *SourceInfo) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: SourceInfo: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: SourceInfo: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Filename", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Filename = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		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 ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				byteLen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if byteLen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + byteLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
 | 
						|
			if m.Data == nil {
 | 
						|
				m.Data = []byte{}
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 3:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Definition", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.Definition == nil {
 | 
						|
				m.Definition = &Definition{}
 | 
						|
			}
 | 
						|
			if err := m.Definition.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *Location) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: Location: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: Location: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field SourceIndex", wireType)
 | 
						|
			}
 | 
						|
			m.SourceIndex = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.SourceIndex |= int32(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 2:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Ranges", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Ranges = append(m.Ranges, &Range{})
 | 
						|
			if err := m.Ranges[len(m.Ranges)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *Range) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: Range: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: Range: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Start", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if err := m.Start.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field End", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if err := m.End.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *Position) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: Position: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: Position: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Line", wireType)
 | 
						|
			}
 | 
						|
			m.Line = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Line |= int32(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 2:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Character", wireType)
 | 
						|
			}
 | 
						|
			m.Character = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Character |= int32(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *ExportCache) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: ExportCache: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: ExportCache: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
 | 
						|
			}
 | 
						|
			var v int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				v |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.Value = bool(v != 0)
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *ProxyEnv) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: ProxyEnv: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: ProxyEnv: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field HttpProxy", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.HttpProxy = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field HttpsProxy", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.HttpsProxy = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 3:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field FtpProxy", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.FtpProxy = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 4:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field NoProxy", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.NoProxy = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *WorkerConstraints) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: WorkerConstraints: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: WorkerConstraints: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Filter", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Filter = append(m.Filter, string(dAtA[iNdEx:postIndex]))
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *Definition) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: Definition: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: Definition: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Def", wireType)
 | 
						|
			}
 | 
						|
			var byteLen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				byteLen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if byteLen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + byteLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Def = append(m.Def, make([]byte, postIndex-iNdEx))
 | 
						|
			copy(m.Def[len(m.Def)-1], dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Metadata", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.Metadata == nil {
 | 
						|
				m.Metadata = make(map[github_com_opencontainers_go_digest.Digest]OpMetadata)
 | 
						|
			}
 | 
						|
			var mapkey github_com_opencontainers_go_digest.Digest
 | 
						|
			mapvalue := &OpMetadata{}
 | 
						|
			for iNdEx < postIndex {
 | 
						|
				entryPreIndex := iNdEx
 | 
						|
				var wire uint64
 | 
						|
				for shift := uint(0); ; shift += 7 {
 | 
						|
					if shift >= 64 {
 | 
						|
						return ErrIntOverflowOps
 | 
						|
					}
 | 
						|
					if iNdEx >= l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					b := dAtA[iNdEx]
 | 
						|
					iNdEx++
 | 
						|
					wire |= uint64(b&0x7F) << shift
 | 
						|
					if b < 0x80 {
 | 
						|
						break
 | 
						|
					}
 | 
						|
				}
 | 
						|
				fieldNum := int32(wire >> 3)
 | 
						|
				if fieldNum == 1 {
 | 
						|
					var stringLenmapkey uint64
 | 
						|
					for shift := uint(0); ; shift += 7 {
 | 
						|
						if shift >= 64 {
 | 
						|
							return ErrIntOverflowOps
 | 
						|
						}
 | 
						|
						if iNdEx >= l {
 | 
						|
							return io.ErrUnexpectedEOF
 | 
						|
						}
 | 
						|
						b := dAtA[iNdEx]
 | 
						|
						iNdEx++
 | 
						|
						stringLenmapkey |= uint64(b&0x7F) << shift
 | 
						|
						if b < 0x80 {
 | 
						|
							break
 | 
						|
						}
 | 
						|
					}
 | 
						|
					intStringLenmapkey := int(stringLenmapkey)
 | 
						|
					if intStringLenmapkey < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					postStringIndexmapkey := iNdEx + intStringLenmapkey
 | 
						|
					if postStringIndexmapkey < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if postStringIndexmapkey > l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					mapkey = github_com_opencontainers_go_digest.Digest(dAtA[iNdEx:postStringIndexmapkey])
 | 
						|
					iNdEx = postStringIndexmapkey
 | 
						|
				} else if fieldNum == 2 {
 | 
						|
					var mapmsglen int
 | 
						|
					for shift := uint(0); ; shift += 7 {
 | 
						|
						if shift >= 64 {
 | 
						|
							return ErrIntOverflowOps
 | 
						|
						}
 | 
						|
						if iNdEx >= l {
 | 
						|
							return io.ErrUnexpectedEOF
 | 
						|
						}
 | 
						|
						b := dAtA[iNdEx]
 | 
						|
						iNdEx++
 | 
						|
						mapmsglen |= int(b&0x7F) << shift
 | 
						|
						if b < 0x80 {
 | 
						|
							break
 | 
						|
						}
 | 
						|
					}
 | 
						|
					if mapmsglen < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					postmsgIndex := iNdEx + mapmsglen
 | 
						|
					if postmsgIndex < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if postmsgIndex > l {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					mapvalue = &OpMetadata{}
 | 
						|
					if err := mapvalue.Unmarshal(dAtA[iNdEx:postmsgIndex]); err != nil {
 | 
						|
						return err
 | 
						|
					}
 | 
						|
					iNdEx = postmsgIndex
 | 
						|
				} else {
 | 
						|
					iNdEx = entryPreIndex
 | 
						|
					skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
					if err != nil {
 | 
						|
						return err
 | 
						|
					}
 | 
						|
					if skippy < 0 {
 | 
						|
						return ErrInvalidLengthOps
 | 
						|
					}
 | 
						|
					if (iNdEx + skippy) > postIndex {
 | 
						|
						return io.ErrUnexpectedEOF
 | 
						|
					}
 | 
						|
					iNdEx += skippy
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.Metadata[github_com_opencontainers_go_digest.Digest(mapkey)] = *mapvalue
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 3:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Source", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.Source == nil {
 | 
						|
				m.Source = &Source{}
 | 
						|
			}
 | 
						|
			if err := m.Source.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *HostIP) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: HostIP: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: HostIP: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Host", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Host = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field IP", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.IP = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *FileOp) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: FileOp: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: FileOp: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 2:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Actions", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Actions = append(m.Actions, &FileAction{})
 | 
						|
			if err := m.Actions[len(m.Actions)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *FileAction) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: FileAction: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: FileAction: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Input", wireType)
 | 
						|
			}
 | 
						|
			m.Input = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Input |= InputIndex(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 2:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field SecondaryInput", wireType)
 | 
						|
			}
 | 
						|
			m.SecondaryInput = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.SecondaryInput |= InputIndex(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 3:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Output", wireType)
 | 
						|
			}
 | 
						|
			m.Output = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Output |= OutputIndex(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 4:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Copy", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			v := &FileActionCopy{}
 | 
						|
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			m.Action = &FileAction_Copy{v}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 5:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Mkfile", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			v := &FileActionMkFile{}
 | 
						|
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			m.Action = &FileAction_Mkfile{v}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 6:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Mkdir", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			v := &FileActionMkDir{}
 | 
						|
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			m.Action = &FileAction_Mkdir{v}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 7:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Rm", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			v := &FileActionRm{}
 | 
						|
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			m.Action = &FileAction_Rm{v}
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *FileActionCopy) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: FileActionCopy: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: FileActionCopy: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Src", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Src = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Dest", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Dest = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 3:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.Owner == nil {
 | 
						|
				m.Owner = &ChownOpt{}
 | 
						|
			}
 | 
						|
			if err := m.Owner.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 4:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
 | 
						|
			}
 | 
						|
			m.Mode = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Mode |= int32(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 5:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field FollowSymlink", wireType)
 | 
						|
			}
 | 
						|
			var v int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				v |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.FollowSymlink = bool(v != 0)
 | 
						|
		case 6:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field DirCopyContents", wireType)
 | 
						|
			}
 | 
						|
			var v int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				v |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.DirCopyContents = bool(v != 0)
 | 
						|
		case 7:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field AttemptUnpackDockerCompatibility", wireType)
 | 
						|
			}
 | 
						|
			var v int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				v |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.AttemptUnpackDockerCompatibility = bool(v != 0)
 | 
						|
		case 8:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field CreateDestPath", wireType)
 | 
						|
			}
 | 
						|
			var v int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				v |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.CreateDestPath = bool(v != 0)
 | 
						|
		case 9:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field AllowWildcard", wireType)
 | 
						|
			}
 | 
						|
			var v int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				v |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.AllowWildcard = bool(v != 0)
 | 
						|
		case 10:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field AllowEmptyWildcard", wireType)
 | 
						|
			}
 | 
						|
			var v int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				v |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.AllowEmptyWildcard = bool(v != 0)
 | 
						|
		case 11:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
 | 
						|
			}
 | 
						|
			m.Timestamp = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Timestamp |= int64(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *FileActionMkFile) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: FileActionMkFile: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: FileActionMkFile: 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 ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Path = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
 | 
						|
			}
 | 
						|
			m.Mode = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Mode |= int32(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 3:
 | 
						|
			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 ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				byteLen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if byteLen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + byteLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Data = append(m.Data[:0], dAtA[iNdEx:postIndex]...)
 | 
						|
			if m.Data == nil {
 | 
						|
				m.Data = []byte{}
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 4:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.Owner == nil {
 | 
						|
				m.Owner = &ChownOpt{}
 | 
						|
			}
 | 
						|
			if err := m.Owner.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 5:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
 | 
						|
			}
 | 
						|
			m.Timestamp = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Timestamp |= int64(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *FileActionMkDir) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: FileActionMkDir: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: FileActionMkDir: 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 ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Path = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Mode", wireType)
 | 
						|
			}
 | 
						|
			m.Mode = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Mode |= int32(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 3:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field MakeParents", wireType)
 | 
						|
			}
 | 
						|
			var v int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				v |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.MakeParents = bool(v != 0)
 | 
						|
		case 4:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Owner", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.Owner == nil {
 | 
						|
				m.Owner = &ChownOpt{}
 | 
						|
			}
 | 
						|
			if err := m.Owner.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 5:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Timestamp", wireType)
 | 
						|
			}
 | 
						|
			m.Timestamp = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Timestamp |= int64(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *FileActionRm) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: FileActionRm: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: FileActionRm: 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 ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Path = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field AllowNotFound", wireType)
 | 
						|
			}
 | 
						|
			var v int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				v |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.AllowNotFound = bool(v != 0)
 | 
						|
		case 3:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field AllowWildcard", wireType)
 | 
						|
			}
 | 
						|
			var v int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				v |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.AllowWildcard = bool(v != 0)
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *ChownOpt) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: ChownOpt: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: ChownOpt: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.User == nil {
 | 
						|
				m.User = &UserOpt{}
 | 
						|
			}
 | 
						|
			if err := m.User.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Group", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			if m.Group == nil {
 | 
						|
				m.Group = &UserOpt{}
 | 
						|
			}
 | 
						|
			if err := m.Group.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			iNdEx = postIndex
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *UserOpt) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: UserOpt: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: UserOpt: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field ByName", wireType)
 | 
						|
			}
 | 
						|
			var msglen int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				msglen |= int(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if msglen < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + msglen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			v := &NamedUserOpt{}
 | 
						|
			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			m.User = &UserOpt_ByName{v}
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field ByID", wireType)
 | 
						|
			}
 | 
						|
			var v uint32
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				v |= uint32(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			m.User = &UserOpt_ByID{v}
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func (m *NamedUserOpt) 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 ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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: NamedUserOpt: wiretype end group for non-group")
 | 
						|
		}
 | 
						|
		if fieldNum <= 0 {
 | 
						|
			return fmt.Errorf("proto: NamedUserOpt: illegal tag %d (wire type %d)", fieldNum, wire)
 | 
						|
		}
 | 
						|
		switch fieldNum {
 | 
						|
		case 1:
 | 
						|
			if wireType != 2 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
 | 
						|
			}
 | 
						|
			var stringLen uint64
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				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 ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			postIndex := iNdEx + intStringLen
 | 
						|
			if postIndex < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if postIndex > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			m.Name = string(dAtA[iNdEx:postIndex])
 | 
						|
			iNdEx = postIndex
 | 
						|
		case 2:
 | 
						|
			if wireType != 0 {
 | 
						|
				return fmt.Errorf("proto: wrong wireType = %d for field Input", wireType)
 | 
						|
			}
 | 
						|
			m.Input = 0
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				m.Input |= InputIndex(b&0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		default:
 | 
						|
			iNdEx = preIndex
 | 
						|
			skippy, err := skipOps(dAtA[iNdEx:])
 | 
						|
			if err != nil {
 | 
						|
				return err
 | 
						|
			}
 | 
						|
			if skippy < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) < 0 {
 | 
						|
				return ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			if (iNdEx + skippy) > l {
 | 
						|
				return io.ErrUnexpectedEOF
 | 
						|
			}
 | 
						|
			iNdEx += skippy
 | 
						|
		}
 | 
						|
	}
 | 
						|
 | 
						|
	if iNdEx > l {
 | 
						|
		return io.ErrUnexpectedEOF
 | 
						|
	}
 | 
						|
	return nil
 | 
						|
}
 | 
						|
func skipOps(dAtA []byte) (n int, err error) {
 | 
						|
	l := len(dAtA)
 | 
						|
	iNdEx := 0
 | 
						|
	depth := 0
 | 
						|
	for iNdEx < l {
 | 
						|
		var wire uint64
 | 
						|
		for shift := uint(0); ; shift += 7 {
 | 
						|
			if shift >= 64 {
 | 
						|
				return 0, ErrIntOverflowOps
 | 
						|
			}
 | 
						|
			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, ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return 0, io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				iNdEx++
 | 
						|
				if dAtA[iNdEx-1] < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
		case 1:
 | 
						|
			iNdEx += 8
 | 
						|
		case 2:
 | 
						|
			var length int
 | 
						|
			for shift := uint(0); ; shift += 7 {
 | 
						|
				if shift >= 64 {
 | 
						|
					return 0, ErrIntOverflowOps
 | 
						|
				}
 | 
						|
				if iNdEx >= l {
 | 
						|
					return 0, io.ErrUnexpectedEOF
 | 
						|
				}
 | 
						|
				b := dAtA[iNdEx]
 | 
						|
				iNdEx++
 | 
						|
				length |= (int(b) & 0x7F) << shift
 | 
						|
				if b < 0x80 {
 | 
						|
					break
 | 
						|
				}
 | 
						|
			}
 | 
						|
			if length < 0 {
 | 
						|
				return 0, ErrInvalidLengthOps
 | 
						|
			}
 | 
						|
			iNdEx += length
 | 
						|
		case 3:
 | 
						|
			depth++
 | 
						|
		case 4:
 | 
						|
			if depth == 0 {
 | 
						|
				return 0, ErrUnexpectedEndOfGroupOps
 | 
						|
			}
 | 
						|
			depth--
 | 
						|
		case 5:
 | 
						|
			iNdEx += 4
 | 
						|
		default:
 | 
						|
			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
 | 
						|
		}
 | 
						|
		if iNdEx < 0 {
 | 
						|
			return 0, ErrInvalidLengthOps
 | 
						|
		}
 | 
						|
		if depth == 0 {
 | 
						|
			return iNdEx, nil
 | 
						|
		}
 | 
						|
	}
 | 
						|
	return 0, io.ErrUnexpectedEOF
 | 
						|
}
 | 
						|
 | 
						|
var (
 | 
						|
	ErrInvalidLengthOps        = fmt.Errorf("proto: negative length found during unmarshaling")
 | 
						|
	ErrIntOverflowOps          = fmt.Errorf("proto: integer overflow")
 | 
						|
	ErrUnexpectedEndOfGroupOps = fmt.Errorf("proto: unexpected end of group")
 | 
						|
)
 |