From 10a334f5bd8e1e57964e1e670ba9f2fecda2c329 Mon Sep 17 00:00:00 2001
From: Justin Chadwell <me@jedevc.com>
Date: Wed, 28 Sep 2022 09:29:46 +0100
Subject: [PATCH 1/5] gateway: add Evaluate API

Signed-off-by: Justin Chadwell <me@jedevc.com>
---
 client/build.go                       |   8 +
 control/gateway/gateway.go            |   8 +
 frontend/frontend_test.go             |  50 ++
 frontend/gateway/client/client.go     |   1 +
 frontend/gateway/forwarder/forward.go |   8 +
 frontend/gateway/gateway.go           |  10 +
 frontend/gateway/grpcclient/client.go |   9 +
 frontend/gateway/pb/caps.go           |   9 +
 frontend/gateway/pb/gateway.pb.go     | 679 +++++++++++++++++++-------
 frontend/gateway/pb/gateway.proto     |   9 +
 10 files changed, 627 insertions(+), 164 deletions(-)

diff --git a/client/build.go b/client/build.go
index 25b3aa6d7ccf..62ebaee55c86 100644
--- a/client/build.go
+++ b/client/build.go
@@ -113,6 +113,14 @@ func (g *gatewayClientForBuild) StatFile(ctx context.Context, in *gatewayapi.Sta
 	return g.gateway.StatFile(ctx, in, opts...)
 }
 
