Merge pull request #1467 from tonistiigi/update-buildkit-862b22

vendor: update buildkit to 862b22d7

go.mod

@@ -16,7 +16,7 @@ require (
 	github.com/google/shlex v0.0.0-20191202100458-e7afc7fbc510
 	github.com/hashicorp/go-cty-funcs v0.0.0-20200930094925-2721b1e36840
 	github.com/hashicorp/hcl/v2 v2.8.2
-	github.com/moby/buildkit v0.11.0-rc1.0.20221213104201-93b40706a007
+	github.com/moby/buildkit v0.11.0-rc1.0.20221213193744-862b22d7e7cf
 	github.com/morikuni/aec v1.0.0
 	github.com/opencontainers/go-digest v1.0.0
 	github.com/opencontainers/image-spec v1.0.3-0.20220303224323-02efb9a75ee1

go.sum

@@ -401,8 +401,8 @@ github.com/mitchellh/go-wordwrap v0.0.0-20150314170334-ad45545899c7/go.mod h1:ZX
 github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
 github.com/mitchellh/mapstructure v1.5.0 h1:jeMsZIYE/09sWLaz43PL7Gy6RuMjD2eJVyuac5Z2hdY=
 github.com/mitchellh/mapstructure v1.5.0/go.mod h1:bFUtVrKA4DC2yAKiSyO/QUcy7e+RRV2QTWOzhPopBRo=
-github.com/moby/buildkit v0.11.0-rc1.0.20221213104201-93b40706a007 h1:TS2xbnk6pp0hRf8cU3Ej4mcKEFY+CZ/2lYDR5kuRZss=
+github.com/moby/buildkit v0.11.0-rc1.0.20221213193744-862b22d7e7cf h1:X4p2o1QeaKAJ8prPctFx98UrokFHsUgbiC0lDUObpOk=
-github.com/moby/buildkit v0.11.0-rc1.0.20221213104201-93b40706a007/go.mod h1:f3jvilDvcG14z+gzPpA2lcWRwIRyFiNTo5bMwHiYDk0=
+github.com/moby/buildkit v0.11.0-rc1.0.20221213193744-862b22d7e7cf/go.mod h1:f3jvilDvcG14z+gzPpA2lcWRwIRyFiNTo5bMwHiYDk0=
 github.com/moby/locker v1.0.1 h1:fOXqR41zeveg4fFODix+1Ch4mj/gT0NE1XJbp/epuBg=
 github.com/moby/locker v1.0.1/go.mod h1:S7SDdo5zpBK84bzzVlKr2V0hz+7x9hWbYC/kq7oQppc=
 github.com/moby/patternmatcher v0.5.0 h1:YCZgJOeULcxLw1Q+sVR636pmS7sPEn1Qo2iAN6M7DBo=

vendor/github.com/moby/buildkit/api/services/control/control.proto

@@ -23,6 +23,7 @@ service Control {
 	rpc Info(InfoRequest) returns (InfoResponse);
 
 	rpc ListenBuildHistory(BuildHistoryRequest) returns (stream BuildHistoryEvent);
+	rpc UpdateBuildHistory(UpdateBuildHistoryRequest) returns (UpdateBuildHistoryResponse);
 }
 
 message PruneRequest {
@@ -66,6 +67,7 @@ message SolveRequest {
 	CacheOptions Cache = 8 [(gogoproto.nullable) = false];
 	repeated string Entitlements = 9 [(gogoproto.customtype) = "github.com/moby/buildkit/util/entitlements.Entitlement" ];
 	map<string, pb.Definition> FrontendInputs = 10;
+	bool Internal = 11; // Internal builds are not recorded in build history
 }
 
 message CacheOptions {
@@ -171,6 +173,7 @@ message InfoResponse {
 message BuildHistoryRequest {
 	bool ActiveOnly = 1;
 	string Ref = 2;
+	bool EarlyExit = 3;
 }
 
 enum BuildHistoryEventType {
@@ -179,7 +182,6 @@ enum BuildHistoryEventType {
 	DELETED = 2;
 }
 
-
 message BuildHistoryEvent {
 	BuildHistoryEventType type = 1;
 	BuildHistoryRecord record = 2;
@@ -198,12 +200,21 @@ message BuildHistoryRecord {
 	BuildResultInfo Result = 10;
 	map<string, BuildResultInfo> Results = 11;
 	int32 Generation = 12;
+	Descriptor trace = 13;
+	bool pinned = 14;
 	// TODO: tags
 	// TODO: steps/cache summary
 	// TODO: unclipped logs
-	// TODO: pinning
 }
 
+message UpdateBuildHistoryRequest {
+	string Ref = 1;
+	bool Pinned = 2;
+	bool Delete = 3;
+}
+
+message UpdateBuildHistoryResponse {}
+
 message Descriptor {
 	string media_type = 1;
 	string digest = 2 [(gogoproto.customtype) = "github.com/opencontainers/go-digest.Digest", (gogoproto.nullable) = false];

vendor/github.com/moby/buildkit/client/client.go

@@ -9,6 +9,7 @@ import (
 	"os"
 	"strings"
 
+	contentapi "github.com/containerd/containerd/api/services/content/v1"
 	"github.com/containerd/containerd/defaults"
 	grpc_middleware "github.com/grpc-ecosystem/go-grpc-middleware"
 	controlapi "github.com/moby/buildkit/api/services/control"
@@ -172,6 +173,10 @@ func (c *Client) ControlClient() controlapi.ControlClient {
 	return controlapi.NewControlClient(c.conn)
 }
 
+func (c *Client) ContentClient() contentapi.ContentClient {
+	return contentapi.NewContentClient(c.conn)
+}
+
 func (c *Client) Dialer() session.Dialer {
 	return grpchijack.Dialer(c.ControlClient())
 }

vendor/github.com/moby/buildkit/client/solve.go

@@ -46,6 +46,7 @@ type SolveOpt struct {
 	AllowedEntitlements   []entitlements.Entitlement
 	SharedSession         *session.Session // TODO: refactor to better session syncing
 	SessionPreInitialized bool             // TODO: refactor to better session syncing
+	Internal              bool
 }
 
 type ExportEntry struct {
@@ -259,6 +260,7 @@ func (c *Client) solve(ctx context.Context, def *llb.Definition, runGateway runG
 			FrontendInputs: frontendInputs,
 			Cache:          cacheOpt.options,
 			Entitlements:   opt.AllowedEntitlements,
+			Internal:       opt.Internal,
 		})
 		if err != nil {
 			return errors.Wrap(err, "failed to solve")
@@ -350,54 +352,6 @@ func (c *Client) solve(ctx context.Context, def *llb.Definition, runGateway runG
 	return res, nil
 }
 
-func NewSolveStatus(resp *controlapi.StatusResponse) *SolveStatus {
-	s := &SolveStatus{}
-	for _, v := range resp.Vertexes {
-		s.Vertexes = append(s.Vertexes, &Vertex{
-			Digest:        v.Digest,
-			Inputs:        v.Inputs,
-			Name:          v.Name,
-			Started:       v.Started,
-			Completed:     v.Completed,
-			Error:         v.Error,
-			Cached:        v.Cached,
-			ProgressGroup: v.ProgressGroup,
-		})
-	}
-	for _, v := range resp.Statuses {
-		s.Statuses = append(s.Statuses, &VertexStatus{
-			ID:        v.ID,
-			Vertex:    v.Vertex,
-			Name:      v.Name,
-			Total:     v.Total,
-			Current:   v.Current,
-			Timestamp: v.Timestamp,
-			Started:   v.Started,
-			Completed: v.Completed,
-		})
-	}
-	for _, v := range resp.Logs {
-		s.Logs = append(s.Logs, &VertexLog{
-			Vertex:    v.Vertex,
-			Stream:    int(v.Stream),
-			Data:      v.Msg,
-			Timestamp: v.Timestamp,
-		})
-	}
-	for _, v := range resp.Warnings {
-		s.Warnings = append(s.Warnings, &VertexWarning{
-			Vertex:     v.Vertex,
-			Level:      int(v.Level),
-			Short:      v.Short,
-			Detail:     v.Detail,
-			URL:        v.Url,
-			SourceInfo: v.Info,
-			Range:      v.Ranges,
-		})
-	}
-	return s
-}
-
 func prepareSyncedDirs(def *llb.Definition, localDirs map[string]string) (filesync.StaticDirSource, error) {
 	for _, d := range localDirs {
 		fi, err := os.Stat(d)

vendor/github.com/moby/buildkit/client/status.go

@@ -0,0 +1,125 @@
+package client
+
+import (
+	controlapi "github.com/moby/buildkit/api/services/control"
+)
+
+var emptyLogVertexSize int
+
+func init() {
+	emptyLogVertex := controlapi.VertexLog{}
+	emptyLogVertexSize = emptyLogVertex.Size()
+}
+
+func NewSolveStatus(resp *controlapi.StatusResponse) *SolveStatus {
+	s := &SolveStatus{}
+	for _, v := range resp.Vertexes {
+		s.Vertexes = append(s.Vertexes, &Vertex{
+			Digest:        v.Digest,
+			Inputs:        v.Inputs,
+			Name:          v.Name,
+			Started:       v.Started,
+			Completed:     v.Completed,
+			Error:         v.Error,
+			Cached:        v.Cached,
+			ProgressGroup: v.ProgressGroup,
+		})
+	}
+	for _, v := range resp.Statuses {
+		s.Statuses = append(s.Statuses, &VertexStatus{
+			ID:        v.ID,
+			Vertex:    v.Vertex,
+			Name:      v.Name,
+			Total:     v.Total,
+			Current:   v.Current,
+			Timestamp: v.Timestamp,
+			Started:   v.Started,
+			Completed: v.Completed,
+		})
+	}
+	for _, v := range resp.Logs {
+		s.Logs = append(s.Logs, &VertexLog{
+			Vertex:    v.Vertex,
+			Stream:    int(v.Stream),
+			Data:      v.Msg,
+			Timestamp: v.Timestamp,
+		})
+	}
+	for _, v := range resp.Warnings {
+		s.Warnings = append(s.Warnings, &VertexWarning{
+			Vertex:     v.Vertex,
+			Level:      int(v.Level),
+			Short:      v.Short,
+			Detail:     v.Detail,
+			URL:        v.Url,
+			SourceInfo: v.Info,
+			Range:      v.Ranges,
+		})
+	}
+	return s
+}
+
+func (ss *SolveStatus) Marshal() (out []*controlapi.StatusResponse) {
+	logSize := 0
+	for {
+		retry := false
+		sr := controlapi.StatusResponse{}
+		for _, v := range ss.Vertexes {
+			sr.Vertexes = append(sr.Vertexes, &controlapi.Vertex{
+				Digest:        v.Digest,
+				Inputs:        v.Inputs,
+				Name:          v.Name,
+				Started:       v.Started,
+				Completed:     v.Completed,
+				Error:         v.Error,
+				Cached:        v.Cached,
+				ProgressGroup: v.ProgressGroup,
+			})
+		}
+		for _, v := range ss.Statuses {
+			sr.Statuses = append(sr.Statuses, &controlapi.VertexStatus{
+				ID:        v.ID,
+				Vertex:    v.Vertex,
+				Name:      v.Name,
+				Current:   v.Current,
+				Total:     v.Total,
+				Timestamp: v.Timestamp,
+				Started:   v.Started,
+				Completed: v.Completed,
+			})
+		}
+		for i, v := range ss.Logs {
+			sr.Logs = append(sr.Logs, &controlapi.VertexLog{
+				Vertex:    v.Vertex,
+				Stream:    int64(v.Stream),
+				Msg:       v.Data,
+				Timestamp: v.Timestamp,
+			})
+			logSize += len(v.Data) + emptyLogVertexSize
+			// avoid logs growing big and split apart if they do
+			if logSize > 1024*1024 {
+				ss.Vertexes = nil
+				ss.Statuses = nil
+				ss.Logs = ss.Logs[i+1:]
+				retry = true
+				break
+			}
+		}
+		for _, v := range ss.Warnings {
+			sr.Warnings = append(sr.Warnings, &controlapi.VertexWarning{
+				Vertex: v.Vertex,
+				Level:  int64(v.Level),
+				Short:  v.Short,
+				Detail: v.Detail,
+				Info:   v.SourceInfo,
+				Ranges: v.Range,
+				Url:    v.URL,
+			})
+		}
+		out = append(out, &sr)
+		if !retry {
+			break
+		}
+	}
+	return
+}

vendor/github.com/moby/buildkit/cmd/buildkitd/config/config.go

@@ -24,6 +24,8 @@ type Config struct {
 	Registries map[string]resolverconfig.RegistryConfig `toml:"registry"`
 
 	DNS *DNSConfig `toml:"dns"`
+
+	History *HistoryConfig `toml:"history"`
 }
 
 type GRPCConfig struct {
@@ -123,3 +125,8 @@ type DNSConfig struct {
 	Options       []string `toml:"options"`
 	SearchDomains []string `toml:"searchDomains"`
 }
+
+type HistoryConfig struct {
+	MaxAge     int64 `toml:"maxAge"`
+	MaxEntries int64 `toml:"maxEntries"`
+}

vendor/github.com/moby/buildkit/frontend/gateway/pb/gateway.pb.go

@@ -90,9 +90,10 @@ type Result struct {
 	//	*Result_RefsDeprecated
 	//	*Result_Ref
 	//	*Result_Refs
-	Result               isResult_Result          `protobuf_oneof:"result"`
+	Result   isResult_Result   `protobuf_oneof:"result"`
-	Metadata             map[string][]byte        `protobuf:"bytes,10,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	Metadata map[string][]byte `protobuf:"bytes,10,rep,name=metadata,proto3" json:"metadata,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
-	Attestations         map[string]*Attestations `protobuf:"bytes,11,rep,name=attestations,proto3" json:"attestations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
+	// 11 was used during development and is reserved for old attestation format
+	Attestations         map[string]*Attestations `protobuf:"bytes,12,rep,name=attestations,proto3" json:"attestations,omitempty" protobuf_key:"bytes,1,opt,name=key,proto3" protobuf_val:"bytes,2,opt,name=value,proto3"`
 	XXX_NoUnkeyedLiteral struct{}                 `json:"-"`
 	XXX_unrecognized     []byte                   `json:"-"`
 	XXX_sizecache        int32                    `json:"-"`
@@ -2609,157 +2610,157 @@ func init() {
 func init() { proto.RegisterFile("gateway.proto", fileDescriptor_f1a937782ebbded5) }
 
 var fileDescriptor_f1a937782ebbded5 = []byte{
-	// 2395 bytes of a gzipped FileDescriptorProto
+	// 2397 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x39, 0xcd, 0x6f, 0x1b, 0xc7,
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x59, 0xcf, 0x6f, 0x1b, 0xc7,
-	0xf5, 0x5a, 0x91, 0x12, 0xc9, 0xc7, 0x0f, 0xd1, 0x13, 0x27, 0x3f, 0x66, 0x11, 0x38, 0xf2, 0x3a,
+	0xf5, 0xd7, 0x8a, 0x94, 0x48, 0x3e, 0xfe, 0x10, 0x3d, 0x71, 0xf2, 0x65, 0x16, 0x81, 0x23, 0xaf,
-	0x51, 0x64, 0xc5, 0x21, 0xfd, 0xa3, 0x1d, 0xc8, 0xb5, 0x5b, 0x27, 0xd6, 0x17, 0xa4, 0x58, 0xb2,
+	0x13, 0x45, 0x56, 0x1c, 0xd2, 0x5f, 0xda, 0x81, 0x5c, 0xbb, 0x75, 0x62, 0xfd, 0x82, 0x14, 0x4b,
-	0xd9, 0x91, 0x0b, 0x17, 0x41, 0x0a, 0x74, 0xc5, 0x1d, 0xd2, 0x5b, 0xaf, 0x76, 0xb7, 0xbb, 0x43,
+	0x36, 0x3b, 0x72, 0xe1, 0x22, 0x48, 0x81, 0xae, 0xb8, 0x43, 0x7a, 0xeb, 0xd5, 0xee, 0x76, 0x77,
-	0xcb, 0x4a, 0x2e, 0xed, 0xad, 0xc8, 0xa9, 0xa7, 0xde, 0x82, 0x02, 0x2d, 0xd0, 0x73, 0x7b, 0xe9,
+	0x68, 0x59, 0xc9, 0xa5, 0xbd, 0x15, 0x39, 0xf5, 0xd4, 0x5b, 0x50, 0xa0, 0x05, 0x7a, 0x6e, 0x2f,
-	0xad, 0x3d, 0x07, 0xe8, 0xa5, 0x97, 0x5e, 0x7a, 0x08, 0x0a, 0xff, 0x11, 0x05, 0x7a, 0x2b, 0xde,
+	0xbd, 0xb5, 0xe7, 0x00, 0xbd, 0xf4, 0xd2, 0x4b, 0x0f, 0x41, 0xe1, 0x3f, 0xa2, 0x40, 0x6f, 0xc5,
-	0xcc, 0x2c, 0x39, 0xfc, 0xd0, 0x92, 0xac, 0x4f, 0x9c, 0x79, 0xf3, 0x3e, 0xe6, 0x7d, 0xbf, 0x59,
+	0x9b, 0x99, 0x25, 0x87, 0x3f, 0xb4, 0x24, 0xeb, 0x13, 0x67, 0xde, 0xbc, 0x1f, 0x33, 0xef, 0xcd,
-	0x42, 0xb9, 0x6b, 0x73, 0x76, 0x66, 0x9f, 0xd7, 0xc3, 0x28, 0xe0, 0x01, 0x79, 0xfb, 0x34, 0x38,
+	0x7b, 0xef, 0x33, 0x4b, 0x28, 0x77, 0x6d, 0xce, 0xce, 0xec, 0xf3, 0x7a, 0x18, 0x05, 0x3c, 0x20,
-	0x39, 0xaf, 0x9f, 0xf4, 0x5c, 0xcf, 0x79, 0xee, 0xf2, 0xfa, 0x8b, 0xff, 0xaf, 0x77, 0xa2, 0xc0,
+	0x6f, 0x9f, 0x06, 0x27, 0xe7, 0xf5, 0x93, 0x9e, 0xeb, 0x39, 0xcf, 0x5d, 0x5e, 0x7f, 0xf1, 0xff,
-	0xe7, 0xcc, 0x77, 0xcc, 0x8f, 0xba, 0x2e, 0x7f, 0xd6, 0x3b, 0xa9, 0xb7, 0x83, 0xd3, 0x46, 0x37,
+	0xf5, 0x4e, 0x14, 0xf8, 0x9c, 0xf9, 0x8e, 0xf9, 0x51, 0xd7, 0xe5, 0xcf, 0x7a, 0x27, 0xf5, 0x76,
-	0xe8, 0x06, 0x0d, 0x41, 0x71, 0xd2, 0xeb, 0x88, 0x9d, 0xd8, 0x88, 0x95, 0xe4, 0x64, 0x36, 0x47,
+	0x70, 0xda, 0xe8, 0x06, 0xdd, 0xa0, 0x21, 0x24, 0x4e, 0x7a, 0x1d, 0x31, 0x13, 0x13, 0x31, 0x92,
-	0xd1, 0xbb, 0x41, 0xd0, 0xf5, 0x98, 0x1d, 0xba, 0xb1, 0x5a, 0x36, 0xa2, 0xb0, 0xdd, 0x88, 0xb9,
+	0x9a, 0xcc, 0xe6, 0x28, 0x7b, 0x37, 0x08, 0xba, 0x1e, 0xb3, 0x43, 0x37, 0x56, 0xc3, 0x46, 0x14,
-	0xcd, 0x7b, 0xb1, 0xa2, 0xb9, 0xa1, 0xd1, 0xe0, 0x45, 0x1a, 0xc9, 0x45, 0x1a, 0x71, 0xe0, 0xbd,
+	0xb6, 0x1b, 0x31, 0xb7, 0x79, 0x2f, 0x56, 0x32, 0x37, 0x34, 0x19, 0xdc, 0x48, 0x23, 0xd9, 0x48,
-	0x60, 0x51, 0x23, 0x3c, 0x69, 0x04, 0x61, 0x82, 0xdd, 0xb8, 0x10, 0xdb, 0x0e, 0xdd, 0x06, 0x3f,
+	0x23, 0x0e, 0xbc, 0x17, 0x2c, 0x6a, 0x84, 0x27, 0x8d, 0x20, 0x4c, 0xb8, 0x1b, 0x17, 0x72, 0xdb,
-	0x0f, 0x59, 0xdc, 0x38, 0x0b, 0xa2, 0xe7, 0x2c, 0x52, 0x04, 0xb7, 0x2e, 0x24, 0xe8, 0x71, 0xd7,
+	0xa1, 0xdb, 0xe0, 0xe7, 0x21, 0x8b, 0x1b, 0x67, 0x41, 0xf4, 0x9c, 0x45, 0x4a, 0xe0, 0xd6, 0x85,
-	0x43, 0xaa, 0xb6, 0x1d, 0xc6, 0x28, 0x04, 0x7f, 0x15, 0x91, 0xae, 0x36, 0x0f, 0x7c, 0x37, 0xe6,
+	0x02, 0x3d, 0xee, 0x7a, 0x28, 0xd5, 0xb6, 0xc3, 0x18, 0x8d, 0xe0, 0xaf, 0x12, 0xd2, 0x8f, 0xcd,
-	0xae, 0xdb, 0x75, 0x1b, 0x9d, 0x58, 0xd0, 0x48, 0x29, 0xa8, 0x84, 0x44, 0xb7, 0xfe, 0x96, 0x85,
+	0x03, 0xdf, 0x8d, 0xb9, 0xeb, 0x76, 0xdd, 0x46, 0x27, 0x16, 0x32, 0xd2, 0x0a, 0x1e, 0x42, 0xb2,
-	0x65, 0xca, 0xe2, 0x9e, 0xc7, 0xc9, 0x1a, 0x94, 0x23, 0xd6, 0xd9, 0x61, 0x61, 0xc4, 0xda, 0x36,
+	0x5b, 0x7f, 0xcb, 0xc2, 0x32, 0x65, 0x71, 0xcf, 0xe3, 0x64, 0x0d, 0xca, 0x11, 0xeb, 0xec, 0xb0,
-	0x67, 0x4e, 0xcd, 0x58, 0x35, 0xd6, 0x0b, 0xfb, 0x0b, 0x74, 0x18, 0x4c, 0x7e, 0x04, 0x95, 0x88,
+	0x30, 0x62, 0x6d, 0x9b, 0x33, 0xa7, 0x66, 0xac, 0x1a, 0xeb, 0x85, 0xfd, 0x05, 0x3a, 0x4c, 0x26,
-	0x75, 0x62, 0x0d, 0x71, 0x71, 0xd5, 0x58, 0x2f, 0x36, 0x3f, 0xac, 0x5f, 0xe8, 0x8c, 0x3a, 0x65,
+	0x3f, 0x82, 0x4a, 0xc4, 0x3a, 0xb1, 0xc6, 0xb8, 0xb8, 0x6a, 0xac, 0x17, 0x9b, 0x1f, 0xd6, 0x2f,
-	0x9d, 0x23, 0x3b, 0x1c, 0x90, 0xec, 0x2f, 0xd0, 0x11, 0x26, 0xa4, 0x09, 0x99, 0x88, 0x75, 0x6a,
+	0x0c, 0x46, 0x9d, 0xb2, 0xce, 0x91, 0x1d, 0x0e, 0x44, 0xf6, 0x17, 0xe8, 0x88, 0x12, 0xd2, 0x84,
-	0x19, 0xc1, 0xeb, 0x4a, 0x3a, 0xaf, 0xfd, 0x05, 0x8a, 0xc8, 0x64, 0x13, 0xb2, 0xc8, 0xa5, 0x96,
+	0x4c, 0xc4, 0x3a, 0xb5, 0x8c, 0xd0, 0x75, 0x25, 0x5d, 0xd7, 0xfe, 0x02, 0x45, 0x66, 0xb2, 0x09,
-	0x15, 0x44, 0x57, 0xa7, 0x5e, 0x60, 0x7f, 0x81, 0x0a, 0x02, 0xf2, 0x10, 0xf2, 0xa7, 0x8c, 0xdb,
+	0x59, 0xd4, 0x52, 0xcb, 0x0a, 0xa1, 0xab, 0x53, 0x37, 0xb0, 0xbf, 0x40, 0x85, 0x00, 0x79, 0x08,
-	0x8e, 0xcd, 0xed, 0x1a, 0xac, 0x66, 0xd6, 0x8b, 0xcd, 0x46, 0x2a, 0x31, 0x1a, 0xa8, 0x7e, 0xa4,
+	0xf9, 0x53, 0xc6, 0x6d, 0xc7, 0xe6, 0x76, 0x0d, 0x56, 0x33, 0xeb, 0xc5, 0x66, 0x23, 0x55, 0x18,
-	0x28, 0x76, 0x7d, 0x1e, 0x9d, 0xd3, 0x3e, 0x03, 0xf2, 0x14, 0x4a, 0x36, 0xe7, 0x0c, 0xad, 0xea,
+	0x1d, 0x54, 0x3f, 0x52, 0x12, 0xbb, 0x3e, 0x8f, 0xce, 0x69, 0x5f, 0x01, 0x79, 0x0a, 0x25, 0x9b,
-	0x06, 0x7e, 0x5c, 0x2b, 0x0a, 0x86, 0xb7, 0xa6, 0x33, 0x7c, 0xa0, 0x51, 0x49, 0xa6, 0x43, 0x8c,
+	0x73, 0x86, 0x5e, 0x75, 0x03, 0x3f, 0xae, 0x95, 0x84, 0xc2, 0x5b, 0xd3, 0x15, 0x3e, 0xd0, 0xa4,
-	0xcc, 0x7b, 0x50, 0x1e, 0x92, 0x49, 0xaa, 0x90, 0x79, 0xce, 0xce, 0xa5, 0x63, 0x28, 0x2e, 0xc9,
+	0xa4, 0xd2, 0x21, 0x45, 0xe6, 0x3d, 0x28, 0x0f, 0xd9, 0x24, 0x55, 0xc8, 0x3c, 0x67, 0xe7, 0x32,
-	0x65, 0x58, 0x7a, 0x61, 0x7b, 0x3d, 0x26, 0x7c, 0x50, 0xa2, 0x72, 0x73, 0x77, 0xf1, 0x8e, 0x61,
+	0x30, 0x14, 0x87, 0xe4, 0x32, 0x2c, 0xbd, 0xb0, 0xbd, 0x1e, 0x13, 0x31, 0x28, 0x51, 0x39, 0xb9,
-	0x3e, 0x83, 0x4b, 0x63, 0xfc, 0x27, 0x30, 0xf8, 0x81, 0xce, 0xa0, 0xd8, 0xfc, 0x20, 0xe5, 0xd6,
+	0xbb, 0x78, 0xc7, 0x30, 0x9f, 0xc1, 0xa5, 0x31, 0xfd, 0x13, 0x14, 0xfc, 0x40, 0x57, 0x50, 0x6c,
-	0x3a, 0x3b, 0x4d, 0xd2, 0x56, 0x1e, 0x96, 0x23, 0xa1, 0x90, 0xf5, 0x1b, 0x03, 0xaa, 0xa3, 0xae,
+	0x7e, 0x90, 0xb2, 0x6b, 0x5d, 0x9d, 0x66, 0x69, 0x2b, 0x0f, 0xcb, 0x91, 0x38, 0x90, 0xf5, 0x1b,
-	0x26, 0x07, 0xca, 0x49, 0x86, 0x30, 0xcb, 0xc7, 0x73, 0x44, 0x09, 0x02, 0x94, 0x61, 0x04, 0x0b,
+	0x03, 0xaa, 0xa3, 0xa1, 0x26, 0x07, 0x2a, 0x48, 0x86, 0x70, 0xcb, 0xc7, 0x73, 0xdc, 0x12, 0x24,
-	0x73, 0x13, 0x0a, 0x7d, 0xd0, 0x34, 0x63, 0x14, 0xb4, 0x2b, 0x5a, 0x9b, 0x90, 0xa1, 0xac, 0x43,
+	0x28, 0xc7, 0x08, 0x15, 0xe6, 0x26, 0x14, 0xfa, 0xa4, 0x69, 0xce, 0x28, 0x68, 0x5b, 0xb4, 0x36,
-	0x2a, 0xb0, 0xe8, 0xaa, 0xb8, 0xa6, 0x8b, 0xae, 0x43, 0x56, 0x21, 0xe3, 0xb0, 0x8e, 0x52, 0xbd,
+	0x21, 0x43, 0x59, 0x87, 0x54, 0x60, 0xd1, 0x55, 0xf7, 0x9a, 0x2e, 0xba, 0x0e, 0x59, 0x85, 0x8c,
-	0x52, 0x0f, 0x4f, 0xea, 0x3b, 0xac, 0xe3, 0xfa, 0x2e, 0xaa, 0x48, 0xf1, 0xc8, 0xfa, 0x9d, 0x81,
+	0xc3, 0x3a, 0xea, 0xe8, 0x95, 0x7a, 0x78, 0x52, 0xdf, 0x61, 0x1d, 0xd7, 0x77, 0xf1, 0x88, 0x14,
-	0xf9, 0x81, 0xd7, 0x22, 0x9f, 0x0c, 0xe9, 0x31, 0x3d, 0xda, 0xc7, 0x6e, 0xff, 0x34, 0xfd, 0xf6,
+	0x97, 0xac, 0xdf, 0x19, 0x98, 0x1f, 0xb8, 0x2d, 0xf2, 0xc9, 0xd0, 0x39, 0xa6, 0xdf, 0xf6, 0xb1,
-	0xb7, 0x87, 0x3d, 0x31, 0x25, 0x05, 0x74, 0xed, 0x7e, 0x0c, 0x25, 0xdd, 0x37, 0x64, 0x1f, 0x8a,
+	0xdd, 0x3f, 0x4d, 0xdf, 0xfd, 0xed, 0xe1, 0x48, 0x4c, 0x49, 0x01, 0xfd, 0x74, 0x3f, 0x86, 0x92,
-	0x5a, 0x1c, 0xa9, 0x0b, 0xaf, 0xcd, 0xe6, 0x59, 0xaa, 0x93, 0x5a, 0x7f, 0xc8, 0x40, 0x51, 0x3b,
+	0x1e, 0x1b, 0xb2, 0x0f, 0x45, 0xed, 0x1e, 0xa9, 0x0d, 0xaf, 0xcd, 0x16, 0x59, 0xaa, 0x8b, 0x5a,
-	0x24, 0xf7, 0x21, 0xfb, 0xdc, 0xf5, 0xa5, 0x09, 0x2b, 0xcd, 0x8d, 0xd9, 0x58, 0x3e, 0x74, 0x7d,
+	0x7f, 0xc8, 0x40, 0x51, 0x5b, 0x24, 0xf7, 0x21, 0xfb, 0xdc, 0xf5, 0xa5, 0x0b, 0x2b, 0xcd, 0x8d,
-	0x87, 0x0a, 0x3a, 0xd2, 0xd2, 0xf2, 0x6e, 0x51, 0x5c, 0xeb, 0xf6, 0x6c, 0x3c, 0x2e, 0x4c, 0xbe,
+	0xd9, 0x54, 0x3e, 0x74, 0x7d, 0x87, 0x0a, 0x39, 0xd2, 0xd2, 0xf2, 0x6e, 0x51, 0x6c, 0xeb, 0xf6,
-	0x9b, 0x73, 0x94, 0x0d, 0x59, 0x34, 0x08, 0x64, 0x43, 0x9b, 0x3f, 0x13, 0x45, 0xa3, 0x40, 0xc5,
+	0x6c, 0x3a, 0x2e, 0x4c, 0xbe, 0x9b, 0x73, 0x94, 0x0d, 0x59, 0x34, 0x08, 0x64, 0x43, 0x9b, 0x3f,
-	0x9a, 0xdc, 0x84, 0x37, 0x5c, 0xff, 0x49, 0xc0, 0x83, 0x56, 0xc4, 0x1c, 0x17, 0x83, 0xef, 0xc9,
+	0x13, 0x45, 0xa3, 0x40, 0xc5, 0x98, 0xdc, 0x84, 0x37, 0x5c, 0xff, 0x49, 0xc0, 0x83, 0x56, 0xc4,
-	0x79, 0xc8, 0x6a, 0x4b, 0x02, 0x65, 0xd2, 0x11, 0x69, 0x41, 0x45, 0x82, 0x8f, 0x7b, 0x27, 0x3f,
+	0x1c, 0x17, 0x2f, 0xdf, 0x93, 0xf3, 0x90, 0xd5, 0x96, 0x04, 0xcb, 0xa4, 0x25, 0xd2, 0x82, 0x8a,
-	0x63, 0x6d, 0x1e, 0xd7, 0x96, 0x85, 0x3e, 0xeb, 0x29, 0x57, 0x38, 0xd0, 0x09, 0xe8, 0x08, 0xfd,
+	0x24, 0x1f, 0xf7, 0x4e, 0x7e, 0xc6, 0xda, 0x3c, 0xae, 0x2d, 0x8b, 0xf3, 0xac, 0xa7, 0x6c, 0xe1,
-	0x6b, 0x65, 0xbb, 0xf5, 0x27, 0x03, 0xca, 0x43, 0xec, 0xc9, 0xa7, 0x43, 0xae, 0xba, 0x31, 0xeb,
+	0x40, 0x17, 0xa0, 0x23, 0xf2, 0xaf, 0x95, 0xed, 0xd6, 0x9f, 0x0c, 0x28, 0x0f, 0xa9, 0x27, 0x9f,
-	0xb5, 0x34, 0x67, 0x7d, 0x06, 0xcb, 0x8e, 0xdb, 0x65, 0x31, 0x17, 0xae, 0x2a, 0x6c, 0x35, 0xbf,
+	0x0e, 0x85, 0xea, 0xc6, 0xac, 0xdb, 0xd2, 0x82, 0xf5, 0x19, 0x2c, 0x3b, 0x6e, 0x97, 0xc5, 0x5c,
-	0xfd, 0xee, 0xdd, 0x85, 0x7f, 0x7e, 0xf7, 0xee, 0x86, 0xd6, 0x62, 0x82, 0x90, 0xf9, 0xed, 0xc0,
+	0x84, 0xaa, 0xb0, 0xd5, 0xfc, 0xf6, 0xbb, 0x77, 0x17, 0xfe, 0xf9, 0xdd, 0xbb, 0x1b, 0x5a, 0x8b,
-	0xe7, 0xb6, 0xeb, 0xb3, 0x08, 0x3b, 0xe5, 0x47, 0x92, 0xa4, 0xbe, 0x23, 0x7e, 0xa8, 0xe2, 0x80,
+	0x09, 0x42, 0xe6, 0xb7, 0x03, 0x9f, 0xdb, 0xae, 0xcf, 0x22, 0xec, 0x94, 0x1f, 0x49, 0x91, 0xfa,
-	0x46, 0xf7, 0xed, 0x53, 0x26, 0xfc, 0x54, 0xa0, 0x62, 0x6d, 0x71, 0x28, 0x53, 0xc6, 0x7b, 0x91,
+	0x8e, 0xf8, 0xa1, 0x4a, 0x03, 0x3a, 0xdd, 0xb7, 0x4f, 0x99, 0x88, 0x53, 0x81, 0x8a, 0xb1, 0xc5,
-	0x4f, 0xd9, 0xcf, 0x7b, 0x88, 0xf4, 0xbd, 0xa4, 0x90, 0x88, 0x4b, 0x4f, 0x2b, 0xe8, 0x88, 0x48,
+	0xa1, 0x4c, 0x19, 0xef, 0x45, 0x3e, 0x65, 0x3f, 0xef, 0x21, 0xd3, 0xf7, 0x92, 0x42, 0x22, 0x36,
-	0x15, 0x01, 0x59, 0x87, 0x25, 0x16, 0x45, 0x41, 0xa4, 0x92, 0x87, 0xd4, 0x65, 0xcf, 0xae, 0x47,
+	0x3d, 0xad, 0xa0, 0x23, 0x23, 0x55, 0x02, 0x64, 0x1d, 0x96, 0x58, 0x14, 0x05, 0x91, 0x4a, 0x1e,
-	0x61, 0xbb, 0x7e, 0x2c, 0x7a, 0x36, 0x95, 0x08, 0x56, 0x15, 0x2a, 0x89, 0xd4, 0x38, 0x0c, 0xfc,
+	0x52, 0x97, 0x3d, 0xbb, 0x1e, 0x85, 0xed, 0xfa, 0xb1, 0xe8, 0xd9, 0x54, 0x32, 0x58, 0x55, 0xa8,
-	0x98, 0x59, 0x2b, 0x68, 0xba, 0xb0, 0xc7, 0x63, 0x75, 0x0f, 0xeb, 0xaf, 0x06, 0x54, 0x12, 0x88,
+	0x24, 0x56, 0xe3, 0x30, 0xf0, 0x63, 0x66, 0xad, 0xa0, 0xeb, 0xc2, 0x1e, 0x8f, 0xd5, 0x3e, 0xac,
-	0xc4, 0x21, 0x5f, 0x40, 0x71, 0x50, 0x1a, 0x92, 0x1a, 0x70, 0x37, 0xd5, 0xa8, 0x3a, 0xbd, 0x56,
+	0xbf, 0x1a, 0x50, 0x49, 0x28, 0x92, 0x87, 0x7c, 0x01, 0xc5, 0x41, 0x69, 0x48, 0x6a, 0xc0, 0xdd,
-	0x57, 0x54, 0x49, 0xd0, 0xd9, 0x99, 0x8f, 0xa0, 0x3a, 0x8a, 0x30, 0xc1, 0xfb, 0xef, 0x0d, 0x17,
+	0x54, 0xa7, 0xea, 0xf2, 0x5a, 0x5d, 0x51, 0x25, 0x41, 0x57, 0x67, 0x3e, 0x82, 0xea, 0x28, 0xc3,
-	0x88, 0xd1, 0x7a, 0xa5, 0x45, 0xc3, 0x3f, 0x0c, 0x78, 0x9b, 0x32, 0x31, 0x84, 0x1c, 0x9c, 0xda,
+	0x84, 0xe8, 0xbf, 0x37, 0x5c, 0x20, 0x46, 0xeb, 0x95, 0x76, 0x1b, 0xfe, 0x61, 0xc0, 0xdb, 0x94,
-	0x5d, 0xb6, 0x1d, 0xf8, 0x1d, 0xb7, 0x9b, 0x98, 0xb9, 0x2a, 0x8a, 0x61, 0xc2, 0x19, 0xeb, 0xe2,
+	0x09, 0x10, 0x72, 0x70, 0x6a, 0x77, 0xd9, 0x76, 0xe0, 0x77, 0xdc, 0x6e, 0xe2, 0xe6, 0xaa, 0x28,
-	0x3a, 0xe4, 0x5b, 0x9e, 0xcd, 0x3b, 0x41, 0x74, 0xaa, 0x98, 0x97, 0x90, 0x79, 0x02, 0xa3, 0xfd,
+	0x86, 0x89, 0x66, 0xac, 0x8b, 0xeb, 0x90, 0x6f, 0x79, 0x36, 0xef, 0x04, 0xd1, 0xa9, 0x52, 0x5e,
-	0x53, 0xb2, 0x0a, 0x45, 0xc5, 0xf8, 0x28, 0x70, 0x12, 0x77, 0xea, 0x20, 0x52, 0x83, 0xdc, 0x61,
+	0x42, 0xe5, 0x09, 0x8d, 0xf6, 0x57, 0xc9, 0x2a, 0x14, 0x95, 0xe2, 0xa3, 0xc0, 0x49, 0xc2, 0xa9,
-	0xd0, 0x7d, 0x84, 0xce, 0x96, 0x19, 0x96, 0x6c, 0x89, 0x05, 0x25, 0x85, 0x18, 0xf5, 0xb3, 0x6b,
+	0x93, 0x48, 0x0d, 0x72, 0x87, 0x41, 0xf7, 0x11, 0x06, 0x5b, 0x66, 0x58, 0x32, 0x25, 0x16, 0x94,
-	0x89, 0x0e, 0xc1, 0xc8, 0x3b, 0x50, 0x38, 0x66, 0x71, 0xec, 0x06, 0xfe, 0xc1, 0x4e, 0x6d, 0x59,
+	0x14, 0x63, 0xd4, 0xcf, 0xae, 0x25, 0x3a, 0x44, 0x23, 0xef, 0x40, 0xe1, 0x98, 0xc5, 0xb1, 0x1b,
-	0xd0, 0x0f, 0x00, 0xd6, 0x2f, 0x0c, 0x30, 0x27, 0xe9, 0xa5, 0x9c, 0xf4, 0x19, 0x2c, 0xcb, 0xb0,
+	0xf8, 0x07, 0x3b, 0xb5, 0x65, 0x21, 0x3f, 0x20, 0x58, 0xbf, 0x30, 0xc0, 0x9c, 0x74, 0x2e, 0x15,
-	0x93, 0xba, 0xfd, 0x6f, 0x01, 0x2b, 0x7f, 0xc9, 0x5b, 0xb0, 0x2c, 0xb9, 0xab, 0x5c, 0x53, 0x3b,
+	0xa4, 0xcf, 0x60, 0x59, 0x5e, 0x3b, 0x79, 0xb6, 0xff, 0xed, 0xc2, 0xca, 0x5f, 0xf2, 0x16, 0x2c,
-	0xeb, 0xcf, 0x4b, 0x50, 0x3a, 0xc6, 0x0b, 0x24, 0xd6, 0xac, 0x03, 0x0c, 0x9c, 0xa0, 0x02, 0x77,
+	0x4b, 0xed, 0x2a, 0xd7, 0xd4, 0xcc, 0xfa, 0xf3, 0x12, 0x94, 0x8e, 0x71, 0x03, 0x89, 0x37, 0xeb,
-	0xd4, 0x35, 0x1a, 0x06, 0x31, 0x21, 0xbf, 0xa7, 0x82, 0x44, 0xf5, 0xa9, 0xfe, 0x9e, 0x7c, 0x0e,
+	0x00, 0x83, 0x20, 0xa8, 0x8b, 0x3b, 0x1a, 0x1a, 0x8d, 0x83, 0x98, 0x90, 0xdf, 0x53, 0x97, 0x44,
-	0xc5, 0x64, 0xfd, 0x38, 0xe4, 0xb5, 0x8c, 0x88, 0xb2, 0x3b, 0x29, 0x51, 0xa6, 0xdf, 0xa4, 0xae,
+	0xf5, 0xa9, 0xfe, 0x9c, 0x7c, 0x0e, 0xc5, 0x64, 0xfc, 0x38, 0xe4, 0xb5, 0x8c, 0xb8, 0x65, 0x77,
-	0x91, 0xaa, 0x18, 0xd3, 0x20, 0xe4, 0x06, 0x5c, 0xb2, 0x3d, 0x2f, 0x38, 0x53, 0x89, 0x23, 0x52,
+	0x52, 0x6e, 0x99, 0xbe, 0x93, 0xba, 0x26, 0xaa, 0xee, 0x98, 0x46, 0x21, 0x37, 0xe0, 0x92, 0xed,
-	0x40, 0xb8, 0x20, 0x4f, 0xc7, 0x0f, 0xb0, 0x20, 0x6a, 0xc0, 0x07, 0x51, 0x64, 0x9f, 0x63, 0xcc,
+	0x79, 0xc1, 0x99, 0x4a, 0x1c, 0x91, 0x02, 0x22, 0x04, 0x79, 0x3a, 0xbe, 0x80, 0x05, 0x51, 0x23,
-	0x2c, 0x0b, 0xfc, 0x49, 0x47, 0x58, 0x9b, 0xf6, 0x5c, 0xdf, 0xf6, 0x6a, 0x20, 0x70, 0xe4, 0x06,
+	0x3e, 0x88, 0x22, 0xfb, 0x1c, 0xef, 0xcc, 0xb2, 0xe0, 0x9f, 0xb4, 0x84, 0xb5, 0x69, 0xcf, 0xf5,
-	0x7d, 0xbe, 0xfb, 0x32, 0x0c, 0x22, 0xce, 0xa2, 0x07, 0x9c, 0x47, 0xb5, 0xa2, 0x30, 0xe6, 0x10,
+	0x6d, 0xaf, 0x06, 0x82, 0x47, 0x4e, 0x30, 0xe6, 0xbb, 0x2f, 0xc3, 0x20, 0xe2, 0x2c, 0x7a, 0xc0,
-	0x8c, 0xb4, 0xa0, 0xb4, 0x6d, 0xb7, 0x9f, 0xb1, 0x83, 0x53, 0x04, 0xc6, 0xb5, 0x92, 0x50, 0x3b,
+	0x79, 0x54, 0x2b, 0x0a, 0x67, 0x0e, 0xd1, 0x48, 0x0b, 0x4a, 0xdb, 0x76, 0xfb, 0x19, 0x3b, 0x38,
-	0xad, 0x62, 0x09, 0xf4, 0xc7, 0xa1, 0x3e, 0x38, 0xe9, 0x1c, 0x48, 0x1b, 0x2a, 0x89, 0xea, 0x32,
+	0x45, 0x62, 0x82, 0x9f, 0xd2, 0x2a, 0x96, 0x60, 0x7f, 0x1c, 0xea, 0xc0, 0x49, 0xd7, 0x40, 0xda,
-	0x0f, 0x6b, 0x65, 0xc1, 0xf3, 0xde, 0xbc, 0xa6, 0x94, 0xd4, 0x52, 0xc4, 0x08, 0x4b, 0x74, 0xe4,
+	0x50, 0x49, 0x8e, 0x2e, 0xf3, 0xb0, 0x56, 0x16, 0x3a, 0xef, 0xcd, 0xeb, 0x4a, 0x29, 0x2d, 0x4d,
-	0x2e, 0xa6, 0x9c, 0xcd, 0x59, 0xad, 0x22, 0x74, 0xee, 0xef, 0xcd, 0xfb, 0x50, 0x1d, 0xf5, 0xc6,
+	0x8c, 0xa8, 0xc4, 0x40, 0xee, 0x62, 0xca, 0xd9, 0x9c, 0xd5, 0x2a, 0xe2, 0xcc, 0xfd, 0xb9, 0x79,
-	0x3c, 0xf3, 0x8a, 0xf9, 0x43, 0x78, 0x63, 0xc2, 0x15, 0x5e, 0xab, 0x26, 0xfc, 0xd1, 0x80, 0x4b,
+	0x1f, 0xaa, 0xa3, 0xd1, 0x98, 0x07, 0xaf, 0x98, 0x3f, 0x84, 0x37, 0x26, 0x6c, 0xe1, 0xb5, 0x6a,
-	0x63, 0x76, 0xc3, 0xba, 0x2c, 0x72, 0x51, 0xb2, 0x14, 0x6b, 0x72, 0x04, 0x4b, 0xe8, 0x97, 0x58,
+	0xc2, 0x1f, 0x0d, 0xb8, 0x34, 0xe6, 0x37, 0xac, 0xcb, 0x22, 0x17, 0xa5, 0x4a, 0x31, 0x26, 0x47,
-	0x75, 0xe8, 0xcd, 0x79, 0x1c, 0x51, 0x17, 0x94, 0xd2, 0x60, 0x92, 0x8b, 0x79, 0x07, 0x60, 0x00,
+	0xb0, 0x84, 0x71, 0x89, 0x55, 0x87, 0xde, 0x9c, 0x27, 0x10, 0x75, 0x21, 0x29, 0x1d, 0x26, 0xb5,
-	0x9c, 0x6b, 0x6a, 0xfb, 0x02, 0xca, 0xca, 0x2b, 0x2a, 0xc1, 0xab, 0xb2, 0xd9, 0x2b, 0x62, 0x6c,
+	0x98, 0x77, 0x00, 0x06, 0xc4, 0xb9, 0x50, 0xdb, 0x17, 0x50, 0x56, 0x51, 0x51, 0x09, 0x5e, 0x95,
-	0xe6, 0x83, 0x96, 0x91, 0x99, 0xb3, 0x65, 0x58, 0x5f, 0xc1, 0x0a, 0x65, 0xb6, 0xb3, 0xe7, 0x7a,
+	0xcd, 0x5e, 0x09, 0x63, 0x33, 0x1f, 0xb4, 0x8c, 0xcc, 0x9c, 0x2d, 0xc3, 0xfa, 0x0a, 0x56, 0x28,
-	0xec, 0xe2, 0xca, 0x88, 0xd9, 0xea, 0x7a, 0xac, 0x85, 0x03, 0x43, 0x92, 0xad, 0x6a, 0x4f, 0xee,
+	0xb3, 0x9d, 0x3d, 0xd7, 0x63, 0x17, 0x57, 0x46, 0xcc, 0x56, 0xd7, 0x63, 0x2d, 0x04, 0x0c, 0x49,
-	0xc2, 0x12, 0xb5, 0xfd, 0x2e, 0x53, 0xa2, 0xdf, 0x4b, 0x11, 0x2d, 0x84, 0x20, 0x2e, 0x95, 0x24,
+	0xb6, 0xaa, 0x39, 0xb9, 0x0b, 0x4b, 0xd4, 0xf6, 0xbb, 0x4c, 0x99, 0x7e, 0x2f, 0xc5, 0xb4, 0x30,
-	0xd6, 0x3d, 0x28, 0xf4, 0x61, 0x58, 0x6b, 0x1e, 0x77, 0x3a, 0x31, 0x93, 0x75, 0x2b, 0x43, 0xd5,
+	0x82, 0xbc, 0x54, 0x8a, 0x58, 0xf7, 0xa0, 0xd0, 0xa7, 0x61, 0xad, 0x79, 0xdc, 0xe9, 0xc4, 0x4c,
-	0x0e, 0xe1, 0x87, 0xcc, 0xef, 0x2a, 0xd1, 0x19, 0xaa, 0x76, 0xd6, 0x1a, 0x4e, 0xd9, 0xc9, 0xcd,
+	0xd6, 0xad, 0x0c, 0x55, 0x33, 0xa4, 0x1f, 0x32, 0xbf, 0xab, 0x4c, 0x67, 0xa8, 0x9a, 0x59, 0x6b,
-	0x95, 0x69, 0x08, 0x64, 0x77, 0x70, 0xaa, 0x32, 0x44, 0x82, 0x89, 0xb5, 0xe5, 0x60, 0xab, 0xb3,
+	0x88, 0xb2, 0x93, 0x9d, 0x2b, 0xd7, 0x10, 0xc8, 0xee, 0x20, 0xaa, 0x32, 0x44, 0x82, 0x89, 0xb1,
-	0x9d, 0x1d, 0x37, 0xba, 0x58, 0xc1, 0x1a, 0xe4, 0x76, 0xdc, 0x48, 0xd3, 0x2f, 0xd9, 0x92, 0x35,
+	0xe5, 0x60, 0xab, 0xb3, 0x9d, 0x1d, 0x37, 0xba, 0xf8, 0x80, 0x35, 0xc8, 0xed, 0xb8, 0x91, 0x76,
-	0x6c, 0x82, 0x6d, 0xaf, 0xe7, 0xa0, 0xb6, 0x9c, 0x45, 0xbe, 0xaa, 0xf6, 0x23, 0x50, 0xeb, 0x13,
+	0xbe, 0x64, 0x4a, 0xd6, 0xb0, 0x09, 0xb6, 0xbd, 0x9e, 0x83, 0xa7, 0xe5, 0x2c, 0xf2, 0x55, 0xb5,
-	0x69, 0x47, 0x21, 0x45, 0x5d, 0xe6, 0x06, 0xe4, 0x98, 0xcf, 0x23, 0x97, 0x25, 0x9d, 0x92, 0xd4,
+	0x1f, 0xa1, 0x5a, 0x9f, 0x48, 0x3f, 0x0a, 0x2b, 0x6a, 0x33, 0x37, 0x20, 0xc7, 0x7c, 0x1e, 0xb9,
-	0xe5, 0x03, 0xb4, 0x2e, 0x1e, 0xa0, 0xa2, 0x23, 0xd3, 0x04, 0xc5, 0xda, 0x84, 0x15, 0x04, 0xa4,
+	0x2c, 0xe9, 0x94, 0xa4, 0x2e, 0x1f, 0xa0, 0x75, 0xf1, 0x00, 0x15, 0x1d, 0x99, 0x26, 0x2c, 0xd6,
-	0x3b, 0x82, 0x40, 0x56, 0xbb, 0xa4, 0x58, 0x5b, 0x77, 0xa1, 0x3a, 0x20, 0x54, 0xa2, 0xd7, 0x20,
+	0x26, 0xac, 0x20, 0x21, 0x3d, 0x10, 0x04, 0xb2, 0xda, 0x26, 0xc5, 0xd8, 0xba, 0x0b, 0xd5, 0x81,
-	0x8b, 0x23, 0xa3, 0x2a, 0xc4, 0x93, 0xe4, 0x8a, 0x73, 0xeb, 0x1a, 0xac, 0x24, 0xd9, 0x7a, 0xa1,
+	0xa0, 0x32, 0xbd, 0x06, 0x59, 0x84, 0x8c, 0xaa, 0x10, 0x4f, 0xb2, 0x2b, 0xd6, 0xad, 0x6b, 0xb0,
-	0x50, 0x8b, 0x40, 0x75, 0x80, 0xa4, 0xa6, 0x85, 0x32, 0x14, 0x5b, 0xae, 0x9f, 0x34, 0x53, 0xeb,
+	0x92, 0x64, 0xeb, 0x85, 0x46, 0x2d, 0x02, 0xd5, 0x01, 0x93, 0x42, 0x0b, 0x65, 0x28, 0xb6, 0x5c,
-	0x95, 0x01, 0xa5, 0x56, 0xe0, 0x0f, 0x9a, 0x50, 0x0b, 0x56, 0x92, 0xd4, 0x7d, 0xd0, 0x3a, 0xd8,
+	0x3f, 0x69, 0xa6, 0xd6, 0x2b, 0x03, 0x4a, 0xad, 0xc0, 0x1f, 0x34, 0xa1, 0x16, 0xac, 0x24, 0xa9,
-	0xb6, 0xc3, 0xc4, 0x06, 0xab, 0xe3, 0xf1, 0xa1, 0x9e, 0xf0, 0x75, 0x89, 0xb8, 0x95, 0xc5, 0x7e,
+	0xfb, 0xa0, 0x75, 0xb0, 0x6d, 0x87, 0x89, 0x0f, 0x56, 0xc7, 0xef, 0x87, 0x7a, 0xc2, 0xd7, 0x25,
-	0x45, 0x47, 0xc9, 0xc9, 0xa7, 0x90, 0x3b, 0x3c, 0xdc, 0x12, 0x9c, 0x16, 0xe7, 0xe2, 0x94, 0x90,
+	0xe3, 0x56, 0x16, 0xfb, 0x15, 0x1d, 0x15, 0x27, 0x9f, 0x42, 0xee, 0xf0, 0x70, 0x4b, 0x68, 0x5a,
-	0x91, 0xfb, 0x90, 0x7b, 0x2a, 0xbe, 0x2c, 0xc4, 0xaa, 0xa7, 0x4c, 0x88, 0x55, 0x69, 0x21, 0x89,
+	0x9c, 0x4b, 0x53, 0x22, 0x46, 0xee, 0x43, 0xee, 0xa9, 0xf8, 0xb2, 0x10, 0xab, 0x9e, 0x32, 0xe1,
-	0x46, 0x59, 0x3b, 0x88, 0x1c, 0x9a, 0x10, 0x59, 0xff, 0x36, 0xa0, 0xf8, 0xd4, 0x1e, 0x0c, 0x6a,
+	0xae, 0x4a, 0x0f, 0x49, 0x36, 0xca, 0xda, 0x41, 0xe4, 0xd0, 0x44, 0xc8, 0xfa, 0xb7, 0x01, 0xc5,
-	0x83, 0xc9, 0xf0, 0x35, 0x1a, 0xad, 0x9a, 0x0c, 0x2f, 0xc3, 0x92, 0xc7, 0x5e, 0x30, 0x4f, 0xc5,
+	0xa7, 0xf6, 0x00, 0xa8, 0x0d, 0x90, 0xe1, 0x6b, 0x34, 0x5a, 0x85, 0x0c, 0x2f, 0xc3, 0x92, 0xc7,
-	0xb8, 0xdc, 0x20, 0x34, 0x7e, 0x16, 0x44, 0x32, 0xad, 0x4b, 0x54, 0x6e, 0x30, 0x21, 0x1c, 0xc6,
+	0x5e, 0x30, 0x4f, 0xdd, 0x71, 0x39, 0x41, 0x6a, 0xfc, 0x2c, 0x88, 0x64, 0x5a, 0x97, 0xa8, 0x9c,
-	0x6d, 0xd7, 0xab, 0x65, 0x57, 0x33, 0xd8, 0x94, 0xe5, 0x0e, 0x3d, 0xd7, 0x8b, 0x3c, 0x35, 0xae,
+	0x60, 0x42, 0x38, 0x8c, 0xdb, 0xae, 0x57, 0xcb, 0xae, 0x66, 0xb0, 0x29, 0xcb, 0x19, 0x46, 0xae,
-	0xe3, 0x92, 0x58, 0x90, 0x75, 0xfd, 0x4e, 0x20, 0x1a, 0x96, 0x2a, 0x8b, 0xc7, 0x41, 0x2f, 0x6a,
+	0x17, 0x79, 0x0a, 0xae, 0xe3, 0x90, 0x58, 0x90, 0x75, 0xfd, 0x4e, 0x20, 0x1a, 0x96, 0x2a, 0x8b,
-	0xb3, 0x03, 0xbf, 0x13, 0x50, 0x71, 0x46, 0xae, 0xc2, 0x72, 0x84, 0xf9, 0x17, 0xd7, 0x72, 0xc2,
+	0xc7, 0x41, 0x2f, 0x6a, 0xb3, 0x03, 0xbf, 0x13, 0x50, 0xb1, 0x46, 0xae, 0xc2, 0x72, 0x84, 0xf9,
-	0x28, 0x05, 0xc4, 0x92, 0x59, 0xaa, 0x0e, 0xac, 0x0a, 0x94, 0xa4, 0xde, 0xca, 0xf9, 0xbf, 0x5e,
+	0x17, 0xd7, 0x72, 0xc2, 0x29, 0x05, 0xe4, 0x92, 0x59, 0xaa, 0x16, 0xac, 0x0a, 0x94, 0xe4, 0xb9,
-	0x84, 0x37, 0x1e, 0xb1, 0xb3, 0xed, 0x44, 0xaf, 0xc4, 0x20, 0xab, 0x50, 0xec, 0xc3, 0x0e, 0x76,
+	0x55, 0xf0, 0x7f, 0xbd, 0x08, 0x6f, 0x3c, 0x62, 0x67, 0xdb, 0xc9, 0xb9, 0x12, 0x87, 0xac, 0x42,
-	0x54, 0x08, 0xe9, 0x20, 0x14, 0x76, 0x14, 0xf4, 0x7c, 0x9e, 0xf8, 0x50, 0x08, 0x13, 0x10, 0xaa,
+	0xb1, 0x4f, 0x3b, 0xd8, 0x51, 0x57, 0x48, 0x27, 0xa1, 0xb1, 0xa3, 0xa0, 0xe7, 0xf3, 0x24, 0x86,
-	0x0e, 0xc8, 0xfb, 0x90, 0x7b, 0xc4, 0xf8, 0x59, 0x10, 0x3d, 0x17, 0x5a, 0x57, 0x9a, 0x45, 0xc4,
+	0xc2, 0x98, 0xa0, 0x50, 0xb5, 0x40, 0xde, 0x87, 0xdc, 0x23, 0xc6, 0xcf, 0x82, 0xe8, 0xb9, 0x38,
-	0x79, 0xc4, 0x38, 0xce, 0x55, 0x34, 0x39, 0xc3, 0x61, 0x2d, 0x4c, 0x86, 0xb5, 0xec, 0xa4, 0x61,
+	0x75, 0xa5, 0x59, 0x44, 0x9e, 0x47, 0x8c, 0x23, 0xae, 0xa2, 0xc9, 0x1a, 0x82, 0xb5, 0x30, 0x01,
-	0x2d, 0x39, 0x25, 0x9b, 0x50, 0x6c, 0x07, 0x7e, 0xcc, 0x23, 0xdb, 0x45, 0xc1, 0x4b, 0x02, 0xf9,
+	0x6b, 0xd9, 0x49, 0x60, 0x2d, 0x59, 0x25, 0x9b, 0x50, 0x6c, 0x07, 0x7e, 0xcc, 0x23, 0xdb, 0x45,
-	0x4d, 0x44, 0x96, 0x8e, 0xdd, 0x1e, 0x1c, 0x52, 0x1d, 0x93, 0x6c, 0x00, 0xb0, 0x97, 0x3c, 0xb2,
+	0xc3, 0x4b, 0x82, 0xf9, 0x4d, 0x64, 0x96, 0x81, 0xdd, 0x1e, 0x2c, 0x52, 0x9d, 0x93, 0x6c, 0x00,
-	0xf7, 0x83, 0xb8, 0xff, 0xb0, 0x01, 0xa4, 0x43, 0xc0, 0x41, 0x8b, 0x6a, 0xa7, 0xd6, 0x5b, 0x70,
+	0xb0, 0x97, 0x3c, 0xb2, 0xf7, 0x83, 0xb8, 0xff, 0xb0, 0x01, 0x94, 0x43, 0xc2, 0x41, 0x8b, 0x6a,
-	0x79, 0xd8, 0x22, 0xca, 0x54, 0xf7, 0xe0, 0xff, 0x28, 0xf3, 0x98, 0x1d, 0xb3, 0xf9, 0xad, 0x65,
+	0xab, 0xd6, 0x5b, 0x70, 0x79, 0xd8, 0x23, 0xca, 0x55, 0xf7, 0xe0, 0xff, 0x28, 0xf3, 0x98, 0x1d,
-	0x99, 0x50, 0x1b, 0x27, 0x56, 0x8c, 0xff, 0x93, 0x81, 0xe2, 0xee, 0x4b, 0xd6, 0x3e, 0x62, 0x71,
+	0xb3, 0xf9, 0xbd, 0x65, 0x99, 0x50, 0x1b, 0x17, 0x56, 0x8a, 0xff, 0x93, 0x81, 0xe2, 0xee, 0x4b,
-	0x6c, 0x77, 0xc5, 0xc8, 0xd8, 0x8a, 0x82, 0x36, 0x8b, 0xe3, 0x3e, 0xaf, 0x01, 0x80, 0x7c, 0x1f,
+	0xd6, 0x3e, 0x62, 0x71, 0x6c, 0x77, 0x05, 0x64, 0x6c, 0x45, 0x41, 0x9b, 0xc5, 0x71, 0x5f, 0xd7,
-	0xb2, 0x07, 0xbe, 0xcb, 0x55, 0x7f, 0x5c, 0x4b, 0x9d, 0xd8, 0x5d, 0xae, 0x78, 0xee, 0x2f, 0x50,
+	0x80, 0x40, 0xbe, 0x0f, 0xd9, 0x03, 0xdf, 0xe5, 0xaa, 0x3f, 0xae, 0xa5, 0x22, 0x76, 0x97, 0x2b,
-	0x41, 0x45, 0xee, 0x42, 0x16, 0xab, 0xcb, 0x2c, 0x15, 0xde, 0xd1, 0x68, 0x91, 0x86, 0x6c, 0x89,
+	0x9d, 0xfb, 0x0b, 0x54, 0x48, 0x91, 0xbb, 0x90, 0xc5, 0xea, 0x32, 0x4b, 0x85, 0x77, 0x34, 0x59,
-	0x2f, 0x6b, 0xee, 0x97, 0x4c, 0x79, 0x69, 0x3d, 0xbd, 0x35, 0xb9, 0x5f, 0xb2, 0x01, 0x07, 0x45,
+	0x94, 0x21, 0x5b, 0xe2, 0xcb, 0x9a, 0xfb, 0x25, 0x53, 0x51, 0x5a, 0x4f, 0x6f, 0x4d, 0xee, 0x97,
-	0x49, 0x76, 0x21, 0x77, 0xcc, 0xed, 0x88, 0x33, 0x47, 0x79, 0xef, 0x7a, 0xda, 0x04, 0x23, 0x31,
+	0x6c, 0xa0, 0x41, 0x49, 0x92, 0x5d, 0xc8, 0x1d, 0x73, 0x3b, 0xe2, 0xcc, 0x51, 0xd1, 0xbb, 0x9e,
-	0x07, 0x5c, 0x12, 0x5a, 0x34, 0xc2, 0xee, 0x4b, 0x97, 0xab, 0x6c, 0x48, 0x33, 0x02, 0xa2, 0x69,
+	0x86, 0x60, 0x24, 0xe7, 0x40, 0x4b, 0x22, 0x8b, 0x4e, 0xd8, 0x7d, 0xe9, 0x72, 0x95, 0x0d, 0x69,
-	0x8a, 0xe0, 0x16, 0xa9, 0x77, 0x02, 0x9f, 0xd5, 0x72, 0x53, 0xa9, 0x11, 0x4d, 0xa3, 0xc6, 0x2d,
+	0x4e, 0x40, 0x36, 0xed, 0x20, 0x38, 0x45, 0xe9, 0x9d, 0xc0, 0x67, 0xb5, 0xdc, 0x54, 0x69, 0x64,
-	0x9a, 0xe1, 0xd8, 0xed, 0xe2, 0x60, 0x98, 0x9f, 0x6a, 0x06, 0x89, 0xa8, 0x99, 0x41, 0x02, 0xb6,
+	0xd3, 0xa4, 0x71, 0x8a, 0x6e, 0x38, 0x76, 0xbb, 0x08, 0x0c, 0xf3, 0x53, 0xdd, 0x20, 0x19, 0x35,
-	0x72, 0xb0, 0x24, 0xc6, 0x20, 0xeb, 0xb7, 0x06, 0x14, 0x35, 0x3f, 0xcd, 0x90, 0x77, 0xef, 0x40,
+	0x37, 0x48, 0xc2, 0x56, 0x0e, 0x96, 0x04, 0x0c, 0xb2, 0x7e, 0x6b, 0x40, 0x51, 0x8b, 0xd3, 0x0c,
-	0x16, 0x5f, 0xd5, 0xca, 0xff, 0x79, 0x91, 0x75, 0x8c, 0xdb, 0x54, 0x40, 0xb1, 0x70, 0xec, 0x39,
+	0x79, 0xf7, 0x0e, 0x64, 0xf1, 0x55, 0xad, 0xe2, 0x9f, 0x17, 0x59, 0xc7, 0xb8, 0x4d, 0x05, 0x15,
-	0xb2, 0x28, 0x96, 0x29, 0x2e, 0x11, 0xf2, 0x84, 0x9f, 0x0b, 0x97, 0xe5, 0x29, 0x2e, 0xc9, 0x0d,
+	0x0b, 0xc7, 0x9e, 0x23, 0x8b, 0x62, 0x99, 0xe2, 0x10, 0x29, 0x4f, 0xf8, 0xb9, 0x08, 0x59, 0x9e,
-	0xc8, 0x1f, 0xb3, 0x76, 0x2f, 0x72, 0xf9, 0xb9, 0x70, 0x42, 0xa5, 0x59, 0x15, 0xe5, 0x44, 0xc1,
+	0xe2, 0x90, 0xdc, 0x80, 0xfc, 0x31, 0x6b, 0xf7, 0x22, 0x97, 0x9f, 0x8b, 0x20, 0x54, 0x9a, 0x55,
-	0x44, 0x72, 0xf6, 0x31, 0xac, 0x87, 0x18, 0x9c, 0x83, 0x0b, 0x12, 0xc8, 0x6e, 0xe3, 0x43, 0x09,
+	0x51, 0x4e, 0x14, 0x4d, 0x24, 0x67, 0x9f, 0xc3, 0x7a, 0x88, 0x97, 0x73, 0xb0, 0x41, 0x02, 0xd9,
-	0x6f, 0x56, 0xa6, 0x62, 0x8d, 0x6f, 0xd5, 0xdd, 0x69, 0x6f, 0xd5, 0xdd, 0xe4, 0xad, 0x3a, 0xec,
+	0x6d, 0x7c, 0x28, 0xe1, 0xce, 0xca, 0x54, 0x8c, 0xf1, 0xad, 0xba, 0x3b, 0xed, 0xad, 0xba, 0x9b,
-	0x54, 0xec, 0x3e, 0x9a, 0x91, 0xad, 0x07, 0x50, 0xe8, 0x07, 0x1e, 0xa9, 0xc0, 0xe2, 0x9e, 0xa3,
+	0xbc, 0x55, 0x87, 0x83, 0x8a, 0xdd, 0x47, 0x73, 0xb2, 0xf5, 0x00, 0x0a, 0xfd, 0x8b, 0x47, 0x2a,
-	0x24, 0x2d, 0xee, 0x39, 0xa8, 0xca, 0xee, 0xe3, 0x3d, 0x21, 0x25, 0x4f, 0x71, 0xd9, 0x1f, 0x12,
+	0xb0, 0xb8, 0xe7, 0x28, 0x4b, 0x8b, 0x7b, 0x0e, 0x1e, 0x65, 0xf7, 0xf1, 0x9e, 0xb0, 0x92, 0xa7,
-	0x32, 0xda, 0x90, 0xb0, 0x89, 0xaf, 0x70, 0x2d, 0xfa, 0x10, 0x89, 0x06, 0x67, 0x71, 0x72, 0x65,
+	0x38, 0xec, 0x83, 0x84, 0x8c, 0x06, 0x12, 0x36, 0xf1, 0x15, 0xae, 0xdd, 0x3e, 0x64, 0xa2, 0xc1,
-	0x5c, 0x4b, 0x35, 0xbc, 0x58, 0xf0, 0x12, 0x6a, 0x78, 0xb1, 0x75, 0x0d, 0xca, 0x43, 0xfe, 0x42,
+	0x59, 0x9c, 0x6c, 0x19, 0xc7, 0xf2, 0x18, 0x5e, 0x2c, 0x74, 0x89, 0x63, 0x78, 0xb1, 0x75, 0x0d,
-	0x24, 0xf1, 0xec, 0x53, 0xb3, 0x24, 0xae, 0x37, 0x18, 0xac, 0x8c, 0x7c, 0x09, 0x22, 0xef, 0xc3,
+	0xca, 0x43, 0xf1, 0x42, 0x26, 0xf1, 0xec, 0x53, 0x58, 0x12, 0xc7, 0x1b, 0x0c, 0x56, 0x46, 0xbe,
-	0xb2, 0xfc, 0xe2, 0x50, 0x5d, 0x30, 0xdf, 0xfe, 0xfa, 0x9b, 0xd5, 0x37, 0x47, 0x10, 0xe4, 0x21,
+	0x04, 0x91, 0xf7, 0x61, 0x59, 0x7e, 0x71, 0xa8, 0x2e, 0x98, 0x6f, 0x7f, 0xfd, 0xcd, 0xea, 0x9b,
-	0xa2, 0x6d, 0xf5, 0x7c, 0xc7, 0x63, 0x55, 0x63, 0x22, 0x9a, 0x3c, 0x34, 0xb3, 0xbf, 0xfa, 0xfd,
+	0x23, 0x0c, 0x72, 0x11, 0xd9, 0xb6, 0x7a, 0xbe, 0xe3, 0xb1, 0xaa, 0x31, 0x91, 0x4d, 0x2e, 0x9a,
-	0x95, 0x85, 0x0d, 0x1b, 0x2e, 0x8d, 0x7d, 0xc5, 0x20, 0xd7, 0x20, 0x7b, 0xcc, 0xbc, 0x4e, 0x22,
+	0xd9, 0x5f, 0xfd, 0xfe, 0xca, 0xc2, 0x86, 0x0d, 0x97, 0xc6, 0xbe, 0x62, 0x90, 0x6b, 0x90, 0x3d,
-	0x66, 0x0c, 0x01, 0x0f, 0xc9, 0x55, 0xc8, 0x50, 0xfb, 0xac, 0x6a, 0x98, 0xb5, 0xaf, 0xbf, 0x59,
+	0x66, 0x5e, 0x27, 0x31, 0x33, 0xc6, 0x80, 0x8b, 0xe4, 0x2a, 0x64, 0xa8, 0x7d, 0x56, 0x35, 0xcc,
-	0xbd, 0x3c, 0xfe, 0x29, 0xc4, 0x3e, 0x93, 0x22, 0x9a, 0x7f, 0x01, 0x28, 0x1c, 0x1e, 0x6e, 0x6d,
+	0xda, 0xd7, 0xdf, 0xac, 0x5e, 0x1e, 0xff, 0x14, 0x62, 0x9f, 0x49, 0x13, 0xcd, 0xbf, 0x00, 0x14,
-	0x45, 0xae, 0xd3, 0x65, 0xe4, 0x97, 0x06, 0x90, 0xf1, 0x97, 0x28, 0xb9, 0x9d, 0x9e, 0xe3, 0x93,
+	0x0e, 0x0f, 0xb7, 0xb6, 0x22, 0xd7, 0xe9, 0x32, 0xf2, 0x4b, 0x03, 0xc8, 0xf8, 0x4b, 0x94, 0xdc,
-	0x1f, 0xe4, 0xe6, 0xc7, 0x73, 0x52, 0xa9, 0x49, 0xe3, 0x73, 0x58, 0x12, 0xe3, 0x31, 0xf9, 0x60,
+	0x4e, 0xcf, 0xf1, 0xc9, 0x0f, 0x72, 0xf3, 0xe3, 0x39, 0xa5, 0x14, 0xd2, 0xf8, 0x1c, 0x96, 0x04,
-	0xc6, 0x67, 0x8d, 0xb9, 0x3e, 0x1d, 0x51, 0xf1, 0x6e, 0x43, 0x3e, 0x19, 0x31, 0xc9, 0x46, 0xea,
+	0x3c, 0x26, 0x1f, 0xcc, 0xf8, 0xac, 0x31, 0xd7, 0xa7, 0x33, 0x2a, 0xdd, 0x6d, 0xc8, 0x27, 0x10,
-	0xf5, 0x86, 0x26, 0x68, 0xf3, 0xc3, 0x99, 0x70, 0x95, 0x90, 0x9f, 0x42, 0x4e, 0x4d, 0x8e, 0xe4,
+	0x93, 0x6c, 0xa4, 0x6e, 0x6f, 0x08, 0x41, 0x9b, 0x1f, 0xce, 0xc4, 0xab, 0x8c, 0xfc, 0x14, 0x72,
-	0xfa, 0x14, 0xba, 0xc1, 0x0c, 0x6b, 0x6e, 0xcc, 0x82, 0x3a, 0x50, 0x23, 0x99, 0x10, 0x53, 0xd5,
+	0x0a, 0x39, 0x92, 0xeb, 0x53, 0xe4, 0x06, 0x18, 0xd6, 0xdc, 0x98, 0x85, 0x75, 0x70, 0x8c, 0x04,
-	0x18, 0x99, 0x3f, 0x53, 0xd5, 0x18, 0x1b, 0x39, 0xdb, 0x83, 0x87, 0x60, 0xaa, 0x90, 0x91, 0x79,
+	0x21, 0xa6, 0x1e, 0x63, 0x04, 0x7f, 0xa6, 0x1e, 0x63, 0x0c, 0x72, 0xb6, 0x07, 0x0f, 0xc1, 0x54,
-	0x33, 0x55, 0xc8, 0xe8, 0xd8, 0x49, 0x9e, 0x42, 0x16, 0xc7, 0x4e, 0x92, 0x56, 0x7e, 0xb5, 0xb9,
+	0x23, 0x23, 0x78, 0x33, 0xd5, 0xc8, 0x28, 0xec, 0x24, 0x4f, 0x21, 0x8b, 0xb0, 0x93, 0xa4, 0x95,
-	0xd4, 0x4c, 0x8b, 0x89, 0xa1, 0x79, 0xf5, 0x27, 0xd8, 0xa6, 0xc4, 0x9b, 0x3f, 0xbd, 0x41, 0x69,
+	0x5f, 0x0d, 0x97, 0x9a, 0x69, 0x77, 0x62, 0x08, 0xaf, 0xfe, 0x04, 0xdb, 0x94, 0x78, 0xf3, 0xa7,
-	0x1f, 0xea, 0xcc, 0xeb, 0x33, 0x60, 0x0e, 0xd8, 0xab, 0xf7, 0xf2, 0xfa, 0x0c, 0x5f, 0xcb, 0xa6,
+	0x37, 0x28, 0xed, 0x43, 0x9d, 0x79, 0x7d, 0x06, 0xce, 0x81, 0x7a, 0xf5, 0x5e, 0x5e, 0x9f, 0xe1,
-	0xb3, 0x1f, 0xf9, 0x2e, 0x17, 0x40, 0x49, 0x9f, 0x3e, 0x48, 0x3d, 0x85, 0x74, 0xc2, 0xe0, 0x66,
+	0x6b, 0xd9, 0x74, 0xf5, 0x23, 0xdf, 0xe5, 0x02, 0x28, 0xe9, 0xe8, 0x83, 0xd4, 0x53, 0x44, 0x27,
-	0x36, 0x66, 0xc6, 0x57, 0x02, 0xbf, 0xc2, 0xb7, 0xd7, 0xf0, 0x64, 0x42, 0x9a, 0xa9, 0xe6, 0x98,
+	0x00, 0x37, 0xb3, 0x31, 0x33, 0xbf, 0x32, 0xf8, 0x15, 0xbe, 0xbd, 0x86, 0x91, 0x09, 0x69, 0xa6,
-	0x38, 0x03, 0x99, 0xb7, 0xe6, 0xa2, 0x51, 0xc2, 0x6d, 0x39, 0xf9, 0xa8, 0xe9, 0x86, 0xa4, 0x37,
+	0xba, 0x63, 0x22, 0x06, 0x32, 0x6f, 0xcd, 0x25, 0xa3, 0x8c, 0xdb, 0x12, 0xf9, 0x28, 0x74, 0x43,
-	0xf2, 0xfe, 0x84, 0x64, 0xce, 0x88, 0xb7, 0x6e, 0xdc, 0x34, 0x30, 0xce, 0x70, 0xe2, 0x4d, 0xe5,
+	0xd2, 0x1b, 0x79, 0x1f, 0x21, 0x99, 0x33, 0xf2, 0xad, 0x1b, 0x37, 0x0d, 0xbc, 0x67, 0x88, 0x78,
-	0xad, 0x3d, 0x05, 0x52, 0xe3, 0x4c, 0x1f, 0x9d, 0xb7, 0x4a, 0xdf, 0xbe, 0xba, 0x62, 0xfc, 0xfd,
+	0x53, 0x75, 0x6b, 0x4f, 0x81, 0xd4, 0x7b, 0xa6, 0x43, 0xe7, 0xad, 0xd2, 0xb7, 0xaf, 0xae, 0x18,
-	0xd5, 0x15, 0xe3, 0x5f, 0xaf, 0xae, 0x18, 0x27, 0xcb, 0xe2, 0xef, 0xc7, 0x5b, 0xff, 0x0d, 0x00,
+	0x7f, 0x7f, 0x75, 0xc5, 0xf8, 0xd7, 0xab, 0x2b, 0xc6, 0xc9, 0xb2, 0xf8, 0xfb, 0xf1, 0xd6, 0x7f,
-	0x00, 0xff, 0xff, 0x76, 0x21, 0x31, 0x33, 0xd0, 0x1d, 0x00, 0x00,
+	0x03, 0x00, 0x00, 0xff, 0xff, 0x5c, 0x01, 0xa5, 0x69, 0xd0, 0x1d, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -3370,7 +3371,7 @@ func (m *Result) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 			dAtA[i] = 0xa
 			i = encodeVarintGateway(dAtA, i, uint64(baseI-i))
 			i--
-			dAtA[i] = 0x5a
+			dAtA[i] = 0x62
 		}
 	}
 	if len(m.Metadata) > 0 {
@@ -6919,7 +6920,7 @@ func (m *Result) Unmarshal(dAtA []byte) error {
 			}
 			m.Metadata[mapkey] = mapvalue
 			iNdEx = postIndex
-		case 11:
+		case 12:
 			if wireType != 2 {
 				return fmt.Errorf("proto: wrong wireType = %d for field Attestations", wireType)
 			}

vendor/github.com/moby/buildkit/frontend/gateway/pb/gateway.proto

@@ -50,7 +50,8 @@ message Result {
 		RefMap refs = 4;
 	}
 	map<string, bytes> metadata = 10;
-	map<string, Attestations> attestations = 11;
+	// 11 was used during development and is reserved for old attestation format
+	map<string, Attestations> attestations = 12;
 }
 
 message RefMapDeprecated {

vendor/github.com/moby/buildkit/util/progress/multireader.go

@@ -35,8 +35,13 @@ func (mr *MultiReader) Reader(ctx context.Context) Reader {
 
 	isBehind := len(mr.sent) > 0
 
-	if !isBehind {
+	select {
-		mr.writers[w] = closeWriter
+	case <-mr.done:
+		isBehind = true
+	default:
+		if !isBehind {
+			mr.writers[w] = closeWriter
+		}
 	}
 
 	go func() {
@@ -74,9 +79,6 @@ func (mr *MultiReader) Reader(ctx context.Context) Reader {
 						case <-ctx.Done():
 							close()
 							return
-						case <-mr.done:
-							close()
-							return
 						default:
 						}
 					}

vendor/github.com/moby/buildkit/util/progress/progress.go

@@ -118,12 +118,22 @@ func (pr *progressReader) Read(ctx context.Context) ([]*Progress, error) {
 	done := make(chan struct{})
 	defer close(done)
 	go func() {
-		select {
+		prdone := pr.ctx.Done()
-		case <-done:
+		for {
-		case <-ctx.Done():
+			select {
-			pr.mu.Lock()
+			case <-done:
-			pr.cond.Broadcast()
+				return
-			pr.mu.Unlock()
+			case <-ctx.Done():
+				pr.mu.Lock()
+				pr.cond.Broadcast()
+				pr.mu.Unlock()
+				return
+			case <-prdone:
+				pr.mu.Lock()
+				pr.cond.Broadcast()
+				pr.mu.Unlock()
+				prdone = nil
+			}
 		}
 	}()
 	pr.mu.Lock()

vendor/github.com/moby/buildkit/util/tracing/detect/detect.go

@@ -24,6 +24,7 @@ type detector struct {
 }
 
 var ServiceName string
+var Recorder *TraceRecorder
 
 var detectors map[string]detector
 var once sync.Once
@@ -80,6 +81,11 @@ func detect() error {
 		return err
 	}
 
+	if Recorder != nil {
+		Recorder.SpanExporter = exp
+		exp = Recorder
+	}
+
 	if exp == nil {
 		return nil
 	}
@@ -98,6 +104,10 @@ func detect() error {
 
 	sp := sdktrace.NewBatchSpanProcessor(exp)
 
+	if Recorder != nil {
+		Recorder.flush = sp.ForceFlush
+	}
+
 	sdktp := sdktrace.NewTracerProvider(sdktrace.WithSpanProcessor(sp), sdktrace.WithResource(res))
 	closers = append(closers, sdktp.Shutdown)
 

vendor/github.com/moby/buildkit/util/tracing/detect/recorder.go

@@ -0,0 +1,115 @@
+package detect
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+	"go.opentelemetry.io/otel/sdk/trace/tracetest"
+	"go.opentelemetry.io/otel/trace"
+)
+
+type TraceRecorder struct {
+	sdktrace.SpanExporter
+
+	mu        sync.Mutex
+	m         map[trace.TraceID]*stubs
+	listeners map[trace.TraceID]int
+	flush     func(context.Context) error
+}
+
+type stubs struct {
+	spans []tracetest.SpanStub
+	last  time.Time
+}
+
+func NewTraceRecorder() *TraceRecorder {
+	tr := &TraceRecorder{
+		m:         map[trace.TraceID]*stubs{},
+		listeners: map[trace.TraceID]int{},
+	}
+
+	go func() {
+		t := time.NewTimer(60 * time.Second)
+		for {
+			<-t.C
+			tr.gc()
+			t.Reset(50 * time.Second)
+		}
+	}()
+
+	return tr
+}
+
+func (r *TraceRecorder) Record(traceID trace.TraceID) func() []tracetest.SpanStub {
+	if r.flush != nil {
+		r.flush(context.TODO())
+	}
+
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	r.listeners[traceID]++
+	var once sync.Once
+	var spans []tracetest.SpanStub
+	return func() []tracetest.SpanStub {
+		once.Do(func() {
+			r.mu.Lock()
+			defer r.mu.Unlock()
+
+			if v, ok := r.m[traceID]; ok {
+				spans = v.spans
+			}
+			r.listeners[traceID]--
+			if r.listeners[traceID] == 0 {
+				delete(r.listeners, traceID)
+			}
+		})
+		return spans
+	}
+}
+
+func (r *TraceRecorder) gc() {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	now := time.Now()
+	for k, s := range r.m {
+		if _, ok := r.listeners[k]; ok {
+			continue
+		}
+		if now.Sub(s.last) > 60*time.Second {
+			delete(r.m, k)
+		}
+	}
+}
+
+func (r *TraceRecorder) ExportSpans(ctx context.Context, spans []sdktrace.ReadOnlySpan) error {
+	r.mu.Lock()
+
+	now := time.Now()
+	for _, s := range spans {
+		ss := tracetest.SpanStubFromReadOnlySpan(s)
+		v, ok := r.m[ss.SpanContext.TraceID()]
+		if !ok {
+			v = &stubs{}
+			r.m[s.SpanContext().TraceID()] = v
+		}
+		v.last = now
+		v.spans = append(v.spans, ss)
+	}
+	r.mu.Unlock()
+
+	if r.SpanExporter == nil {
+		return nil
+	}
+	return r.SpanExporter.ExportSpans(ctx, spans)
+}
+
+func (r *TraceRecorder) Shutdown(ctx context.Context) error {
+	if r.SpanExporter == nil {
+		return nil
+	}
+	return r.SpanExporter.Shutdown(ctx)
+}

vendor/go.opentelemetry.io/otel/sdk/trace/tracetest/exporter.go

@@ -0,0 +1,85 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package tracetest is a testing helper package for the SDK. User can
+// configure no-op or in-memory exporters to verify different SDK behaviors or
+// custom instrumentation.
+package tracetest // import "go.opentelemetry.io/otel/sdk/trace/tracetest"
+
+import (
+	"context"
+	"sync"
+
+	"go.opentelemetry.io/otel/sdk/trace"
+)
+
+var _ trace.SpanExporter = (*NoopExporter)(nil)
+
+// NewNoopExporter returns a new no-op exporter.
+func NewNoopExporter() *NoopExporter {
+	return new(NoopExporter)
+}
+
+// NoopExporter is an exporter that drops all received spans and performs no
+// action.
+type NoopExporter struct{}
+
+// ExportSpans handles export of spans by dropping them.
+func (nsb *NoopExporter) ExportSpans(context.Context, []trace.ReadOnlySpan) error { return nil }
+
+// Shutdown stops the exporter by doing nothing.
+func (nsb *NoopExporter) Shutdown(context.Context) error { return nil }
+
+var _ trace.SpanExporter = (*InMemoryExporter)(nil)
+
+// NewInMemoryExporter returns a new InMemoryExporter.
+func NewInMemoryExporter() *InMemoryExporter {
+	return new(InMemoryExporter)
+}
+
+// InMemoryExporter is an exporter that stores all received spans in-memory.
+type InMemoryExporter struct {
+	mu sync.Mutex
+	ss SpanStubs
+}
+
+// ExportSpans handles export of spans by storing them in memory.
+func (imsb *InMemoryExporter) ExportSpans(_ context.Context, spans []trace.ReadOnlySpan) error {
+	imsb.mu.Lock()
+	defer imsb.mu.Unlock()
+	imsb.ss = append(imsb.ss, SpanStubsFromReadOnlySpans(spans)...)
+	return nil
+}
+
+// Shutdown stops the exporter by clearing spans held in memory.
+func (imsb *InMemoryExporter) Shutdown(context.Context) error {
+	imsb.Reset()
+	return nil
+}
+
+// Reset the current in-memory storage.
+func (imsb *InMemoryExporter) Reset() {
+	imsb.mu.Lock()
+	defer imsb.mu.Unlock()
+	imsb.ss = nil
+}
+
+// GetSpans returns the current in-memory stored spans.
+func (imsb *InMemoryExporter) GetSpans() SpanStubs {
+	imsb.mu.Lock()
+	defer imsb.mu.Unlock()
+	ret := make(SpanStubs, len(imsb.ss))
+	copy(ret, imsb.ss)
+	return ret
+}

vendor/go.opentelemetry.io/otel/sdk/trace/tracetest/recorder.go

@@ -0,0 +1,91 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package tracetest // import "go.opentelemetry.io/otel/sdk/trace/tracetest"
+
+import (
+	"context"
+	"sync"
+
+	sdktrace "go.opentelemetry.io/otel/sdk/trace"
+)
+
+// SpanRecorder records started and ended spans.
+type SpanRecorder struct {
+	startedMu sync.RWMutex
+	started   []sdktrace.ReadWriteSpan
+
+	endedMu sync.RWMutex
+	ended   []sdktrace.ReadOnlySpan
+}
+
+var _ sdktrace.SpanProcessor = (*SpanRecorder)(nil)
+
+func NewSpanRecorder() *SpanRecorder {
+	return new(SpanRecorder)
+}
+
+// OnStart records started spans.
+//
+// This method is safe to be called concurrently.
+func (sr *SpanRecorder) OnStart(_ context.Context, s sdktrace.ReadWriteSpan) {
+	sr.startedMu.Lock()
+	defer sr.startedMu.Unlock()
+	sr.started = append(sr.started, s)
+}
+
+// OnEnd records completed spans.
+//
+// This method is safe to be called concurrently.
+func (sr *SpanRecorder) OnEnd(s sdktrace.ReadOnlySpan) {
+	sr.endedMu.Lock()
+	defer sr.endedMu.Unlock()
+	sr.ended = append(sr.ended, s)
+}
+
+// Shutdown does nothing.
+//
+// This method is safe to be called concurrently.
+func (sr *SpanRecorder) Shutdown(context.Context) error {
+	return nil
+}
+
+// ForceFlush does nothing.
+//
+// This method is safe to be called concurrently.
+func (sr *SpanRecorder) ForceFlush(context.Context) error {
+	return nil
+}
+
+// Started returns a copy of all started spans that have been recorded.
+//
+// This method is safe to be called concurrently.
+func (sr *SpanRecorder) Started() []sdktrace.ReadWriteSpan {
+	sr.startedMu.RLock()
+	defer sr.startedMu.RUnlock()
+	dst := make([]sdktrace.ReadWriteSpan, len(sr.started))
+	copy(dst, sr.started)
+	return dst
+}
+
+// Ended returns a copy of all ended spans that have been recorded.
+//
+// This method is safe to be called concurrently.
+func (sr *SpanRecorder) Ended() []sdktrace.ReadOnlySpan {
+	sr.endedMu.RLock()
+	defer sr.endedMu.RUnlock()
+	dst := make([]sdktrace.ReadOnlySpan, len(sr.ended))
+	copy(dst, sr.ended)
+	return dst
+}

vendor/go.opentelemetry.io/otel/sdk/trace/tracetest/span.go

@@ -0,0 +1,163 @@
+// Copyright The OpenTelemetry Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package tracetest // import "go.opentelemetry.io/otel/sdk/trace/tracetest"
+
+import (
+	"time"
+
+	"go.opentelemetry.io/otel/attribute"
+	"go.opentelemetry.io/otel/sdk/instrumentation"
+	"go.opentelemetry.io/otel/sdk/resource"
+	tracesdk "go.opentelemetry.io/otel/sdk/trace"
+	"go.opentelemetry.io/otel/trace"
+)
+
+type SpanStubs []SpanStub
+
+// SpanStubsFromReadOnlySpans returns SpanStubs populated from ro.
+func SpanStubsFromReadOnlySpans(ro []tracesdk.ReadOnlySpan) SpanStubs {
+	if len(ro) == 0 {
+		return nil
+	}
+
+	s := make(SpanStubs, 0, len(ro))
+	for _, r := range ro {
+		s = append(s, SpanStubFromReadOnlySpan(r))
+	}
+
+	return s
+}
+
+// Snapshots returns s as a slice of ReadOnlySpans.
+func (s SpanStubs) Snapshots() []tracesdk.ReadOnlySpan {
+	if len(s) == 0 {
+		return nil
+	}
+
+	ro := make([]tracesdk.ReadOnlySpan, len(s))
+	for i := 0; i < len(s); i++ {
+		ro[i] = s[i].Snapshot()
+	}
+	return ro
+}
+
+// SpanStub is a stand-in for a Span.
+type SpanStub struct {
+	Name                   string
+	SpanContext            trace.SpanContext
+	Parent                 trace.SpanContext
+	SpanKind               trace.SpanKind
+	StartTime              time.Time
+	EndTime                time.Time
+	Attributes             []attribute.KeyValue
+	Events                 []tracesdk.Event
+	Links                  []tracesdk.Link
+	Status                 tracesdk.Status
+	DroppedAttributes      int
+	DroppedEvents          int
+	DroppedLinks           int
+	ChildSpanCount         int
+	Resource               *resource.Resource
+	InstrumentationLibrary instrumentation.Library
+}
+
+// SpanStubFromReadOnlySpan returns a SpanStub populated from ro.
+func SpanStubFromReadOnlySpan(ro tracesdk.ReadOnlySpan) SpanStub {
+	if ro == nil {
+		return SpanStub{}
+	}
+
+	return SpanStub{
+		Name:                   ro.Name(),
+		SpanContext:            ro.SpanContext(),
+		Parent:                 ro.Parent(),
+		SpanKind:               ro.SpanKind(),
+		StartTime:              ro.StartTime(),
+		EndTime:                ro.EndTime(),
+		Attributes:             ro.Attributes(),
+		Events:                 ro.Events(),
+		Links:                  ro.Links(),
+		Status:                 ro.Status(),
+		DroppedAttributes:      ro.DroppedAttributes(),
+		DroppedEvents:          ro.DroppedEvents(),
+		DroppedLinks:           ro.DroppedLinks(),
+		ChildSpanCount:         ro.ChildSpanCount(),
+		Resource:               ro.Resource(),
+		InstrumentationLibrary: ro.InstrumentationLibrary(),
+	}
+}
+
+// Snapshot returns a read-only copy of the SpanStub.
+func (s SpanStub) Snapshot() tracesdk.ReadOnlySpan {
+	return spanSnapshot{
+		name:                   s.Name,
+		spanContext:            s.SpanContext,
+		parent:                 s.Parent,
+		spanKind:               s.SpanKind,
+		startTime:              s.StartTime,
+		endTime:                s.EndTime,
+		attributes:             s.Attributes,
+		events:                 s.Events,
+		links:                  s.Links,
+		status:                 s.Status,
+		droppedAttributes:      s.DroppedAttributes,
+		droppedEvents:          s.DroppedEvents,
+		droppedLinks:           s.DroppedLinks,
+		childSpanCount:         s.ChildSpanCount,
+		resource:               s.Resource,
+		instrumentationLibrary: s.InstrumentationLibrary,
+	}
+}
+
+type spanSnapshot struct {
+	// Embed the interface to implement the private method.
+	tracesdk.ReadOnlySpan
+
+	name                   string
+	spanContext            trace.SpanContext
+	parent                 trace.SpanContext
+	spanKind               trace.SpanKind
+	startTime              time.Time
+	endTime                time.Time
+	attributes             []attribute.KeyValue
+	events                 []tracesdk.Event
+	links                  []tracesdk.Link
+	status                 tracesdk.Status
+	droppedAttributes      int
+	droppedEvents          int
+	droppedLinks           int
+	childSpanCount         int
+	resource               *resource.Resource
+	instrumentationLibrary instrumentation.Library
+}
+
+func (s spanSnapshot) Name() string                     { return s.name }
+func (s spanSnapshot) SpanContext() trace.SpanContext   { return s.spanContext }
+func (s spanSnapshot) Parent() trace.SpanContext        { return s.parent }
+func (s spanSnapshot) SpanKind() trace.SpanKind         { return s.spanKind }
+func (s spanSnapshot) StartTime() time.Time             { return s.startTime }
+func (s spanSnapshot) EndTime() time.Time               { return s.endTime }
+func (s spanSnapshot) Attributes() []attribute.KeyValue { return s.attributes }
+func (s spanSnapshot) Links() []tracesdk.Link           { return s.links }
+func (s spanSnapshot) Events() []tracesdk.Event         { return s.events }
+func (s spanSnapshot) Status() tracesdk.Status          { return s.status }
+func (s spanSnapshot) DroppedAttributes() int           { return s.droppedAttributes }
+func (s spanSnapshot) DroppedLinks() int                { return s.droppedLinks }
+func (s spanSnapshot) DroppedEvents() int               { return s.droppedEvents }
+func (s spanSnapshot) ChildSpanCount() int              { return s.childSpanCount }
+func (s spanSnapshot) Resource() *resource.Resource     { return s.resource }
+func (s spanSnapshot) InstrumentationLibrary() instrumentation.Library {
+	return s.instrumentationLibrary
+}

vendor/modules.txt

@@ -433,7 +433,7 @@ github.com/mitchellh/go-wordwrap
 # github.com/mitchellh/mapstructure v1.5.0
 ## explicit; go 1.14
 github.com/mitchellh/mapstructure
-# github.com/moby/buildkit v0.11.0-rc1.0.20221213104201-93b40706a007
+# github.com/moby/buildkit v0.11.0-rc1.0.20221213193744-862b22d7e7cf
 ## explicit; go 1.18
 github.com/moby/buildkit/api/services/control
 github.com/moby/buildkit/api/types
@@ -684,6 +684,7 @@ go.opentelemetry.io/otel/sdk/internal
 go.opentelemetry.io/otel/sdk/internal/env
 go.opentelemetry.io/otel/sdk/resource
 go.opentelemetry.io/otel/sdk/trace
+go.opentelemetry.io/otel/sdk/trace/tracetest
 # go.opentelemetry.io/otel/trace v1.4.1
 ## explicit; go 1.16
 go.opentelemetry.io/otel/trace