+func (g *gatewayClientForBuild) Evaluate(ctx context.Context, in *gatewayapi.EvaluateRequest, opts ...grpc.CallOption) (*gatewayapi.EvaluateResponse, error) {
+	if err := g.caps.Supports(gatewayapi.CapGatewayEvaluate); err != nil {
+		return nil, err
+	}
+	ctx = buildid.AppendToOutgoingContext(ctx, g.buildID)
+	return g.gateway.Evaluate(ctx, in, opts...)
+}
+
 func (g *gatewayClientForBuild) Ping(ctx context.Context, in *gatewayapi.PingRequest, opts ...grpc.CallOption) (*gatewayapi.PongResponse, error) {
 	ctx = buildid.AppendToOutgoingContext(ctx, g.buildID)
 	return g.gateway.Ping(ctx, in, opts...)
diff --git a/control/gateway/gateway.go b/control/gateway/gateway.go
index 62c696d6c448..4451e022d322 100644
--- a/control/gateway/gateway.go
+++ b/control/gateway/gateway.go
@@ -111,6 +111,14 @@ func (gwf *GatewayForwarder) ReadFile(ctx context.Context, req *gwapi.ReadFileRe
 	return fwd.ReadFile(ctx, req)
 }
 
+func (gwf *GatewayForwarder) Evaluate(ctx context.Context, req *gwapi.EvaluateRequest) (*gwapi.EvaluateResponse, error) {
+	fwd, err := gwf.lookupForwarder(ctx)
+	if err != nil {
+		return nil, errors.Wrap(err, "forwarding Evaluate")
+	}
+	return fwd.Evaluate(ctx, req)
+}
+
 func (gwf *GatewayForwarder) Ping(ctx context.Context, req *gwapi.PingRequest) (*gwapi.PongResponse, error) {
 	fwd, err := gwf.lookupForwarder(ctx)
 	if err != nil {
diff --git a/frontend/frontend_test.go b/frontend/frontend_test.go
index 907581f4f381..c2dc94f66823 100644
--- a/frontend/frontend_test.go
+++ b/frontend/frontend_test.go
@@ -31,6 +31,7 @@ func TestFrontendIntegration(t *testing.T) {
 		testRefReadFile,
 		testRefReadDir,
 		testRefStatFile,
+		testRefEvaluate,
 		testReturnNil,
 	))
 }
@@ -291,6 +292,55 @@ func testRefStatFile(t *testing.T, sb integration.Sandbox) {
 	require.NoError(t, err)
 }
 
+func testRefEvaluate(t *testing.T, sb integration.Sandbox) {
+	ctx := sb.Context()
+
+	c, err := client.New(ctx, sb.Address())
+	require.NoError(t, err)
+	defer c.Close()
+
+	frontend := func(ctx context.Context, c gateway.Client) (*gateway.Result, error) {
+		st := llb.Scratch().File(llb.Mkfile("/test", 0666, []byte{}))
+		def, err := st.Marshal(ctx)
+		if err != nil {
+			return nil, err
+		}
+		res, err := c.Solve(ctx, gateway.SolveRequest{
+			Definition: def.ToPB(),
+		})
+		if err != nil {
+			return nil, err
+		}
+		ref, err := res.SingleRef()
+		if err != nil {
+			return nil, err
+		}
+
+		st = llb.Scratch().File(llb.Mkfile("/test/dir-does-not-exist", 0666, []byte{}))
+		def, err = st.Marshal(ctx)
+		if err != nil {
+			return nil, err
+		}
+		res, err = c.Solve(ctx, gateway.SolveRequest{
+			Definition: def.ToPB(),
+		})
+		if err != nil {
+			return nil, err
+		}
+		ref2, err := res.SingleRef()
+		if err != nil {
+			return nil, err
+		}
+
+		require.NoError(t, ref.Evaluate(ctx))
+		require.Error(t, ref2.Evaluate(ctx))
+		return gateway.NewResult(), nil
+	}
+
+	_, err = c.Build(ctx, client.SolveOpt{}, "", frontend, nil)
+	require.NoError(t, err)
+}
+
 func tmpdir(t *testing.T, appliers ...fstest.Applier) (string, error) {
 	tmpdir := t.TempDir()
 	if err := fstest.Apply(appliers...).Apply(tmpdir); err != nil {
diff --git a/frontend/gateway/client/client.go b/frontend/gateway/client/client.go
index fe77522387e6..23e6a632d2ee 100644
--- a/frontend/gateway/client/client.go
+++ b/frontend/gateway/client/client.go
@@ -91,6 +91,7 @@ type ContainerProcess interface {
 
 type Reference interface {
 	ToState() (llb.State, error)
+	Evaluate(ctx context.Context) error
 	ReadFile(ctx context.Context, req ReadRequest) ([]byte, error)
 	StatFile(ctx context.Context, req StatRequest) (*fstypes.Stat, error)
 	ReadDir(ctx context.Context, req ReadDirRequest) ([]*fstypes.Stat, error)
diff --git a/frontend/gateway/forwarder/forward.go b/frontend/gateway/forwarder/forward.go
index e98bf6ed7973..d2e579a26f4c 100644
--- a/frontend/gateway/forwarder/forward.go
+++ b/frontend/gateway/forwarder/forward.go
@@ -318,6 +318,14 @@ func (r *ref) ToState() (st llb.State, err error) {
 	return llb.NewState(defop), nil
 }
 
+func (r *ref) Evaluate(ctx context.Context) error {
+	_, err := r.resultProxy.Result(ctx)
+	if err != nil {
+		return r.c.wrapSolveError(err)
+	}
+	return nil
+}
+
 func (r *ref) ReadFile(ctx context.Context, req client.ReadRequest) ([]byte, error) {
 	m, err := r.getMountable(ctx)
 	if err != nil {
diff --git a/frontend/gateway/gateway.go b/frontend/gateway/gateway.go
index 327fee6fb7cb..0f180ecb0618 100644
--- a/frontend/gateway/gateway.go
+++ b/frontend/gateway/gateway.go
@@ -852,6 +852,16 @@ func (lbf *llbBridgeForwarder) StatFile(ctx context.Context, req *pb.StatFileReq
 	return &pb.StatFileResponse{Stat: st}, nil
 }
 
+func (lbf *llbBridgeForwarder) Evaluate(ctx context.Context, req *pb.EvaluateRequest) (*pb.EvaluateResponse, error) {
+	ctx = tracing.ContextWithSpanFromContext(ctx, lbf.callCtx)
+
+	_, err := lbf.getImmutableRef(ctx, req.Ref, "/")
+	if err != nil {
+		return nil, err
+	}
+	return &pb.EvaluateResponse{}, nil
+}
+
 func (lbf *llbBridgeForwarder) Ping(context.Context, *pb.PingRequest) (*pb.PongResponse, error) {
 	workers := lbf.workers.WorkerInfos()
 	pbWorkers := make([]*apitypes.WorkerRecord, 0, len(workers))
diff --git a/frontend/gateway/grpcclient/client.go b/frontend/gateway/grpcclient/client.go
index 8a8c794a8465..b20bd7c5adc5 100644
--- a/frontend/gateway/grpcclient/client.go
+++ b/frontend/gateway/grpcclient/client.go
@@ -1054,6 +1054,15 @@ func (r *reference) ToState() (st llb.State, err error) {
 	return llb.NewState(defop), nil
 }
 
+func (r *reference) Evaluate(ctx context.Context) error {
+	req := &pb.EvaluateRequest{Ref: r.id}
+	_, err := r.c.client.Evaluate(ctx, req)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
 func (r *reference) ReadFile(ctx context.Context, req client.ReadRequest) ([]byte, error) {
 	rfr := &pb.ReadFileRequest{FilePath: req.Filename, Ref: r.id}
 	if r := req.Range; r != nil {
diff --git a/frontend/gateway/pb/caps.go b/frontend/gateway/pb/caps.go
index 912ab88d22c3..deb192dc116e 100644
--- a/frontend/gateway/pb/caps.go
+++ b/frontend/gateway/pb/caps.go
@@ -56,6 +56,8 @@ const (
 	// errors.
 	CapGatewayEvaluateSolve apicaps.CapID = "gateway.solve.evaluate"
 
+	CapGatewayEvaluate apicaps.CapID = "gateway.evaluate"
+
 	// CapGatewayWarnings is the capability to log warnings from frontend
 	CapGatewayWarnings apicaps.CapID = "gateway.warnings"
 
@@ -198,6 +200,13 @@ func init() {
 		Status:  apicaps.CapStatusExperimental,
 	})
 
+	Caps.Init(apicaps.Cap{
+		ID:      CapGatewayEvaluate,
+		Name:    "gateway evaluate",
+		Enabled: true,
+		Status:  apicaps.CapStatusExperimental,
+	})
+
 	Caps.Init(apicaps.Cap{
 		ID:      CapGatewayWarnings,
 		Name:    "logging warnings",
diff --git a/frontend/gateway/pb/gateway.pb.go b/frontend/gateway/pb/gateway.pb.go
index 762ce2cfbf39..b1670622b94e 100644
--- a/frontend/gateway/pb/gateway.pb.go
+++ b/frontend/gateway/pb/gateway.pb.go
@@ -1471,6 +1471,92 @@ func (m *StatFileResponse) GetStat() *types.Stat {
 	return nil
 }
 
+type EvaluateRequest struct {
+	Ref                  string   `protobuf:"bytes,1,opt,name=Ref,proto3" json:"Ref,omitempty"`
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *EvaluateRequest) Reset()         { *m = EvaluateRequest{} }
+func (m *EvaluateRequest) String() string { return proto.CompactTextString(m) }
+func (*EvaluateRequest) ProtoMessage()    {}
+func (*EvaluateRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptor_f1a937782ebbded5, []int{23}
+}
+func (m *EvaluateRequest) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *EvaluateRequest) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_EvaluateRequest.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *EvaluateRequest) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EvaluateRequest.Merge(m, src)
+}
+func (m *EvaluateRequest) XXX_Size() int {
+	return m.Size()
+}
+func (m *EvaluateRequest) XXX_DiscardUnknown() {
+	xxx_messageInfo_EvaluateRequest.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EvaluateRequest proto.InternalMessageInfo
+
+func (m *EvaluateRequest) GetRef() string {
+	if m != nil {
+		return m.Ref
+	}
+	return ""
+}
+
+type EvaluateResponse struct {
+	XXX_NoUnkeyedLiteral struct{} `json:"-"`
+	XXX_unrecognized     []byte   `json:"-"`
+	XXX_sizecache        int32    `json:"-"`
+}
+
+func (m *EvaluateResponse) Reset()         { *m = EvaluateResponse{} }
+func (m *EvaluateResponse) String() string { return proto.CompactTextString(m) }
+func (*EvaluateResponse) ProtoMessage()    {}
+func (*EvaluateResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptor_f1a937782ebbded5, []int{24}
+}
+func (m *EvaluateResponse) XXX_Unmarshal(b []byte) error {
+	return m.Unmarshal(b)
+}
+func (m *EvaluateResponse) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
+	if deterministic {
+		return xxx_messageInfo_EvaluateResponse.Marshal(b, m, deterministic)
+	} else {
+		b = b[:cap(b)]
+		n, err := m.MarshalToSizedBuffer(b)
+		if err != nil {
+			return nil, err
+		}
+		return b[:n], nil
+	}
+}
+func (m *EvaluateResponse) XXX_Merge(src proto.Message) {
+	xxx_messageInfo_EvaluateResponse.Merge(m, src)
+}
+func (m *EvaluateResponse) XXX_Size() int {
+	return m.Size()
+}
+func (m *EvaluateResponse) XXX_DiscardUnknown() {
+	xxx_messageInfo_EvaluateResponse.DiscardUnknown(m)
+}
+
+var xxx_messageInfo_EvaluateResponse proto.InternalMessageInfo
+
 type PingRequest struct {
 	XXX_NoUnkeyedLiteral struct{} `json:"-"`
 	XXX_unrecognized     []byte   `json:"-"`
@@ -1481,7 +1567,7 @@ func (m *PingRequest) Reset()         { *m = PingRequest{} }
 func (m *PingRequest) String() string { return proto.CompactTextString(m) }
 func (*PingRequest) ProtoMessage()    {}
 func (*PingRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1a937782ebbded5, []int{23}
+	return fileDescriptor_f1a937782ebbded5, []int{25}
 }
 func (m *PingRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1523,7 +1609,7 @@ func (m *PongResponse) Reset()         { *m = PongResponse{} }
 func (m *PongResponse) String() string { return proto.CompactTextString(m) }
 func (*PongResponse) ProtoMessage()    {}
 func (*PongResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1a937782ebbded5, []int{24}
+	return fileDescriptor_f1a937782ebbded5, []int{26}
 }
 func (m *PongResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1590,7 +1676,7 @@ func (m *WarnRequest) Reset()         { *m = WarnRequest{} }
 func (m *WarnRequest) String() string { return proto.CompactTextString(m) }
 func (*WarnRequest) ProtoMessage()    {}
 func (*WarnRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1a937782ebbded5, []int{25}
+	return fileDescriptor_f1a937782ebbded5, []int{27}
 }
 func (m *WarnRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1671,7 +1757,7 @@ func (m *WarnResponse) Reset()         { *m = WarnResponse{} }
 func (m *WarnResponse) String() string { return proto.CompactTextString(m) }
 func (*WarnResponse) ProtoMessage()    {}
 func (*WarnResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1a937782ebbded5, []int{26}
+	return fileDescriptor_f1a937782ebbded5, []int{28}
 }
 func (m *WarnResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1717,7 +1803,7 @@ func (m *NewContainerRequest) Reset()         { *m = NewContainerRequest{} }
 func (m *NewContainerRequest) String() string { return proto.CompactTextString(m) }
 func (*NewContainerRequest) ProtoMessage()    {}
 func (*NewContainerRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1a937782ebbded5, []int{27}
+	return fileDescriptor_f1a937782ebbded5, []int{29}
 }
 func (m *NewContainerRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1798,7 +1884,7 @@ func (m *NewContainerResponse) Reset()         { *m = NewContainerResponse{} }
 func (m *NewContainerResponse) String() string { return proto.CompactTextString(m) }
 func (*NewContainerResponse) ProtoMessage()    {}
 func (*NewContainerResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1a937782ebbded5, []int{28}
+	return fileDescriptor_f1a937782ebbded5, []int{30}
 }
 func (m *NewContainerResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1838,7 +1924,7 @@ func (m *ReleaseContainerRequest) Reset()         { *m = ReleaseContainerRequest
 func (m *ReleaseContainerRequest) String() string { return proto.CompactTextString(m) }
 func (*ReleaseContainerRequest) ProtoMessage()    {}
 func (*ReleaseContainerRequest) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1a937782ebbded5, []int{29}
+	return fileDescriptor_f1a937782ebbded5, []int{31}
 }
 func (m *ReleaseContainerRequest) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1884,7 +1970,7 @@ func (m *ReleaseContainerResponse) Reset()         { *m = ReleaseContainerRespon
 func (m *ReleaseContainerResponse) String() string { return proto.CompactTextString(m) }
 func (*ReleaseContainerResponse) ProtoMessage()    {}
 func (*ReleaseContainerResponse) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1a937782ebbded5, []int{30}
+	return fileDescriptor_f1a937782ebbded5, []int{32}
 }
 func (m *ReleaseContainerResponse) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -1934,7 +2020,7 @@ func (m *ExecMessage) Reset()         { *m = ExecMessage{} }
 func (m *ExecMessage) String() string { return proto.CompactTextString(m) }
 func (*ExecMessage) ProtoMessage()    {}
 func (*ExecMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1a937782ebbded5, []int{31}
+	return fileDescriptor_f1a937782ebbded5, []int{33}
 }
 func (m *ExecMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2090,7 +2176,7 @@ func (m *InitMessage) Reset()         { *m = InitMessage{} }
 func (m *InitMessage) String() string { return proto.CompactTextString(m) }
 func (*InitMessage) ProtoMessage()    {}
 func (*InitMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1a937782ebbded5, []int{32}
+	return fileDescriptor_f1a937782ebbded5, []int{34}
 }
 func (m *InitMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2166,7 +2252,7 @@ func (m *ExitMessage) Reset()         { *m = ExitMessage{} }
 func (m *ExitMessage) String() string { return proto.CompactTextString(m) }
 func (*ExitMessage) ProtoMessage()    {}
 func (*ExitMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1a937782ebbded5, []int{33}
+	return fileDescriptor_f1a937782ebbded5, []int{35}
 }
 func (m *ExitMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2219,7 +2305,7 @@ func (m *StartedMessage) Reset()         { *m = StartedMessage{} }
 func (m *StartedMessage) String() string { return proto.CompactTextString(m) }
 func (*StartedMessage) ProtoMessage()    {}
 func (*StartedMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1a937782ebbded5, []int{34}
+	return fileDescriptor_f1a937782ebbded5, []int{36}
 }
 func (m *StartedMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2258,7 +2344,7 @@ func (m *DoneMessage) Reset()         { *m = DoneMessage{} }
 func (m *DoneMessage) String() string { return proto.CompactTextString(m) }
 func (*DoneMessage) ProtoMessage()    {}
 func (*DoneMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1a937782ebbded5, []int{35}
+	return fileDescriptor_f1a937782ebbded5, []int{37}
 }
 func (m *DoneMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2300,7 +2386,7 @@ func (m *FdMessage) Reset()         { *m = FdMessage{} }
 func (m *FdMessage) String() string { return proto.CompactTextString(m) }
 func (*FdMessage) ProtoMessage()    {}
 func (*FdMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1a937782ebbded5, []int{36}
+	return fileDescriptor_f1a937782ebbded5, []int{38}
 }
 func (m *FdMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2362,7 +2448,7 @@ func (m *ResizeMessage) Reset()         { *m = ResizeMessage{} }
 func (m *ResizeMessage) String() string { return proto.CompactTextString(m) }
 func (*ResizeMessage) ProtoMessage()    {}
 func (*ResizeMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1a937782ebbded5, []int{37}
+	return fileDescriptor_f1a937782ebbded5, []int{39}
 }
 func (m *ResizeMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2418,7 +2504,7 @@ func (m *SignalMessage) Reset()         { *m = SignalMessage{} }
 func (m *SignalMessage) String() string { return proto.CompactTextString(m) }
 func (*SignalMessage) ProtoMessage()    {}
 func (*SignalMessage) Descriptor() ([]byte, []int) {
-	return fileDescriptor_f1a937782ebbded5, []int{38}
+	return fileDescriptor_f1a937782ebbded5, []int{40}
 }
 func (m *SignalMessage) XXX_Unmarshal(b []byte) error {
 	return m.Unmarshal(b)
@@ -2488,6 +2574,8 @@ func init() {
 	proto.RegisterType((*ReadDirResponse)(nil), "moby.buildkit.v1.frontend.ReadDirResponse")
 	proto.RegisterType((*StatFileRequest)(nil), "moby.buildkit.v1.frontend.StatFileRequest")
 	proto.RegisterType((*StatFileResponse)(nil), "moby.buildkit.v1.frontend.StatFileResponse")
+	proto.RegisterType((*EvaluateRequest)(nil), "moby.buildkit.v1.frontend.EvaluateRequest")
+	proto.RegisterType((*EvaluateResponse)(nil), "moby.buildkit.v1.frontend.EvaluateResponse")
 	proto.RegisterType((*PingRequest)(nil), "moby.buildkit.v1.frontend.PingRequest")
 	proto.RegisterType((*PongResponse)(nil), "moby.buildkit.v1.frontend.PongResponse")
 	proto.RegisterType((*WarnRequest)(nil), "moby.buildkit.v1.frontend.WarnRequest")
@@ -2509,154 +2597,156 @@ func init() {
 func init() { proto.RegisterFile("gateway.proto", fileDescriptor_f1a937782ebbded5) }
 
 var fileDescriptor_f1a937782ebbded5 = []byte{
-	// 2349 bytes of a gzipped FileDescriptorProto
-	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x39, 0xcd, 0x6f, 0x1b, 0xc7,
-	0xf5, 0x5a, 0x91, 0x12, 0xc9, 0xc7, 0x0f, 0xcb, 0x13, 0x27, 0xbf, 0xcd, 0x22, 0x70, 0xe8, 0x4d,
-	0xa2, 0xd0, 0x8a, 0x43, 0xe6, 0x47, 0x27, 0x90, 0x6b, 0xb7, 0x4e, 0xac, 0x2f, 0x48, 0xb1, 0x64,
-	0xb3, 0x23, 0x17, 0x2e, 0x82, 0x14, 0xe8, 0x8a, 0x1c, 0xd2, 0x5b, 0x53, 0xbb, 0xdb, 0xd9, 0xa1,
-	0x65, 0x25, 0x97, 0xf6, 0x56, 0xe4, 0xd4, 0x53, 0x6f, 0x41, 0x81, 0xf6, 0x1f, 0x68, 0x2f, 0x3d,
-	0xf6, 0x1c, 0xa0, 0x97, 0x5e, 0x0a, 0x14, 0x3d, 0x04, 0x85, 0xff, 0x88, 0x16, 0xbd, 0x15, 0x6f,
-	0x66, 0x96, 0x1c, 0x7e, 0x78, 0x49, 0x35, 0x27, 0xce, 0xbc, 0x79, 0xef, 0xcd, 0xfb, 0x7e, 0x6f,
-	0x96, 0x50, 0xee, 0x79, 0x82, 0x9d, 0x79, 0xe7, 0xf5, 0x88, 0x87, 0x22, 0x24, 0xaf, 0x9f, 0x86,
-	0x27, 0xe7, 0xf5, 0x93, 0x81, 0xdf, 0xef, 0x3c, 0xf5, 0x45, 0xfd, 0xd9, 0xff, 0xd7, 0xbb, 0x3c,
-	0x0c, 0x04, 0x0b, 0x3a, 0xce, 0xfb, 0x3d, 0x5f, 0x3c, 0x19, 0x9c, 0xd4, 0xdb, 0xe1, 0x69, 0xa3,
-	0x17, 0xf6, 0xc2, 0x86, 0xa4, 0x38, 0x19, 0x74, 0xe5, 0x4e, 0x6e, 0xe4, 0x4a, 0x71, 0x72, 0x9a,
-	0x93, 0xe8, 0xbd, 0x30, 0xec, 0xf5, 0x99, 0x17, 0xf9, 0xb1, 0x5e, 0x36, 0x78, 0xd4, 0x6e, 0xc4,
-	0xc2, 0x13, 0x83, 0x58, 0xd3, 0xdc, 0x30, 0x68, 0x50, 0x90, 0x46, 0x22, 0x48, 0x23, 0x0e, 0xfb,
-	0xcf, 0x18, 0x6f, 0x44, 0x27, 0x8d, 0x30, 0x4a, 0xb0, 0x1b, 0x2f, 0xc5, 0xf6, 0x22, 0xbf, 0x21,
-	0xce, 0x23, 0x16, 0x37, 0xce, 0x42, 0xfe, 0x94, 0x71, 0x4d, 0x70, 0xf3, 0xa5, 0x04, 0x03, 0xe1,
-	0xf7, 0x91, 0xaa, 0xed, 0x45, 0x31, 0x5e, 0x82, 0xbf, 0x9a, 0xc8, 0x54, 0x5b, 0x84, 0x81, 0x1f,
-	0x0b, 0xdf, 0xef, 0xf9, 0x8d, 0x6e, 0x2c, 0x69, 0xd4, 0x2d, 0xa8, 0x84, 0x42, 0x77, 0xff, 0x92,
-	0x85, 0x55, 0xca, 0xe2, 0x41, 0x5f, 0x90, 0x75, 0x28, 0x73, 0xd6, 0xdd, 0x61, 0x11, 0x67, 0x6d,
-	0x4f, 0xb0, 0x8e, 0x6d, 0x55, 0xad, 0x5a, 0x61, 0x7f, 0x89, 0x8e, 0x83, 0xc9, 0x8f, 0xa0, 0xc2,
-	0x59, 0x37, 0x36, 0x10, 0x97, 0xab, 0x56, 0xad, 0xd8, 0x7c, 0xaf, 0xfe, 0x52, 0x67, 0xd4, 0x29,
-	0xeb, 0x1e, 0x79, 0xd1, 0x88, 0x64, 0x7f, 0x89, 0x4e, 0x30, 0x21, 0x4d, 0xc8, 0x70, 0xd6, 0xb5,
-	0x33, 0x92, 0xd7, 0xd5, 0x74, 0x5e, 0xfb, 0x4b, 0x14, 0x91, 0xc9, 0x26, 0x64, 0x91, 0x8b, 0x9d,
-	0x95, 0x44, 0xd7, 0xe6, 0x0a, 0xb0, 0xbf, 0x44, 0x25, 0x01, 0xb9, 0x0f, 0xf9, 0x53, 0x26, 0xbc,
-	0x8e, 0x27, 0x3c, 0x1b, 0xaa, 0x99, 0x5a, 0xb1, 0xd9, 0x48, 0x25, 0x46, 0x03, 0xd5, 0x8f, 0x34,
-	0xc5, 0x6e, 0x20, 0xf8, 0x39, 0x1d, 0x32, 0x20, 0x8f, 0xa1, 0xe4, 0x09, 0xc1, 0xd0, 0xaa, 0x7e,
-	0x18, 0xc4, 0x76, 0x51, 0x32, 0xbc, 0x39, 0x9f, 0xe1, 0x3d, 0x83, 0x4a, 0x31, 0x1d, 0x63, 0xe4,
-	0xdc, 0x81, 0xf2, 0xd8, 0x9d, 0x64, 0x0d, 0x32, 0x4f, 0xd9, 0xb9, 0x72, 0x0c, 0xc5, 0x25, 0xb9,
-	0x02, 0x2b, 0xcf, 0xbc, 0xfe, 0x80, 0x49, 0x1f, 0x94, 0xa8, 0xda, 0xdc, 0x5e, 0xbe, 0x65, 0x39,
-	0x4f, 0xe0, 0xf2, 0x14, 0xff, 0x19, 0x0c, 0x7e, 0x60, 0x32, 0x28, 0x36, 0xdf, 0x4d, 0x91, 0xda,
-	0x64, 0x67, 0xdc, 0xb4, 0x95, 0x87, 0x55, 0x2e, 0x15, 0x72, 0x7f, 0x63, 0xc1, 0xda, 0xa4, 0xab,
-	0xc9, 0x81, 0x76, 0x92, 0x25, 0xcd, 0xf2, 0xd1, 0x05, 0xa2, 0x04, 0x01, 0xda, 0x30, 0x92, 0x85,
-	0xb3, 0x09, 0x85, 0x21, 0x68, 0x9e, 0x31, 0x0a, 0x86, 0x88, 0xee, 0x26, 0x64, 0x28, 0xeb, 0x92,
-	0x0a, 0x2c, 0xfb, 0x3a, 0xae, 0xe9, 0xb2, 0xdf, 0x21, 0x55, 0xc8, 0x74, 0x58, 0x57, 0xab, 0x5e,
-	0xa9, 0x47, 0x27, 0xf5, 0x1d, 0xd6, 0xf5, 0x03, 0x1f, 0x55, 0xa4, 0x78, 0xe4, 0xfe, 0xce, 0xc2,
-	0xfc, 0x40, 0xb1, 0xc8, 0xc7, 0x63, 0x7a, 0xcc, 0x8f, 0xf6, 0x29, 0xe9, 0x1f, 0xa7, 0x4b, 0xff,
-	0xe1, 0xb8, 0x27, 0xe6, 0xa4, 0x80, 0xa9, 0xdd, 0x8f, 0xa1, 0x64, 0xfa, 0x86, 0xec, 0x43, 0xd1,
-	0x88, 0x23, 0x2d, 0xf0, 0xfa, 0x62, 0x9e, 0xa5, 0x26, 0xa9, 0xfb, 0x6f, 0x0b, 0x8a, 0xc6, 0x21,
-	0xb9, 0x0b, 0xd9, 0xa7, 0x7e, 0xa0, 0x4c, 0x58, 0x69, 0x6e, 0x2c, 0xc6, 0xf2, 0xbe, 0x1f, 0x74,
-	0xa8, 0xa4, 0x43, 0xad, 0xb9, 0x36, 0x78, 0x41, 0xa5, 0x30, 0x81, 0x6c, 0xe4, 0x89, 0x27, 0x32,
-	0xef, 0x0b, 0x54, 0xae, 0xc9, 0x07, 0xf0, 0x8a, 0x1f, 0x3c, 0x0a, 0x45, 0xd8, 0xe2, 0xac, 0xe3,
-	0x63, 0x28, 0x3c, 0x3a, 0x8f, 0x98, 0xcc, 0xf2, 0x02, 0x9d, 0x75, 0x44, 0x5a, 0x50, 0x51, 0xe0,
-	0xe3, 0xc1, 0xc9, 0xcf, 0x58, 0x5b, 0xc4, 0xf6, 0x8a, 0x54, 0xba, 0x96, 0x22, 0xe1, 0x81, 0x49,
-	0x40, 0x27, 0xe8, 0xdd, 0x3f, 0x5a, 0x50, 0x1e, 0xc3, 0x20, 0x9f, 0x8c, 0xe9, 0x7e, 0x63, 0x51,
-	0xce, 0x86, 0xf6, 0x9f, 0xc2, 0x6a, 0xc7, 0xef, 0xb1, 0x58, 0xd8, 0xcb, 0xd5, 0x4c, 0xad, 0xb0,
-	0xd5, 0xfc, 0xe6, 0xdb, 0x37, 0x97, 0xfe, 0xf1, 0xed, 0x9b, 0x1b, 0x46, 0xcd, 0x0e, 0x23, 0x16,
-	0xb4, 0xc3, 0x40, 0x78, 0x7e, 0xc0, 0x38, 0xb6, 0x9e, 0xf7, 0x15, 0x49, 0x7d, 0x47, 0xfe, 0x50,
-	0xcd, 0x01, 0xed, 0x16, 0x78, 0xa7, 0x2c, 0xb1, 0x1b, 0xae, 0x5d, 0x01, 0x65, 0xca, 0xc4, 0x80,
-	0x07, 0x94, 0xfd, 0x7c, 0x80, 0x48, 0xdf, 0x4b, 0x32, 0x53, 0x0a, 0x3d, 0xaf, 0x42, 0x22, 0x22,
-	0xd5, 0x04, 0xa4, 0x06, 0x2b, 0x8c, 0xf3, 0x90, 0xeb, 0x68, 0x24, 0x75, 0xd5, 0x04, 0xeb, 0x3c,
-	0x6a, 0xd7, 0x8f, 0x65, 0x13, 0xa4, 0x0a, 0xc1, 0x5d, 0x83, 0x4a, 0x72, 0x6b, 0x1c, 0x85, 0x41,
-	0xcc, 0xdc, 0x4b, 0x68, 0xba, 0x68, 0x20, 0x62, 0x2d, 0x87, 0xfb, 0x67, 0x0b, 0x2a, 0x09, 0x44,
-	0xe1, 0x90, 0xcf, 0xa1, 0x38, 0xca, 0xb5, 0x24, 0xa9, 0x6e, 0xa7, 0x1a, 0xd5, 0xa4, 0x37, 0x12,
-	0x55, 0xe7, 0x98, 0xc9, 0xce, 0x79, 0x00, 0x6b, 0x93, 0x08, 0x33, 0x32, 0xee, 0xed, 0xf1, 0x8c,
-	0x9b, 0x2c, 0x00, 0x46, 0x86, 0xfd, 0xcd, 0x82, 0xd7, 0x29, 0x93, 0x5d, 0xfd, 0xe0, 0xd4, 0xeb,
-	0xb1, 0xed, 0x30, 0xe8, 0xfa, 0xbd, 0xc4, 0xcc, 0x6b, 0xb2, 0xba, 0x24, 0x9c, 0xb1, 0xd0, 0xd4,
-	0x20, 0xdf, 0xea, 0x7b, 0xa2, 0x1b, 0xf2, 0x53, 0xcd, 0xbc, 0x84, 0xcc, 0x13, 0x18, 0x1d, 0x9e,
-	0x92, 0x2a, 0x14, 0x35, 0xe3, 0xa3, 0xb0, 0x93, 0xb8, 0xd3, 0x04, 0x11, 0x1b, 0x72, 0x87, 0x61,
-	0xef, 0x01, 0x3a, 0x5b, 0x65, 0x40, 0xb2, 0x25, 0x2e, 0x94, 0x34, 0x22, 0x97, 0x09, 0xb2, 0x52,
-	0xb5, 0x6a, 0x2b, 0x74, 0x0c, 0x46, 0xde, 0x80, 0xc2, 0x31, 0x8b, 0x63, 0x3f, 0x0c, 0x0e, 0x76,
-	0xec, 0x55, 0x49, 0x3f, 0x02, 0xb8, 0xbf, 0xb0, 0xc0, 0x99, 0xa5, 0x97, 0x76, 0xd2, 0xa7, 0xb0,
-	0xaa, 0xc2, 0x4e, 0xe9, 0xf6, 0xbf, 0x05, 0xac, 0xfa, 0x25, 0xaf, 0xc1, 0xaa, 0xe2, 0xae, 0x5b,
-	0x95, 0xde, 0xb9, 0x7f, 0x5a, 0x81, 0xd2, 0x31, 0x0a, 0x90, 0x58, 0xb3, 0x0e, 0x30, 0x72, 0x82,
-	0x0e, 0xdc, 0x49, 0xd7, 0x18, 0x18, 0xc4, 0x81, 0xfc, 0x9e, 0x0e, 0x12, 0x5d, 0x58, 0x86, 0x7b,
-	0xf2, 0x19, 0x14, 0x93, 0xf5, 0xc3, 0x48, 0xd8, 0x19, 0x19, 0x65, 0xb7, 0x52, 0xa2, 0xcc, 0x94,
-	0xa4, 0x6e, 0x90, 0xea, 0x18, 0x33, 0x20, 0xe4, 0x06, 0x5c, 0xf6, 0xfa, 0xfd, 0xf0, 0x4c, 0x27,
-	0x8e, 0x4c, 0x01, 0xe9, 0x82, 0x3c, 0x9d, 0x3e, 0xc0, 0x9a, 0x66, 0x00, 0xef, 0x71, 0xee, 0x9d,
-	0x63, 0xcc, 0xac, 0x4a, 0xfc, 0x59, 0x47, 0xd8, 0xcd, 0xf6, 0xfc, 0xc0, 0xeb, 0xdb, 0x20, 0x71,
-	0xd4, 0x06, 0x7d, 0xbe, 0xfb, 0x3c, 0x0a, 0xb9, 0x60, 0xfc, 0x9e, 0x10, 0xdc, 0x2e, 0x4a, 0x63,
-	0x8e, 0xc1, 0x48, 0x0b, 0x4a, 0xdb, 0x5e, 0xfb, 0x09, 0x3b, 0x38, 0x45, 0x60, 0x6c, 0x97, 0xa4,
-	0xda, 0x69, 0x15, 0x4b, 0xa2, 0x3f, 0x8c, 0xcc, 0x49, 0xc4, 0xe4, 0x40, 0xda, 0x50, 0x49, 0x54,
-	0x57, 0x79, 0x68, 0x97, 0x25, 0xcf, 0x3b, 0x17, 0x35, 0xa5, 0xa2, 0x56, 0x57, 0x4c, 0xb0, 0x44,
-	0x47, 0xee, 0x62, 0xca, 0x79, 0x82, 0xd9, 0x15, 0xa9, 0xf3, 0x70, 0xef, 0xdc, 0x85, 0xb5, 0x49,
-	0x6f, 0x5c, 0x64, 0x00, 0x70, 0x7e, 0x08, 0xaf, 0xcc, 0x10, 0xe1, 0x3b, 0xd5, 0x84, 0x3f, 0x58,
-	0x70, 0x79, 0xca, 0x6e, 0x58, 0x97, 0x65, 0x2e, 0x2a, 0x96, 0x72, 0x4d, 0x8e, 0x60, 0x05, 0xfd,
-	0x12, 0xcb, 0xb2, 0x5f, 0x6c, 0x6e, 0x5e, 0xc4, 0x11, 0x75, 0x49, 0xa9, 0x0c, 0xa6, 0xb8, 0x38,
-	0xb7, 0x00, 0x46, 0xc0, 0x0b, 0x8d, 0x41, 0x9f, 0x43, 0x59, 0x7b, 0x45, 0x27, 0xb8, 0xee, 0xc7,
-	0xd6, 0xa8, 0x1f, 0x8f, 0x5a, 0x46, 0xe6, 0x82, 0x2d, 0xc3, 0xfd, 0x12, 0x2e, 0x51, 0xe6, 0x75,
-	0xf6, 0xfc, 0x3e, 0x7b, 0x79, 0x65, 0xc4, 0x6c, 0xf5, 0xfb, 0xac, 0x85, 0x3d, 0x3f, 0xc9, 0x56,
-	0xbd, 0x27, 0xb7, 0x61, 0x85, 0x7a, 0x41, 0x8f, 0xe9, 0xab, 0xdf, 0x4e, 0xb9, 0x5a, 0x5e, 0x82,
-	0xb8, 0x54, 0x91, 0xb8, 0x77, 0xa0, 0x30, 0x84, 0x61, 0xad, 0x79, 0xd8, 0xed, 0xc6, 0x4c, 0xd5,
-	0xad, 0x0c, 0xd5, 0x3b, 0x84, 0x1f, 0xb2, 0xa0, 0xa7, 0xaf, 0xce, 0x50, 0xbd, 0x73, 0xd7, 0x71,
-	0x6c, 0x4d, 0x24, 0xd7, 0xa6, 0x21, 0x90, 0xdd, 0xc1, 0xe7, 0x81, 0x25, 0x13, 0x4c, 0xae, 0xdd,
-	0x0e, 0xb6, 0x3a, 0xaf, 0xb3, 0xe3, 0xf3, 0x97, 0x2b, 0x68, 0x43, 0x6e, 0xc7, 0xe7, 0x86, 0x7e,
-	0xc9, 0x96, 0xac, 0x63, 0x13, 0x6c, 0xf7, 0x07, 0x1d, 0xd4, 0x56, 0x30, 0x1e, 0xe8, 0x6a, 0x3f,
-	0x01, 0x75, 0x3f, 0x56, 0x76, 0x94, 0xb7, 0x68, 0x61, 0x6e, 0x40, 0x8e, 0x05, 0x82, 0xfb, 0x2c,
-	0xe9, 0x94, 0xa4, 0xae, 0x5e, 0x74, 0x75, 0xf9, 0xa2, 0x93, 0x1d, 0x99, 0x26, 0x28, 0xee, 0x26,
-	0x5c, 0x42, 0x40, 0xba, 0x23, 0x08, 0x64, 0x0d, 0x21, 0xe5, 0xda, 0xbd, 0x0d, 0x6b, 0x23, 0x42,
-	0x7d, 0xf5, 0x3a, 0x64, 0x71, 0x8e, 0xd3, 0x85, 0x78, 0xd6, 0xbd, 0xf2, 0xdc, 0x2d, 0x43, 0xb1,
-	0xe5, 0x07, 0x49, 0x4f, 0x74, 0x5f, 0x58, 0x50, 0x6a, 0x85, 0xc1, 0xa8, 0x97, 0xb4, 0xe0, 0x52,
-	0x92, 0x81, 0xf7, 0x5a, 0x07, 0xdb, 0x5e, 0x94, 0xa8, 0x52, 0x9d, 0x76, 0xb3, 0x7e, 0xda, 0xd6,
-	0x15, 0xe2, 0x56, 0x16, 0xdb, 0x0e, 0x9d, 0x24, 0x27, 0x9f, 0x40, 0xee, 0xf0, 0x70, 0x4b, 0x72,
-	0x5a, 0xbe, 0x10, 0xa7, 0x84, 0x8c, 0xdc, 0x85, 0xdc, 0x63, 0xf9, 0xe2, 0x8e, 0x75, 0x6b, 0x98,
-	0x11, 0x72, 0x4a, 0x51, 0x85, 0x46, 0x59, 0x3b, 0xe4, 0x1d, 0x9a, 0x10, 0xb9, 0xff, 0xb2, 0xa0,
-	0xf8, 0xd8, 0x1b, 0xcd, 0x5b, 0xa3, 0x01, 0xef, 0x3b, 0xf4, 0x4b, 0x3d, 0xe0, 0x5d, 0x81, 0x95,
-	0x3e, 0x7b, 0xc6, 0xfa, 0x3a, 0x54, 0xd5, 0x06, 0xa1, 0xf1, 0x93, 0x90, 0xab, 0xec, 0x2c, 0x51,
-	0xb5, 0xc1, 0xb8, 0xee, 0x30, 0xe1, 0xf9, 0x7d, 0x3b, 0x5b, 0xcd, 0x60, 0x6f, 0x55, 0x3b, 0xf4,
-	0xfa, 0x80, 0xf7, 0x65, 0x53, 0x2a, 0x50, 0x5c, 0x12, 0x17, 0xb2, 0x7e, 0xd0, 0x0d, 0x65, 0xdf,
-	0xd1, 0xd5, 0xed, 0x38, 0x1c, 0xf0, 0x36, 0x3b, 0x08, 0xba, 0x21, 0x95, 0x67, 0xe4, 0x1a, 0xac,
-	0x72, 0x4c, 0xa3, 0xd8, 0xce, 0x49, 0xa3, 0x14, 0x10, 0x4b, 0x25, 0x9b, 0x3e, 0x70, 0x2b, 0x50,
-	0x52, 0x7a, 0xeb, 0x89, 0xef, 0xd7, 0xcb, 0xf0, 0xca, 0x03, 0x76, 0xb6, 0x9d, 0xe8, 0x95, 0x18,
-	0xa4, 0x0a, 0xc5, 0x21, 0xec, 0x60, 0x47, 0x87, 0x9f, 0x09, 0xc2, 0xcb, 0x8e, 0xc2, 0x41, 0x20,
-	0x12, 0x1f, 0xca, 0xcb, 0x24, 0x84, 0xea, 0x03, 0xf2, 0x0e, 0xe4, 0x1e, 0x30, 0x71, 0x16, 0xf2,
-	0xa7, 0x52, 0xeb, 0x4a, 0xb3, 0x88, 0x38, 0x0f, 0x98, 0xc0, 0xf1, 0x88, 0x26, 0x67, 0x38, 0x73,
-	0x45, 0xc9, 0xcc, 0x95, 0x9d, 0x35, 0x73, 0x25, 0xa7, 0x64, 0x13, 0x8a, 0xed, 0x30, 0x88, 0x05,
-	0xf7, 0xfc, 0x40, 0x3e, 0x15, 0x10, 0xf9, 0x55, 0x44, 0x56, 0x8e, 0xdd, 0x1e, 0x1d, 0x52, 0x13,
-	0x93, 0x6c, 0x00, 0xb0, 0xe7, 0x82, 0x7b, 0xfb, 0x61, 0x2c, 0x62, 0x7b, 0x55, 0x0a, 0x0c, 0x48,
-	0x87, 0x80, 0x83, 0x16, 0x35, 0x4e, 0xdd, 0xd7, 0xe0, 0xca, 0xb8, 0x45, 0xb4, 0xa9, 0xee, 0xc0,
-	0xff, 0x51, 0xd6, 0x67, 0x5e, 0xcc, 0x2e, 0x6e, 0x2d, 0xd7, 0x01, 0x7b, 0x9a, 0x58, 0x33, 0xfe,
-	0x4f, 0x06, 0x8a, 0xbb, 0xcf, 0x59, 0xfb, 0x88, 0xc5, 0xb1, 0xd7, 0x93, 0x93, 0x5f, 0x8b, 0x87,
-	0x6d, 0x16, 0xc7, 0x43, 0x5e, 0x23, 0x00, 0xf9, 0x3e, 0x64, 0x0f, 0x02, 0x5f, 0xe8, 0x36, 0xb7,
-	0x9e, 0x3a, 0x78, 0xfb, 0x42, 0xf3, 0xdc, 0x5f, 0xa2, 0x92, 0x8a, 0xdc, 0x86, 0x2c, 0x16, 0x89,
-	0x45, 0x0a, 0x75, 0xc7, 0xa0, 0x45, 0x1a, 0xb2, 0x25, 0xbf, 0x38, 0xf9, 0x5f, 0x30, 0xed, 0xa5,
-	0x5a, 0x7a, 0x87, 0xf1, 0xbf, 0x60, 0x23, 0x0e, 0x9a, 0x92, 0xec, 0x42, 0xee, 0x58, 0x78, 0x5c,
-	0xb0, 0x8e, 0xf6, 0xde, 0xf5, 0xb4, 0x41, 0x44, 0x61, 0x8e, 0xb8, 0x24, 0xb4, 0x68, 0x84, 0xdd,
-	0xe7, 0xbe, 0xd0, 0xd9, 0x90, 0x66, 0x04, 0x44, 0x33, 0x14, 0xc1, 0x2d, 0x52, 0xef, 0x84, 0x01,
-	0xb3, 0x73, 0x73, 0xa9, 0x11, 0xcd, 0xa0, 0xc6, 0x2d, 0x9a, 0xe1, 0xd8, 0xef, 0xe1, 0x7c, 0x97,
-	0x9f, 0x6b, 0x06, 0x85, 0x68, 0x98, 0x41, 0x01, 0xb6, 0x72, 0xb0, 0x22, 0xa7, 0x19, 0xf7, 0xb7,
-	0x16, 0x14, 0x0d, 0x3f, 0x2d, 0x90, 0x77, 0x6f, 0x40, 0xf6, 0x88, 0x09, 0x4f, 0xfb, 0x3f, 0x2f,
-	0xb3, 0x8e, 0x09, 0x8f, 0x4a, 0x28, 0x16, 0x8e, 0xbd, 0x8e, 0x2a, 0x8a, 0x65, 0x8a, 0x4b, 0x84,
-	0x3c, 0x12, 0xe7, 0xd2, 0x65, 0x79, 0x8a, 0x4b, 0x72, 0x03, 0xf2, 0xc7, 0xac, 0x3d, 0xe0, 0xbe,
-	0x38, 0x97, 0x4e, 0xa8, 0x34, 0xd7, 0x64, 0x39, 0xd1, 0x30, 0x99, 0x9c, 0x43, 0x0c, 0xf7, 0x3e,
-	0x06, 0xe7, 0x48, 0x40, 0x02, 0xd9, 0x6d, 0x7c, 0xef, 0xa0, 0x64, 0x65, 0x2a, 0xd7, 0xf8, 0xe4,
-	0xdc, 0x9d, 0xf7, 0xe4, 0xdc, 0x4d, 0x9e, 0x9c, 0xe3, 0x4e, 0xc5, 0xee, 0x63, 0x18, 0xd9, 0xbd,
-	0x07, 0x85, 0x61, 0xe0, 0x91, 0x0a, 0x2c, 0xef, 0x75, 0xf4, 0x4d, 0xcb, 0x7b, 0xf2, 0x23, 0xc4,
-	0xee, 0xc3, 0x3d, 0x79, 0x4b, 0x9e, 0xe2, 0x72, 0xd8, 0xeb, 0x33, 0x46, 0xaf, 0xdf, 0xc4, 0xc7,
-	0xb4, 0x11, 0x7d, 0x88, 0x44, 0xc3, 0xb3, 0x38, 0x11, 0x19, 0xd7, 0x4a, 0x8d, 0x7e, 0x2c, 0x79,
-	0x49, 0x35, 0xfa, 0xb1, 0xfb, 0x16, 0x94, 0xc7, 0xfc, 0x85, 0x48, 0xf2, 0xf5, 0xa6, 0x47, 0x42,
-	0x5c, 0x6f, 0xdc, 0x85, 0x4b, 0x13, 0x5f, 0x48, 0xc8, 0x3b, 0xb0, 0xaa, 0x3e, 0x1c, 0xac, 0x2d,
-	0x39, 0xaf, 0x7f, 0xf5, 0x75, 0xf5, 0xd5, 0x09, 0x04, 0x75, 0xe8, 0x64, 0x7f, 0xf5, 0xfb, 0xab,
-	0x4b, 0x1b, 0x1e, 0x5c, 0x9e, 0xfa, 0xca, 0x40, 0xde, 0x82, 0xec, 0x31, 0xeb, 0x77, 0x13, 0xfa,
-	0x29, 0x04, 0x3c, 0x24, 0xd7, 0x20, 0x43, 0xbd, 0xb3, 0x35, 0xcb, 0xb1, 0xbf, 0xfa, 0xba, 0x7a,
-	0x65, 0xfa, 0x53, 0x85, 0x77, 0xa6, 0xae, 0x68, 0xfe, 0xbd, 0x00, 0x85, 0xc3, 0xc3, 0xad, 0x2d,
-	0xee, 0x77, 0x7a, 0x8c, 0xfc, 0xd2, 0x02, 0x32, 0xfd, 0x52, 0x24, 0x1f, 0xa6, 0x27, 0xef, 0xec,
-	0x07, 0xb3, 0xf3, 0xd1, 0x05, 0xa9, 0xf4, 0x08, 0xf1, 0x19, 0xac, 0xc8, 0xf1, 0x95, 0xbc, 0xbb,
-	0xe0, 0xb3, 0xc3, 0xa9, 0xcd, 0x47, 0xd4, 0xbc, 0xdb, 0x90, 0x4f, 0x46, 0x40, 0xb2, 0x91, 0x2a,
-	0xde, 0xd8, 0x84, 0xeb, 0xbc, 0xb7, 0x10, 0xae, 0xbe, 0xe4, 0xa7, 0x90, 0xd3, 0x93, 0x1d, 0xb9,
-	0x3e, 0x87, 0x6e, 0x34, 0x63, 0x3a, 0x1b, 0x8b, 0xa0, 0x8e, 0xd4, 0x48, 0x26, 0xb8, 0x54, 0x35,
-	0x26, 0xe6, 0xc3, 0x54, 0x35, 0xa6, 0x46, 0xc2, 0xc7, 0x90, 0xc5, 0x51, 0x8f, 0xa4, 0x95, 0x3c,
-	0x63, 0x16, 0x74, 0xd2, 0xdc, 0x35, 0x36, 0x23, 0xfe, 0x04, 0x5b, 0x83, 0x7c, 0x2e, 0xa7, 0x37,
-	0x05, 0xe3, 0x1b, 0x97, 0x73, 0x7d, 0x01, 0xcc, 0x11, 0x7b, 0xfd, 0xd4, 0xac, 0x2d, 0xf0, 0xa1,
-	0x69, 0x3e, 0xfb, 0x89, 0x4f, 0x5a, 0x21, 0x94, 0xcc, 0x8e, 0x4f, 0xea, 0x29, 0xa4, 0x33, 0x86,
-	0x25, 0xa7, 0xb1, 0x30, 0xbe, 0xbe, 0xf0, 0x4b, 0x7c, 0xb6, 0x8c, 0x4f, 0x03, 0xa4, 0x99, 0x6a,
-	0x8e, 0x99, 0x73, 0x87, 0x73, 0xf3, 0x42, 0x34, 0xfa, 0x72, 0x4f, 0x4d, 0x1b, 0x7a, 0xa2, 0x20,
-	0xe9, 0xcd, 0x73, 0x38, 0x95, 0x38, 0x0b, 0xe2, 0xd5, 0xac, 0x0f, 0x2c, 0x8c, 0x33, 0x9c, 0x32,
-	0x53, 0x79, 0x1b, 0xe3, 0x77, 0x6a, 0x9c, 0x99, 0xe3, 0xea, 0x56, 0xe9, 0x9b, 0x17, 0x57, 0xad,
-	0xbf, 0xbe, 0xb8, 0x6a, 0xfd, 0xf3, 0xc5, 0x55, 0xeb, 0x64, 0x55, 0xfe, 0x15, 0x76, 0xf3, 0xbf,
-	0x01, 0x00, 0x00, 0xff, 0xff, 0x78, 0x82, 0xaf, 0xf3, 0x5c, 0x1c, 0x00, 0x00,
+	// 2375 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xa4, 0x19, 0x4b, 0x6f, 0x1b, 0xc7,
+	0x59, 0x2b, 0x52, 0x7c, 0x7c, 0x7c, 0x88, 0x1e, 0x3b, 0xe9, 0x7a, 0x11, 0x38, 0xf4, 0x3a, 0x51,
+	0x68, 0xc5, 0x21, 0x53, 0x3a, 0x81, 0x5c, 0xbb, 0x75, 0x62, 0xbd, 0x20, 0xc5, 0x92, 0xcd, 0x8e,
+	0x5c, 0xb8, 0x08, 0x52, 0xa0, 0x2b, 0x72, 0x48, 0x6f, 0x4d, 0xed, 0x6e, 0x77, 0x87, 0x96, 0x95,
+	0x5c, 0xda, 0x5b, 0x91, 0x53, 0x4f, 0xbd, 0x05, 0x05, 0xda, 0x3f, 0xd0, 0x5e, 0x7a, 0x6b, 0xcf,
+	0x01, 0x7a, 0xe9, 0xa5, 0x97, 0x1e, 0x82, 0xc2, 0x3f, 0xa2, 0x45, 0x6f, 0xc5, 0x37, 0x33, 0x4b,
+	0x0e, 0x1f, 0x5a, 0x52, 0xc9, 0x89, 0x33, 0xdf, 0x7c, 0x8f, 0xf9, 0xde, 0xdf, 0x2c, 0xa1, 0xd4,
+	0x73, 0x38, 0x3b, 0x75, 0xce, 0xea, 0x41, 0xe8, 0x73, 0x9f, 0x5c, 0x3d, 0xf1, 0x8f, 0xcf, 0xea,
+	0xc7, 0x03, 0xb7, 0xdf, 0x79, 0xee, 0xf2, 0xfa, 0x8b, 0xef, 0xd7, 0xbb, 0xa1, 0xef, 0x71, 0xe6,
+	0x75, 0xac, 0xf7, 0x7a, 0x2e, 0x7f, 0x36, 0x38, 0xae, 0xb7, 0xfd, 0x93, 0x46, 0xcf, 0xef, 0xf9,
+	0x0d, 0x41, 0x71, 0x3c, 0xe8, 0x8a, 0x9d, 0xd8, 0x88, 0x95, 0xe4, 0x64, 0x35, 0x27, 0xd1, 0x7b,
+	0xbe, 0xdf, 0xeb, 0x33, 0x27, 0x70, 0x23, 0xb5, 0x6c, 0x84, 0x41, 0xbb, 0x11, 0x71, 0x87, 0x0f,
+	0x22, 0x45, 0x73, 0x4b, 0xa3, 0xc1, 0x8b, 0x34, 0xe2, 0x8b, 0x34, 0x22, 0xbf, 0xff, 0x82, 0x85,
+	0x8d, 0xe0, 0xb8, 0xe1, 0x07, 0x31, 0x76, 0xe3, 0x5c, 0x6c, 0x27, 0x70, 0x1b, 0xfc, 0x2c, 0x60,
+	0x51, 0xe3, 0xd4, 0x0f, 0x9f, 0xb3, 0x50, 0x11, 0xdc, 0x3e, 0x97, 0x60, 0xc0, 0xdd, 0x3e, 0x52,
+	0xb5, 0x9d, 0x20, 0x42, 0x21, 0xf8, 0xab, 0x88, 0x74, 0xb5, 0xb9, 0xef, 0xb9, 0x11, 0x77, 0xdd,
+	0x9e, 0xdb, 0xe8, 0x46, 0x82, 0x46, 0x4a, 0x41, 0x25, 0x24, 0xba, 0xfd, 0xf7, 0x34, 0x64, 0x28,
+	0x8b, 0x06, 0x7d, 0x4e, 0xd6, 0xa0, 0x14, 0xb2, 0xee, 0x36, 0x0b, 0x42, 0xd6, 0x76, 0x38, 0xeb,
+	0x98, 0x46, 0xd5, 0xa8, 0xe5, 0xf7, 0x96, 0xe8, 0x38, 0x98, 0xfc, 0x04, 0xca, 0x21, 0xeb, 0x46,
+	0x1a, 0xe2, 0x72, 0xd5, 0xa8, 0x15, 0x9a, 0xef, 0xd6, 0xcf, 0x75, 0x46, 0x9d, 0xb2, 0xee, 0xa1,
+	0x13, 0x8c, 0x48, 0xf6, 0x96, 0xe8, 0x04, 0x13, 0xd2, 0x84, 0x54, 0xc8, 0xba, 0x66, 0x4a, 0xf0,
+	0xba, 0x96, 0xcc, 0x6b, 0x6f, 0x89, 0x22, 0x32, 0xd9, 0x80, 0x34, 0x72, 0x31, 0xd3, 0x82, 0xe8,
+	0xfa, 0xdc, 0x0b, 0xec, 0x2d, 0x51, 0x41, 0x40, 0x1e, 0x42, 0xee, 0x84, 0x71, 0xa7, 0xe3, 0x70,
+	0xc7, 0x84, 0x6a, 0xaa, 0x56, 0x68, 0x36, 0x12, 0x89, 0xd1, 0x40, 0xf5, 0x43, 0x45, 0xb1, 0xe3,
+	0xf1, 0xf0, 0x8c, 0x0e, 0x19, 0x90, 0xa7, 0x50, 0x74, 0x38, 0x67, 0x68, 0x55, 0xd7, 0xf7, 0x22,
+	0xb3, 0x20, 0x18, 0xde, 0x9e, 0xcf, 0xf0, 0x81, 0x46, 0x25, 0x99, 0x8e, 0x31, 0xb2, 0xee, 0x41,
+	0x69, 0x4c, 0x26, 0xa9, 0x40, 0xea, 0x39, 0x3b, 0x93, 0x8e, 0xa1, 0xb8, 0x24, 0x57, 0x60, 0xe5,
+	0x85, 0xd3, 0x1f, 0x30, 0xe1, 0x83, 0x22, 0x95, 0x9b, 0xbb, 0xcb, 0x77, 0x0c, 0xeb, 0x19, 0x5c,
+	0x9a, 0xe2, 0x3f, 0x83, 0xc1, 0x8f, 0x74, 0x06, 0x85, 0xe6, 0x3b, 0x09, 0xb7, 0xd6, 0xd9, 0x69,
+	0x92, 0x36, 0x73, 0x90, 0x09, 0x85, 0x42, 0xf6, 0xef, 0x0c, 0xa8, 0x4c, 0xba, 0x9a, 0xec, 0x2b,
+	0x27, 0x19, 0xc2, 0x2c, 0x1f, 0x5e, 0x20, 0x4a, 0x10, 0xa0, 0x0c, 0x23, 0x58, 0x58, 0x1b, 0x90,
+	0x1f, 0x82, 0xe6, 0x19, 0x23, 0xaf, 0x5d, 0xd1, 0xde, 0x80, 0x14, 0x65, 0x5d, 0x52, 0x86, 0x65,
+	0x57, 0xc5, 0x35, 0x5d, 0x76, 0x3b, 0xa4, 0x0a, 0xa9, 0x0e, 0xeb, 0x2a, 0xd5, 0xcb, 0xf5, 0xe0,
+	0xb8, 0xbe, 0xcd, 0xba, 0xae, 0xe7, 0xa2, 0x8a, 0x14, 0x8f, 0xec, 0x3f, 0x18, 0x98, 0x1f, 0x78,
+	0x2d, 0xf2, 0xd1, 0x98, 0x1e, 0xf3, 0xa3, 0x7d, 0xea, 0xf6, 0x4f, 0x93, 0x6f, 0xff, 0xc1, 0xb8,
+	0x27, 0xe6, 0xa4, 0x80, 0xae, 0xdd, 0x4f, 0xa1, 0xa8, 0xfb, 0x86, 0xec, 0x41, 0x41, 0x8b, 0x23,
+	0x75, 0xe1, 0xb5, 0xc5, 0x3c, 0x4b, 0x75, 0x52, 0xfb, 0xbf, 0x06, 0x14, 0xb4, 0x43, 0x72, 0x1f,
+	0xd2, 0xcf, 0x5d, 0x4f, 0x9a, 0xb0, 0xdc, 0x5c, 0x5f, 0x8c, 0xe5, 0x43, 0xd7, 0xeb, 0x50, 0x41,
+	0x87, 0x5a, 0x87, 0xca, 0xe0, 0x79, 0x99, 0xc2, 0x04, 0xd2, 0x81, 0xc3, 0x9f, 0x89, 0xbc, 0xcf,
+	0x53, 0xb1, 0x26, 0xef, 0xc3, 0x65, 0xd7, 0x7b, 0xe2, 0x73, 0xbf, 0x15, 0xb2, 0x8e, 0x8b, 0xa1,
+	0xf0, 0xe4, 0x2c, 0x60, 0x22, 0xcb, 0xf3, 0x74, 0xd6, 0x11, 0x69, 0x41, 0x59, 0x82, 0x8f, 0x06,
+	0xc7, 0xbf, 0x60, 0x6d, 0x1e, 0x99, 0x2b, 0x42, 0xe9, 0x5a, 0xc2, 0x0d, 0xf7, 0x75, 0x02, 0x3a,
+	0x41, 0x6f, 0xff, 0xd9, 0x80, 0xd2, 0x18, 0x06, 0xf9, 0x78, 0x4c, 0xf7, 0x5b, 0x8b, 0x72, 0xd6,
+	0xb4, 0xff, 0x04, 0x32, 0x1d, 0xb7, 0xc7, 0x22, 0x6e, 0x2e, 0x57, 0x53, 0xb5, 0xfc, 0x66, 0xf3,
+	0xeb, 0x6f, 0xde, 0x5c, 0xfa, 0xd7, 0x37, 0x6f, 0xae, 0x6b, 0x35, 0xdb, 0x0f, 0x98, 0xd7, 0xf6,
+	0x3d, 0xee, 0xb8, 0x1e, 0x0b, 0xb1, 0xf5, 0xbc, 0x27, 0x49, 0xea, 0xdb, 0xe2, 0x87, 0x2a, 0x0e,
+	0x68, 0x37, 0xcf, 0x39, 0x61, 0xb1, 0xdd, 0x70, 0x6d, 0x73, 0x28, 0x51, 0xc6, 0x07, 0xa1, 0x47,
+	0xd9, 0x2f, 0x07, 0x88, 0xf4, 0x83, 0x38, 0x33, 0xc5, 0xa5, 0xe7, 0x55, 0x48, 0x44, 0xa4, 0x8a,
+	0x80, 0xd4, 0x60, 0x85, 0x85, 0xa1, 0x1f, 0xaa, 0x68, 0x24, 0x75, 0xd9, 0x04, 0xeb, 0x61, 0xd0,
+	0xae, 0x1f, 0x89, 0x26, 0x48, 0x25, 0x82, 0x5d, 0x81, 0x72, 0x2c, 0x35, 0x0a, 0x7c, 0x2f, 0x62,
+	0xf6, 0x2a, 0x9a, 0x2e, 0x18, 0xf0, 0x48, 0xdd, 0xc3, 0xfe, 0x9b, 0x01, 0xe5, 0x18, 0x22, 0x71,
+	0xc8, 0x67, 0x50, 0x18, 0xe5, 0x5a, 0x9c, 0x54, 0x77, 0x13, 0x8d, 0xaa, 0xd3, 0x6b, 0x89, 0xaa,
+	0x72, 0x4c, 0x67, 0x67, 0x3d, 0x82, 0xca, 0x24, 0xc2, 0x8c, 0x8c, 0x7b, 0x6b, 0x3c, 0xe3, 0x26,
+	0x0b, 0x80, 0x96, 0x61, 0xff, 0x34, 0xe0, 0x2a, 0x65, 0xa2, 0xab, 0xef, 0x9f, 0x38, 0x3d, 0xb6,
+	0xe5, 0x7b, 0x5d, 0xb7, 0x17, 0x9b, 0xb9, 0x22, 0xaa, 0x4b, 0xcc, 0x19, 0x0b, 0x4d, 0x0d, 0x72,
+	0xad, 0xbe, 0xc3, 0xbb, 0x7e, 0x78, 0xa2, 0x98, 0x17, 0x91, 0x79, 0x0c, 0xa3, 0xc3, 0x53, 0x52,
+	0x85, 0x82, 0x62, 0x7c, 0xe8, 0x77, 0x62, 0x77, 0xea, 0x20, 0x62, 0x42, 0xf6, 0xc0, 0xef, 0x3d,
+	0x42, 0x67, 0xcb, 0x0c, 0x88, 0xb7, 0xc4, 0x86, 0xa2, 0x42, 0x0c, 0x45, 0x82, 0xac, 0x54, 0x8d,
+	0xda, 0x0a, 0x1d, 0x83, 0x91, 0x37, 0x20, 0x7f, 0xc4, 0xa2, 0xc8, 0xf5, 0xbd, 0xfd, 0x6d, 0x33,
+	0x23, 0xe8, 0x47, 0x00, 0xfb, 0x57, 0x06, 0x58, 0xb3, 0xf4, 0x52, 0x4e, 0xfa, 0x04, 0x32, 0x32,
+	0xec, 0xa4, 0x6e, 0xdf, 0x2e, 0x60, 0xe5, 0x2f, 0x79, 0x1d, 0x32, 0x92, 0xbb, 0x6a, 0x55, 0x6a,
+	0x67, 0xff, 0x65, 0x05, 0x8a, 0x47, 0x78, 0x81, 0xd8, 0x9a, 0x75, 0x80, 0x91, 0x13, 0x54, 0xe0,
+	0x4e, 0xba, 0x46, 0xc3, 0x20, 0x16, 0xe4, 0x76, 0x55, 0x90, 0xa8, 0xc2, 0x32, 0xdc, 0x93, 0x4f,
+	0xa1, 0x10, 0xaf, 0x1f, 0x07, 0xdc, 0x4c, 0x89, 0x28, 0xbb, 0x93, 0x10, 0x65, 0xfa, 0x4d, 0xea,
+	0x1a, 0xa9, 0x8a, 0x31, 0x0d, 0x42, 0x6e, 0xc1, 0x25, 0xa7, 0xdf, 0xf7, 0x4f, 0x55, 0xe2, 0x88,
+	0x14, 0x10, 0x2e, 0xc8, 0xd1, 0xe9, 0x03, 0xac, 0x69, 0x1a, 0xf0, 0x41, 0x18, 0x3a, 0x67, 0x18,
+	0x33, 0x19, 0x81, 0x3f, 0xeb, 0x08, 0xbb, 0xd9, 0xae, 0xeb, 0x39, 0x7d, 0x13, 0x04, 0x8e, 0xdc,
+	0xa0, 0xcf, 0x77, 0x5e, 0x06, 0x7e, 0xc8, 0x59, 0xf8, 0x80, 0xf3, 0xd0, 0x2c, 0x08, 0x63, 0x8e,
+	0xc1, 0x48, 0x0b, 0x8a, 0x5b, 0x4e, 0xfb, 0x19, 0xdb, 0x3f, 0x41, 0x60, 0x64, 0x16, 0x85, 0xda,
+	0x49, 0x15, 0x4b, 0xa0, 0x3f, 0x0e, 0xf4, 0x49, 0x44, 0xe7, 0x40, 0xda, 0x50, 0x8e, 0x55, 0x97,
+	0x79, 0x68, 0x96, 0x04, 0xcf, 0x7b, 0x17, 0x35, 0xa5, 0xa4, 0x96, 0x22, 0x26, 0x58, 0xa2, 0x23,
+	0x77, 0x30, 0xe5, 0x1c, 0xce, 0xcc, 0xb2, 0xd0, 0x79, 0xb8, 0xb7, 0xee, 0x43, 0x65, 0xd2, 0x1b,
+	0x17, 0x19, 0x00, 0xac, 0x1f, 0xc3, 0xe5, 0x19, 0x57, 0xf8, 0x4e, 0x35, 0xe1, 0x4f, 0x06, 0x5c,
+	0x9a, 0xb2, 0x1b, 0xd6, 0x65, 0x91, 0x8b, 0x92, 0xa5, 0x58, 0x93, 0x43, 0x58, 0x41, 0xbf, 0x44,
+	0xa2, 0xec, 0x17, 0x9a, 0x1b, 0x17, 0x71, 0x44, 0x5d, 0x50, 0x4a, 0x83, 0x49, 0x2e, 0xd6, 0x1d,
+	0x80, 0x11, 0xf0, 0x42, 0x63, 0xd0, 0x67, 0x50, 0x52, 0x5e, 0x51, 0x09, 0xae, 0xfa, 0xb1, 0x31,
+	0xea, 0xc7, 0xa3, 0x96, 0x91, 0xba, 0x60, 0xcb, 0xb0, 0xbf, 0x80, 0x55, 0xca, 0x9c, 0xce, 0xae,
+	0xdb, 0x67, 0xe7, 0x57, 0x46, 0xcc, 0x56, 0xb7, 0xcf, 0x5a, 0xd8, 0xf3, 0xe3, 0x6c, 0x55, 0x7b,
+	0x72, 0x17, 0x56, 0xa8, 0xe3, 0xf5, 0x98, 0x12, 0xfd, 0x56, 0x82, 0x68, 0x21, 0x04, 0x71, 0xa9,
+	0x24, 0xb1, 0xef, 0x41, 0x7e, 0x08, 0xc3, 0x5a, 0xf3, 0xb8, 0xdb, 0x8d, 0x98, 0xac, 0x5b, 0x29,
+	0xaa, 0x76, 0x08, 0x3f, 0x60, 0x5e, 0x4f, 0x89, 0x4e, 0x51, 0xb5, 0xb3, 0xd7, 0x70, 0x6c, 0x8d,
+	0x6f, 0xae, 0x4c, 0x43, 0x20, 0xbd, 0x8d, 0xcf, 0x03, 0x43, 0x24, 0x98, 0x58, 0xdb, 0x1d, 0x6c,
+	0x75, 0x4e, 0x67, 0xdb, 0x0d, 0xcf, 0x57, 0xd0, 0x84, 0xec, 0xb6, 0x1b, 0x6a, 0xfa, 0xc5, 0x5b,
+	0xb2, 0x86, 0x4d, 0xb0, 0xdd, 0x1f, 0x74, 0x50, 0x5b, 0xce, 0x42, 0x4f, 0x55, 0xfb, 0x09, 0xa8,
+	0xfd, 0x91, 0xb4, 0xa3, 0x90, 0xa2, 0x2e, 0x73, 0x0b, 0xb2, 0xcc, 0xe3, 0xa1, 0xcb, 0xe2, 0x4e,
+	0x49, 0xea, 0xf2, 0x45, 0x57, 0x17, 0x2f, 0x3a, 0xd1, 0x91, 0x69, 0x8c, 0x62, 0x6f, 0xc0, 0x2a,
+	0x02, 0x92, 0x1d, 0x41, 0x20, 0xad, 0x5d, 0x52, 0xac, 0xed, 0xbb, 0x50, 0x19, 0x11, 0x2a, 0xd1,
+	0x6b, 0x90, 0xc6, 0x39, 0x4e, 0x15, 0xe2, 0x59, 0x72, 0xc5, 0xb9, 0x7d, 0x03, 0x56, 0xe3, 0x6c,
+	0x3d, 0x57, 0xa8, 0x4d, 0xa0, 0x32, 0x42, 0x52, 0xd3, 0x42, 0x09, 0x0a, 0x2d, 0xd7, 0x8b, 0x9b,
+	0xa9, 0xfd, 0xca, 0x80, 0x62, 0xcb, 0xf7, 0x46, 0x4d, 0xa8, 0x05, 0xab, 0x71, 0xea, 0x3e, 0x68,
+	0xed, 0x6f, 0x39, 0x41, 0x6c, 0x83, 0xea, 0x74, 0x7c, 0xa8, 0x37, 0x71, 0x5d, 0x22, 0x6e, 0xa6,
+	0xb1, 0x5f, 0xd1, 0x49, 0x72, 0xf2, 0x31, 0x64, 0x0f, 0x0e, 0x36, 0x05, 0xa7, 0xe5, 0x0b, 0x71,
+	0x8a, 0xc9, 0xc8, 0x7d, 0xc8, 0x3e, 0x15, 0x4f, 0xf5, 0x48, 0xf5, 0x94, 0x19, 0xb1, 0x2a, 0x2d,
+	0x24, 0xd1, 0x28, 0x6b, 0xfb, 0x61, 0x87, 0xc6, 0x44, 0xf6, 0x7f, 0x0c, 0x28, 0x3c, 0x75, 0x46,
+	0x83, 0xda, 0x68, 0x32, 0xfc, 0x0e, 0x8d, 0x56, 0x4d, 0x86, 0x57, 0x60, 0xa5, 0xcf, 0x5e, 0xb0,
+	0xbe, 0x8a, 0x71, 0xb9, 0x41, 0x68, 0xf4, 0xcc, 0x0f, 0x65, 0x5a, 0x17, 0xa9, 0xdc, 0x60, 0x42,
+	0x74, 0x18, 0x77, 0xdc, 0xbe, 0x99, 0xae, 0xa6, 0xb0, 0x29, 0xcb, 0x1d, 0x7a, 0x6e, 0x10, 0xf6,
+	0x45, 0x37, 0xcb, 0x53, 0x5c, 0x12, 0x1b, 0xd2, 0xae, 0xd7, 0xf5, 0x45, 0xc3, 0x52, 0x65, 0xf1,
+	0xc8, 0x1f, 0x84, 0x6d, 0xb6, 0xef, 0x75, 0x7d, 0x2a, 0xce, 0xc8, 0x75, 0xc8, 0x84, 0x98, 0x7f,
+	0x91, 0x99, 0x15, 0x46, 0xc9, 0x23, 0x96, 0xcc, 0x52, 0x75, 0x60, 0x97, 0xa1, 0x28, 0xf5, 0x56,
+	0xce, 0xff, 0xed, 0x32, 0x5c, 0x7e, 0xc4, 0x4e, 0xb7, 0x62, 0xbd, 0x62, 0x83, 0x54, 0xa1, 0x30,
+	0x84, 0xed, 0x6f, 0xab, 0x10, 0xd2, 0x41, 0x28, 0xec, 0xd0, 0x1f, 0x78, 0x3c, 0xf6, 0xa1, 0x10,
+	0x26, 0x20, 0x54, 0x1d, 0x90, 0xb7, 0x21, 0xfb, 0x88, 0xf1, 0x53, 0x3f, 0x7c, 0x2e, 0xb4, 0x2e,
+	0x37, 0x0b, 0x88, 0xf3, 0x88, 0x71, 0x9c, 0xab, 0x68, 0x7c, 0x86, 0xc3, 0x5a, 0x10, 0x0f, 0x6b,
+	0xe9, 0x59, 0xc3, 0x5a, 0x7c, 0x4a, 0x36, 0xa0, 0xd0, 0xf6, 0xbd, 0x88, 0x87, 0x8e, 0xeb, 0x89,
+	0x37, 0x06, 0x22, 0xbf, 0x86, 0xc8, 0xd2, 0xb1, 0x5b, 0xa3, 0x43, 0xaa, 0x63, 0x92, 0x75, 0x00,
+	0xf6, 0x92, 0x87, 0xce, 0x9e, 0x1f, 0xf1, 0xc8, 0xcc, 0x88, 0x0b, 0x03, 0xd2, 0x21, 0x60, 0xbf,
+	0x45, 0xb5, 0x53, 0xfb, 0x75, 0xb8, 0x32, 0x6e, 0x11, 0x65, 0xaa, 0x7b, 0xf0, 0x3d, 0xca, 0xfa,
+	0xcc, 0x89, 0xd8, 0xc5, 0xad, 0x65, 0x5b, 0x60, 0x4e, 0x13, 0x2b, 0xc6, 0xff, 0x4b, 0x41, 0x61,
+	0xe7, 0x25, 0x6b, 0x1f, 0xb2, 0x28, 0x72, 0x7a, 0x62, 0x64, 0x6c, 0x85, 0x7e, 0x9b, 0x45, 0xd1,
+	0x90, 0xd7, 0x08, 0x40, 0x7e, 0x08, 0xe9, 0x7d, 0xcf, 0xe5, 0xaa, 0x3f, 0xae, 0x25, 0x4e, 0xec,
+	0x2e, 0x57, 0x3c, 0xf7, 0x96, 0xa8, 0xa0, 0x22, 0x77, 0x21, 0x8d, 0xd5, 0x65, 0x91, 0x0a, 0xdf,
+	0xd1, 0x68, 0x91, 0x86, 0x6c, 0x8a, 0x4f, 0x55, 0xee, 0xe7, 0x4c, 0x79, 0xa9, 0x96, 0xdc, 0x9a,
+	0xdc, 0xcf, 0xd9, 0x88, 0x83, 0xa2, 0x24, 0x3b, 0x90, 0x3d, 0xe2, 0x4e, 0xc8, 0x59, 0x47, 0x79,
+	0xef, 0x66, 0xd2, 0x04, 0x23, 0x31, 0x47, 0x5c, 0x62, 0x5a, 0x34, 0xc2, 0xce, 0x4b, 0x97, 0xab,
+	0x6c, 0x48, 0x32, 0x02, 0xa2, 0x69, 0x8a, 0xe0, 0x16, 0xa9, 0xb7, 0x7d, 0x8f, 0x99, 0xd9, 0xb9,
+	0xd4, 0x88, 0xa6, 0x51, 0xe3, 0x16, 0xcd, 0x70, 0xe4, 0xf6, 0x70, 0x30, 0xcc, 0xcd, 0x35, 0x83,
+	0x44, 0xd4, 0xcc, 0x20, 0x01, 0x9b, 0x59, 0x58, 0x11, 0x63, 0x90, 0xfd, 0x7b, 0x03, 0x0a, 0x9a,
+	0x9f, 0x16, 0xc8, 0xbb, 0x37, 0x20, 0x7d, 0xc8, 0xb8, 0xa3, 0xfc, 0x9f, 0x13, 0x59, 0xc7, 0xb8,
+	0x43, 0x05, 0x14, 0x0b, 0xc7, 0x6e, 0x47, 0x16, 0xc5, 0x12, 0xc5, 0x25, 0x42, 0x9e, 0xf0, 0x33,
+	0xe1, 0xb2, 0x1c, 0xc5, 0x25, 0xb9, 0x05, 0xb9, 0x23, 0xd6, 0x1e, 0x84, 0x2e, 0x3f, 0x13, 0x4e,
+	0x28, 0x37, 0x2b, 0xa2, 0x9c, 0x28, 0x98, 0x48, 0xce, 0x21, 0x86, 0xfd, 0x10, 0x83, 0x73, 0x74,
+	0x41, 0x02, 0xe9, 0x2d, 0x7c, 0x28, 0xe1, 0xcd, 0x4a, 0x54, 0xac, 0xf1, 0xad, 0xba, 0x33, 0xef,
+	0xad, 0xba, 0x13, 0xbf, 0x55, 0xc7, 0x9d, 0x8a, 0xdd, 0x47, 0x33, 0xb2, 0xfd, 0x00, 0xf2, 0xc3,
+	0xc0, 0x23, 0x65, 0x58, 0xde, 0xed, 0x28, 0x49, 0xcb, 0xbb, 0xe2, 0xeb, 0xc5, 0xce, 0xe3, 0x5d,
+	0x21, 0x25, 0x47, 0x71, 0x39, 0x1c, 0x12, 0x52, 0xda, 0x90, 0xb0, 0x81, 0xaf, 0x70, 0x2d, 0xfa,
+	0x10, 0x89, 0xfa, 0xa7, 0x51, 0x7c, 0x65, 0x5c, 0x4b, 0x35, 0xfa, 0x91, 0xe0, 0x25, 0xd4, 0xe8,
+	0x47, 0xf6, 0x0d, 0x28, 0x8d, 0xf9, 0x0b, 0x91, 0xc4, 0xb3, 0x4f, 0xcd, 0x92, 0xb8, 0x5e, 0xbf,
+	0x0f, 0xab, 0x13, 0x9f, 0x56, 0xc8, 0xdb, 0x90, 0x91, 0x5f, 0x1c, 0x2a, 0x4b, 0xd6, 0xd5, 0x2f,
+	0xbf, 0xaa, 0xbe, 0x36, 0x81, 0x20, 0x0f, 0xad, 0xf4, 0x6f, 0xfe, 0x78, 0x6d, 0x69, 0xdd, 0x81,
+	0x4b, 0x53, 0x9f, 0x27, 0xc8, 0x0d, 0x48, 0x1f, 0xb1, 0x7e, 0x37, 0xa6, 0x9f, 0x42, 0xc0, 0x43,
+	0x72, 0x1d, 0x52, 0xd4, 0x39, 0xad, 0x18, 0x96, 0xf9, 0xe5, 0x57, 0xd5, 0x2b, 0xd3, 0xdf, 0x38,
+	0x9c, 0x53, 0x29, 0xa2, 0xf9, 0x57, 0x80, 0xfc, 0xc1, 0xc1, 0xe6, 0x66, 0xe8, 0x76, 0x7a, 0x8c,
+	0xfc, 0xda, 0x00, 0x32, 0xfd, 0xc4, 0x24, 0x1f, 0x24, 0x27, 0xef, 0xec, 0x97, 0xb6, 0xf5, 0xe1,
+	0x05, 0xa9, 0xd4, 0x08, 0xf1, 0x29, 0xac, 0x88, 0xb9, 0x97, 0xbc, 0xb3, 0xe0, 0x7b, 0xc5, 0xaa,
+	0xcd, 0x47, 0x54, 0xbc, 0xdb, 0x90, 0x8b, 0x67, 0x47, 0xb2, 0x9e, 0x78, 0xbd, 0xb1, 0xd1, 0xd8,
+	0x7a, 0x77, 0x21, 0x5c, 0x25, 0xe4, 0xe7, 0x90, 0x55, 0x23, 0x21, 0xb9, 0x39, 0x87, 0x6e, 0x34,
+	0x9c, 0x5a, 0xeb, 0x8b, 0xa0, 0x8e, 0xd4, 0x88, 0x47, 0xbf, 0x44, 0x35, 0x26, 0x06, 0xcb, 0x44,
+	0x35, 0xa6, 0x66, 0xc9, 0xf6, 0xe8, 0x85, 0x97, 0x28, 0x64, 0x62, 0x90, 0x4c, 0x14, 0x32, 0x39,
+	0x4f, 0x92, 0xa7, 0x90, 0xc6, 0x79, 0x92, 0x24, 0xd5, 0x55, 0x6d, 0xe0, 0xb4, 0x92, 0x62, 0x62,
+	0x6c, 0x10, 0xfd, 0x19, 0xf6, 0x1f, 0xf1, 0x98, 0x4f, 0xee, 0x3c, 0xda, 0x17, 0x38, 0xeb, 0xe6,
+	0x02, 0x98, 0x23, 0xf6, 0xea, 0x21, 0x5c, 0x5b, 0xe0, 0x33, 0xd8, 0x7c, 0xf6, 0x13, 0x1f, 0xdc,
+	0x7c, 0x28, 0xea, 0x63, 0x05, 0xa9, 0x27, 0x90, 0xce, 0x98, 0xc8, 0xac, 0xc6, 0xc2, 0xf8, 0x4a,
+	0xe0, 0x17, 0xf8, 0xa8, 0x1a, 0x1f, 0x39, 0x48, 0x33, 0xd1, 0x1c, 0x33, 0x87, 0x1b, 0xeb, 0xf6,
+	0x85, 0x68, 0x94, 0x70, 0x47, 0x8e, 0x34, 0x6a, 0x6c, 0x21, 0xc9, 0x1d, 0x7a, 0x38, 0xfa, 0x58,
+	0x0b, 0xe2, 0xd5, 0x8c, 0xf7, 0x0d, 0x8c, 0x33, 0x1c, 0x65, 0x13, 0x79, 0x6b, 0x33, 0x7e, 0x62,
+	0x9c, 0xe9, 0x33, 0xf1, 0x66, 0xf1, 0xeb, 0x57, 0xd7, 0x8c, 0x7f, 0xbc, 0xba, 0x66, 0xfc, 0xfb,
+	0xd5, 0x35, 0xe3, 0x38, 0x23, 0xfe, 0xa8, 0xbb, 0xfd, 0xff, 0x00, 0x00, 0x00, 0xff, 0xff, 0xab,
+	0x58, 0x65, 0x65, 0xfa, 0x1c, 0x00, 0x00,
 }
 
 // Reference imports to suppress errors if they are not otherwise used.
@@ -2681,6 +2771,8 @@ type LLBBridgeClient interface {
 	ReadDir(ctx context.Context, in *ReadDirRequest, opts ...grpc.CallOption) (*ReadDirResponse, error)
 	// apicaps:CapStatFile
 	StatFile(ctx context.Context, in *StatFileRequest, opts ...grpc.CallOption) (*StatFileResponse, error)
+	// apicaps:CapGatewayEvaluate
+	Evaluate(ctx context.Context, in *EvaluateRequest, opts ...grpc.CallOption) (*EvaluateResponse, error)
 	Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PongResponse, error)
 	Return(ctx context.Context, in *ReturnRequest, opts ...grpc.CallOption) (*ReturnResponse, error)
 	// apicaps:CapFrontendInputs
@@ -2745,6 +2837,15 @@ func (c *lLBBridgeClient) StatFile(ctx context.Context, in *StatFileRequest, opt
 	return out, nil
 }
 
+func (c *lLBBridgeClient) Evaluate(ctx context.Context, in *EvaluateRequest, opts ...grpc.CallOption) (*EvaluateResponse, error) {
+	out := new(EvaluateResponse)
+	err := c.cc.Invoke(ctx, "/moby.buildkit.v1.frontend.LLBBridge/Evaluate", in, out, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
 func (c *lLBBridgeClient) Ping(ctx context.Context, in *PingRequest, opts ...grpc.CallOption) (*PongResponse, error) {
 	out := new(PongResponse)
 	err := c.cc.Invoke(ctx, "/moby.buildkit.v1.frontend.LLBBridge/Ping", in, out, opts...)
@@ -2842,6 +2943,8 @@ type LLBBridgeServer interface {
 	ReadDir(context.Context, *ReadDirRequest) (*ReadDirResponse, error)
 	// apicaps:CapStatFile
 	StatFile(context.Context, *StatFileRequest) (*StatFileResponse, error)
+	// apicaps:CapGatewayEvaluate
+	Evaluate(context.Context, *EvaluateRequest) (*EvaluateResponse, error)
 	Ping(context.Context, *PingRequest) (*PongResponse, error)
 	Return(context.Context, *ReturnRequest) (*ReturnResponse, error)
 	// apicaps:CapFrontendInputs
@@ -2872,6 +2975,9 @@ func (*UnimplementedLLBBridgeServer) ReadDir(ctx context.Context, req *ReadDirRe
 func (*UnimplementedLLBBridgeServer) StatFile(ctx context.Context, req *StatFileRequest) (*StatFileResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method StatFile not implemented")
 }
+func (*UnimplementedLLBBridgeServer) Evaluate(ctx context.Context, req *EvaluateRequest) (*EvaluateResponse, error) {
+	return nil, status.Errorf(codes.Unimplemented, "method Evaluate not implemented")
+}
 func (*UnimplementedLLBBridgeServer) Ping(ctx context.Context, req *PingRequest) (*PongResponse, error) {
 	return nil, status.Errorf(codes.Unimplemented, "method Ping not implemented")
 }
@@ -2988,6 +3094,24 @@ func _LLBBridge_StatFile_Handler(srv interface{}, ctx context.Context, dec func(
 	return interceptor(ctx, in, info, handler)
 }
 
+func _LLBBridge_Evaluate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(EvaluateRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LLBBridgeServer).Evaluate(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/moby.buildkit.v1.frontend.LLBBridge/Evaluate",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LLBBridgeServer).Evaluate(ctx, req.(*EvaluateRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
 func _LLBBridge_Ping_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
 	in := new(PingRequest)
 	if err := dec(in); err != nil {
@@ -3146,6 +3270,10 @@ var _LLBBridge_serviceDesc = grpc.ServiceDesc{
 			MethodName: "StatFile",
 			Handler:    _LLBBridge_StatFile_Handler,
 		},
+		{
+			MethodName: "Evaluate",
+			Handler:    _LLBBridge_Evaluate_Handler,
+		},
 		{
 			MethodName: "Ping",
 			Handler:    _LLBBridge_Ping_Handler,
@@ -4458,6 +4586,67 @@ func (m *StatFileResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
 	return len(dAtA) - i, nil
 }
 
+func (m *EvaluateRequest) 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 *EvaluateRequest) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EvaluateRequest) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	if len(m.Ref) > 0 {
+		i -= len(m.Ref)
+		copy(dAtA[i:], m.Ref)
+		i = encodeVarintGateway(dAtA, i, uint64(len(m.Ref)))
+		i--
+		dAtA[i] = 0xa
+	}
+	return len(dAtA) - i, nil
+}
+
+func (m *EvaluateResponse) 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 *EvaluateResponse) MarshalTo(dAtA []byte) (int, error) {
+	size := m.Size()
+	return m.MarshalToSizedBuffer(dAtA[:size])
+}
+
+func (m *EvaluateResponse) MarshalToSizedBuffer(dAtA []byte) (int, error) {
+	i := len(dAtA)
+	_ = i
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		i -= len(m.XXX_unrecognized)
+		copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return len(dAtA) - i, nil
+}
+
 func (m *PingRequest) Marshal() (dAtA []byte, err error) {
 	size := m.Size()
 	dAtA = make([]byte, size)
@@ -5940,6 +6129,34 @@ func (m *StatFileResponse) Size() (n int) {
 	return n
 }
 
+func (m *EvaluateRequest) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	l = len(m.Ref)
+	if l > 0 {
+		n += 1 + l + sovGateway(uint64(l))
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *EvaluateResponse) Size() (n int) {
+	if m == nil {
+		return 0
+	}
+	var l int
+	_ = l
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
 func (m *PingRequest) Size() (n int) {
 	if m == nil {
 		return 0
@@ -10065,6 +10282,140 @@ func (m *StatFileResponse) Unmarshal(dAtA []byte) error {
 	}
 	return nil
 }
+func (m *EvaluateRequest) 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 ErrIntOverflowGateway
+			}
+			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: EvaluateRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: EvaluateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Ref", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowGateway
+				}
+				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 ErrInvalidLengthGateway
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex < 0 {
+				return ErrInvalidLengthGateway
+			}
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Ref = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGateway(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGateway
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *EvaluateResponse) 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 ErrIntOverflowGateway
+			}
+			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: EvaluateResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: EvaluateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipGateway(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if (skippy < 0) || (iNdEx+skippy) < 0 {
+				return ErrInvalidLengthGateway
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
 func (m *PingRequest) Unmarshal(dAtA []byte) error {
 	l := len(dAtA)
 	iNdEx := 0
diff --git a/frontend/gateway/pb/gateway.proto b/frontend/gateway/pb/gateway.proto
index 314fa94c09ca..d26058357c83 100644
--- a/frontend/gateway/pb/gateway.proto
+++ b/frontend/gateway/pb/gateway.proto
@@ -25,6 +25,8 @@ service LLBBridge {
 	rpc ReadDir(ReadDirRequest) returns (ReadDirResponse);
 	// apicaps:CapStatFile
 	rpc StatFile(StatFileRequest) returns (StatFileResponse);
+	// apicaps:CapGatewayEvaluate
+	rpc Evaluate(EvaluateRequest) returns (EvaluateResponse);
 	rpc Ping(PingRequest) returns (PongResponse);
 	rpc Return(ReturnRequest) returns (ReturnResponse);
 	// apicaps:CapFrontendInputs
@@ -195,6 +197,13 @@ message StatFileResponse {
 	fsutil.types.Stat stat = 1;
 }
 
+message EvaluateRequest {
+	string Ref = 1;
+}
+
+message EvaluateResponse {
+}
+
 message PingRequest{
 }
 message PongResponse{

From d709afdb96f539c49836f5874f7331a11287bee0 Mon Sep 17 00:00:00 2001
From: Justin Chadwell <me@jedevc.com>
Date: Tue, 5 Jul 2022 14:43:37 +0100
Subject: [PATCH 2/5] solver: always respect value of evaluate field

Always use the value of the evaluate field to force result generation,
which previously was not performed for frontends. This improves API
consistency, and ensures the value is used regardless of whether
the solver uses a frontend, or a raw definition.

Signed-off-by: Justin Chadwell <me@jedevc.com>
---
 solver/llbsolver/bridge.go | 9 ++++++---
 1 file changed, 6 insertions(+), 3 deletions(-)

diff --git a/solver/llbsolver/bridge.go b/solver/llbsolver/bridge.go
index d28fde356992..b0ec157b46ea 100644
--- a/solver/llbsolver/bridge.go
+++ b/solver/llbsolver/bridge.go
@@ -142,9 +142,6 @@ func (b *llbBridge) Solve(ctx context.Context, req frontend.SolveRequest, sid st
 
 	if req.Definition != nil && req.Definition.Def != nil {
 		res = &frontend.Result{Ref: newResultProxy(b, req)}
-		if req.Evaluate {
-			_, err = res.Ref.Result(ctx)
-		}
 	} else if req.Frontend != "" {
 		f, ok := b.frontends[req.Frontend]
 		if !ok {
@@ -157,6 +154,12 @@ func (b *llbBridge) Solve(ctx context.Context, req frontend.SolveRequest, sid st
 	} else {
 		return &frontend.Result{}, nil
 	}
+	if req.Evaluate {
+		err = res.EachRef(func(ref solver.ResultProxy) error {
+			_, err := res.Ref.Result(ctx)
+			return err
+		})
+	}
 
 	if len(res.Refs) > 0 {
 		for p := range res.Refs {

From 5cb44cb7dda013260a1391bbd0c330c0be6aec8f Mon Sep 17 00:00:00 2001
From: Justin Chadwell <me@jedevc.com>
Date: Mon, 3 Oct 2022 12:10:32 +0200
Subject: [PATCH 3/5] client: add StatFile fallback for Evaluate

Signed-off-by: Justin Chadwell <me@jedevc.com>
---
 client/build.go | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/client/build.go b/client/build.go
index 62ebaee55c86..106d36329108 100644
--- a/client/build.go
+++ b/client/build.go
@@ -115,7 +115,12 @@ func (g *gatewayClientForBuild) StatFile(ctx context.Context, in *gatewayapi.Sta
 
 func (g *gatewayClientForBuild) Evaluate(ctx context.Context, in *gatewayapi.EvaluateRequest, opts ...grpc.CallOption) (*gatewayapi.EvaluateResponse, error) {
 	if err := g.caps.Supports(gatewayapi.CapGatewayEvaluate); err != nil {
-		return nil, err
+		if err2 := g.caps.Supports(gatewayapi.CapStatFile); err2 != nil {
+			return nil, err
+		}
+		ctx = buildid.AppendToOutgoingContext(ctx, g.buildID)
+		_, err := g.gateway.StatFile(ctx, &gatewayapi.StatFileRequest{Ref: in.Ref, Path: "."}, opts...)
+		return &gatewayapi.EvaluateResponse{}, err
 	}
 	ctx = buildid.AppendToOutgoingContext(ctx, g.buildID)
 	return g.gateway.Evaluate(ctx, in, opts...)

From fa28d8919026933c69696bc4839bd33071f4c9ae Mon Sep 17 00:00:00 2001
From: Justin Chadwell <me@jedevc.com>
Date: Thu, 29 Sep 2022 15:17:20 +0100
Subject: [PATCH 4/5] client: refactor StatFile fallback for
 SolveRequest.Evaluate

The StatFile fallback needs reworking to ensure that all refs in the
result are evaluated, not just the first one found.

Signed-off-by: Justin Chadwell <me@jedevc.com>
---
 frontend/gateway/grpcclient/client.go | 25 +++++--------------------
 1 file changed, 5 insertions(+), 20 deletions(-)

diff --git a/frontend/gateway/grpcclient/client.go b/frontend/gateway/grpcclient/client.go
index b20bd7c5adc5..7387e6fa4d3c 100644
--- a/frontend/gateway/grpcclient/client.go
+++ b/frontend/gateway/grpcclient/client.go
@@ -387,30 +387,15 @@ func (c *grpcClient) Solve(ctx context.Context, creq client.SolveRequest) (res *
 		if c.caps.Supports(pb.CapGatewayEvaluateSolve) == nil {
 			req.Evaluate = creq.Evaluate
 		} else {
-			// If evaluate is not supported, fallback to running Stat(".") in order to
-			// trigger an evaluation of the result.
+			// If evaluate is not supported, fallback to running Stat(".") in
+			// order to trigger an evaluation of the result.
 			defer func() {
 				if res == nil {
 					return
 				}
-
-				var (
-					id  string
-					ref client.Reference
-				)
-				ref, err = res.SingleRef()
-				if err != nil {
-					for refID := range res.Refs {
-						id = refID
-						break
-					}
-				} else {
-					id = ref.(*reference).id
-				}
-
-				_, err = c.client.StatFile(ctx, &pb.StatFileRequest{
-					Ref:  id,
-					Path: ".",
+				err = res.EachRef(func(ref client.Reference) error {
+					_, err := ref.StatFile(ctx, client.StatRequest{Path: "."})
+					return err
 				})
 			}()
 		}

From 62fbd5e786f58e185e416a09e37a0772134a3d6c Mon Sep 17 00:00:00 2001
From: Justin Chadwell <me@jedevc.com>
Date: Mon, 3 Oct 2022 12:33:29 +0200
Subject: [PATCH 5/5] gateway: tidy up getImmutableRef args

Remove path argument from llbBridgeForward.getImmutableRef, as it is
only used to print a deceiving error message. Contents of the
Result.Refs map should not be nil, and sane frontends should not produce
them - printing that the file cannot be found doesn't indicate that this
is an abnormal edge case.

Signed-off-by: Justin Chadwell <me@jedevc.com>
---
 frontend/gateway/gateway.go | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/frontend/gateway/gateway.go b/frontend/gateway/gateway.go
index 0f180ecb0618..d02423890af9 100644
--- a/frontend/gateway/gateway.go
+++ b/frontend/gateway/gateway.go
@@ -754,15 +754,15 @@ func (lbf *llbBridgeForwarder) Solve(ctx context.Context, req *pb.SolveRequest)
 	return resp, nil
 }
 
-func (lbf *llbBridgeForwarder) getImmutableRef(ctx context.Context, id, path string) (cache.ImmutableRef, error) {
+func (lbf *llbBridgeForwarder) getImmutableRef(ctx context.Context, id string) (cache.ImmutableRef, error) {
 	lbf.mu.Lock()
 	ref, ok := lbf.refs[id]
 	lbf.mu.Unlock()
 	if !ok {
-		return nil, errors.Errorf("no such ref: %v", id)
+		return nil, errors.Errorf("no such ref: %s", id)
 	}
 	if ref == nil {
-		return nil, errors.Wrap(os.ErrNotExist, path)
+		return nil, errors.Errorf("empty ref: %s", id)
 	}
 
 	r, err := ref.Result(ctx)
@@ -781,7 +781,7 @@ func (lbf *llbBridgeForwarder) getImmutableRef(ctx context.Context, id, path str
 func (lbf *llbBridgeForwarder) ReadFile(ctx context.Context, req *pb.ReadFileRequest) (*pb.ReadFileResponse, error) {
 	ctx = tracing.ContextWithSpanFromContext(ctx, lbf.callCtx)
 
-	ref, err := lbf.getImmutableRef(ctx, req.Ref, req.FilePath)
+	ref, err := lbf.getImmutableRef(ctx, req.Ref)
 	if err != nil {
 		return nil, err
 	}
@@ -812,7 +812,7 @@ func (lbf *llbBridgeForwarder) ReadFile(ctx context.Context, req *pb.ReadFileReq
 func (lbf *llbBridgeForwarder) ReadDir(ctx context.Context, req *pb.ReadDirRequest) (*pb.ReadDirResponse, error) {
 	ctx = tracing.ContextWithSpanFromContext(ctx, lbf.callCtx)
 
-	ref, err := lbf.getImmutableRef(ctx, req.Ref, req.DirPath)
+	ref, err := lbf.getImmutableRef(ctx, req.Ref)
 	if err != nil {
 		return nil, err
 	}
@@ -836,7 +836,7 @@ func (lbf *llbBridgeForwarder) ReadDir(ctx context.Context, req *pb.ReadDirReque
 func (lbf *llbBridgeForwarder) StatFile(ctx context.Context, req *pb.StatFileRequest) (*pb.StatFileResponse, error) {
 	ctx = tracing.ContextWithSpanFromContext(ctx, lbf.callCtx)
 
-	ref, err := lbf.getImmutableRef(ctx, req.Ref, req.Path)
+	ref, err := lbf.getImmutableRef(ctx, req.Ref)
 	if err != nil {
 		return nil, err
 	}
@@ -855,7 +855,7 @@ func (lbf *llbBridgeForwarder) StatFile(ctx context.Context, req *pb.StatFileReq
 func (lbf *llbBridgeForwarder) Evaluate(ctx context.Context, req *pb.EvaluateRequest) (*pb.EvaluateResponse, error) {
 	ctx = tracing.ContextWithSpanFromContext(ctx, lbf.callCtx)
 
-	_, err := lbf.getImmutableRef(ctx, req.Ref, "/")
+	_, err := lbf.getImmutableRef(ctx, req.Ref)
 	if err != nil {
 		return nil, err
 	}