beenull/moby
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Add swarm jobs

Browse source 
Adds support for ReplicatedJob and GlobalJob service modes. These modes
allow running service which execute tasks that exit upon success,
instead of daemon-type tasks.

Signed-off-by: Drew Erny <drew.erny@docker.com>
This commit is contained in:
Drew Erny 2019-12-11 10:05:03 -06:00 committed by Drew Erny
parent 4d63209d94
commit 30d9fe30b1
32 changed files with 3463 additions and 980 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

6
api/server/router/swarm/helpers.go
View file

@ -101,5 +101,11 @@ func adjustForAPIVersion(cliVersion string, service *swarm.ServiceSpec) {
// API version 1.41
service.TaskTemplate.ContainerSpec.Capabilities = nil
}
// jobs were only introduced in API version 1.41. Nil out both Job
// modes; if the service is one of these modes and subsequently has no
// mode, then something down the pipe will thrown an error.
service.Mode.ReplicatedJob = nil
service.Mode.GlobalJob = nil
}
}

53
api/swagger.yaml
View file

@ -3183,6 +3183,12 @@ definitions:
type: "integer"
DesiredState:
$ref: "#/definitions/TaskState"
JobIteration:
description: |
If the Service this Task belongs to is a job-mode service, contains
the JobIteration of the Service this Task was created for. Absent if
the Task was created for a Replicated or Global Service.
$ref: "#/definitions/ObjectVersion"
example:
ID: "0kzzo1i0y4jz6027t0k7aezc7"
Version:
@ -3275,6 +3281,22 @@ definitions:
format: "int64"
Global:
type: "object"
ReplicatedJob:
description: "The mode used for services with a finite number of tasks that run to a completed state."
type: "object"
properties:
MaxConcurrent:
description: "The maximum number of replicas to run simultaneously."
type: "integer"
format: "int64"
default: 1
TotalCompletions:
description: "The total number of replicas desired to reach the Completed state. If unset, will default to the value of MaxConcurrent"
type: "integer"
format: "int64"
GlobalJob:
description: "The mode used for services which run a task to the completed state on each valid node."
type: "object"
UpdateConfig:
description: "Specification for the update strategy of the service."
type: "object"
@ -3475,6 +3497,37 @@ definitions:
type: "integer"
format: "uint64"
example: 10
CompletedTasks:
description: |
The number of tasks for a job that are in the Completed state.
This field must be cross-referenced with the service type, as the
value of 0 may mean the service is not in a job mode, or it may
mean the job-mode service has no tasks yet Completed.
type: "integer"
format: "uint64"
JobStatus:
description: |
The status of the service when it is in one of ReplicatedJob or
GlobalJob modes. Absent on Replicated and Global mode services. The
JobIteration is an ObjectVersion, but unlike the Service's version,
does not need to be sent with an update request.
type: "object"
properties:
JobIteration:
description: |
JobIteration is a value increased each time a Job is executed,
successfully or otherwise. "Executed", in this case, means the
job as a whole has been started, not that an individual Task has
been launched. A job is "Executed" when its ServiceSpec is
updated. JobIteration can be used to disambiguate Tasks belonging
to different executions of a job. Though JobIteration will
increase with each subsequent execution, it may not necessarily
increase by 1, and so JobIteration should not be used to
$ref: "#/definitions/ObjectVersion"
LastExecution:
description: "The last time, as observed by the server, that this job was started"
type: "string"
format: "dateTime"
example:
ID: "9mnpnzenvg8p8tdbtq4wvbkcz"
Version:

57
api/types/swarm/service.go
View file

@ -17,6 +17,10 @@ type Service struct {
// listing all tasks for a service, an operation that could be
// computation and network expensive.
ServiceStatus *ServiceStatus `json:",omitempty"`
// JobStatus is the status of a Service which is in one of ReplicatedJob or
// GlobalJob modes. It is absent on Replicated and Global services.
JobStatus *JobStatus `json:",omitempty"`
}
// ServiceSpec represents the spec of a service.
@ -41,6 +45,8 @@ type ServiceSpec struct {
type ServiceMode struct {
Replicated *ReplicatedService `json:",omitempty"`
Global *GlobalService `json:",omitempty"`
ReplicatedJob *ReplicatedJob `json:",omitempty"`
GlobalJob *GlobalJob `json:",omitempty"`
}
// UpdateState is the state of a service update.
@ -77,6 +83,32 @@ type ReplicatedService struct {
// GlobalService is a kind of ServiceMode.
type GlobalService struct{}
// ReplicatedJob is the a type of Service which executes a defined Tasks
// in parallel until the specified number of Tasks have succeeded.
type ReplicatedJob struct {
// MaxConcurrent indicates the maximum number of Tasks that should be
// executing simultaneously for this job at any given time. There may be
// fewer Tasks that MaxConcurrent executing simultaneously; for example, if
// there are fewer than MaxConcurrent tasks needed to reach
// TotalCompletions.
//
// If this field is empty, it will default to a max concurrency of 1.
MaxConcurrent *uint64 `json:",omitempty"`
// TotalCompletions is the total number of Tasks desired to run to
// completion.
//
// If this field is empty, the value of MaxConcurrent will be used.
TotalCompletions *uint64 `json:",omitempty"`
}
// GlobalJob is the type of a Service which executes a Task on every Node
// matching the Service's placement constraints. These tasks run to completion
// and then exit.
//
// This type is deliberately empty.
type GlobalJob struct{}
const (
// UpdateFailureActionPause PAUSE
UpdateFailureActionPause = "pause"
@ -142,4 +174,29 @@ type ServiceStatus struct {
// services, this is computed by taking the number of tasks with desired
// state of not-Shutdown.
DesiredTasks uint64
// CompletedTasks is the number of tasks in the state Completed, if this
// service is in ReplicatedJob or GlobalJob mode. This field must be
// cross-referenced with the service type, because the default value of 0
// may mean that a service is not in a job mode, or it may mean that the
// job has yet to complete any tasks.
CompletedTasks uint64
}
// JobStatus is the status of a job-type service.
type JobStatus struct {
// JobIteration is a value increased each time a Job is executed,
// successfully or otherwise. "Executed", in this case, means the job as a
// whole has been started, not that an individual Task has been launched. A
// job is "Executed" when its ServiceSpec is updated. JobIteration can be
// used to disambiguate Tasks belonging to different executions of a job.
//
// Though JobIteration will increase with each subsequent execution, it may
// not necessarily increase by 1, and so JobIteration should not be used to
// keep track of the number of times a job has been executed.
JobIteration Version
// LastExecution is the time that the job was last executed, as observed by
// Swarm manager.
LastExecution time.Time `json:",omitempty"`
}

6
api/types/swarm/task.go
View file

@ -56,6 +56,12 @@ type Task struct {
DesiredState TaskState `json:",omitempty"`
NetworksAttachments []NetworkAttachment `json:",omitempty"`
GenericResources []GenericResource `json:",omitempty"`
// JobIteration is the JobIteration of the Service that this Task was
// spawned from, if the Service is a ReplicatedJob or GlobalJob. This is
// used to determine which Tasks belong to which run of the job. This field
// is absent if the Service mode is Replicated or Global.
JobIteration *Version `json:",omitempty"`
}
// TaskSpec represents the spec of a task.

58
daemon/cluster/convert/service.go
View file

@ -44,6 +44,15 @@ func ServiceFromGRPC(s swarmapi.Service) (types.Service, error) {
service.CreatedAt, _ = gogotypes.TimestampFromProto(s.Meta.CreatedAt)
service.UpdatedAt, _ = gogotypes.TimestampFromProto(s.Meta.UpdatedAt)
if s.JobStatus != nil {
service.JobStatus = &types.JobStatus{
JobIteration: types.Version{
Index: s.JobStatus.JobIteration.Index,
},
}
service.JobStatus.LastExecution, _ = gogotypes.TimestampFromProto(s.JobStatus.LastExecution)
}
// UpdateStatus
if s.UpdateStatus != nil {
service.UpdateStatus = &types.UpdateStatus{}
@ -131,6 +140,13 @@ func serviceSpecFromGRPC(spec *swarmapi.ServiceSpec) (*types.ServiceSpec, error)
convertedSpec.Mode.Replicated = &types.ReplicatedService{
Replicas: &t.Replicated.Replicas,
}
case *swarmapi.ServiceSpec_ReplicatedJob:
convertedSpec.Mode.ReplicatedJob = &types.ReplicatedJob{
MaxConcurrent: &t.ReplicatedJob.MaxConcurrent,
TotalCompletions: &t.ReplicatedJob.TotalCompletions,
}
case *swarmapi.ServiceSpec_GlobalJob:
convertedSpec.Mode.GlobalJob = &types.GlobalJob{}
}
return convertedSpec, nil
@ -283,14 +299,52 @@ func ServiceSpecToGRPC(s types.ServiceSpec) (swarmapi.ServiceSpec, error) {
}
// Mode
if s.Mode.Global != nil && s.Mode.Replicated != nil {
return swarmapi.ServiceSpec{}, fmt.Errorf("cannot specify both replicated mode and global mode")
numModes := 0
if s.Mode.Global != nil {
numModes++
}
if s.Mode.Replicated != nil {
numModes++
}
if s.Mode.ReplicatedJob != nil {
numModes++
}
if s.Mode.GlobalJob != nil {
numModes++
}
if numModes > 1 {
return swarmapi.ServiceSpec{}, fmt.Errorf("must specify only one service mode")
}
if s.Mode.Global != nil {
spec.Mode = &swarmapi.ServiceSpec_Global{
Global: &swarmapi.GlobalService{},
}
} else if s.Mode.GlobalJob != nil {
spec.Mode = &swarmapi.ServiceSpec_GlobalJob{
GlobalJob: &swarmapi.GlobalJob{},
}
} else if s.Mode.ReplicatedJob != nil {
// if the service is a replicated job, we have two different kinds of
// values that might need to be defaulted.
r := &swarmapi.ReplicatedJob{}
if s.Mode.ReplicatedJob.MaxConcurrent != nil {
r.MaxConcurrent = *s.Mode.ReplicatedJob.MaxConcurrent
} else {
r.MaxConcurrent = 1
}
if s.Mode.ReplicatedJob.TotalCompletions != nil {
r.TotalCompletions = *s.Mode.ReplicatedJob.TotalCompletions
} else {
r.TotalCompletions = r.MaxConcurrent
}
spec.Mode = &swarmapi.ServiceSpec_ReplicatedJob{
ReplicatedJob: r,
}
} else if s.Mode.Replicated != nil && s.Mode.Replicated.Replicas != nil {
spec.Mode = &swarmapi.ServiceSpec_Replicated{
Replicated: &swarmapi.ReplicatedService{Replicas: *s.Mode.Replicated.Replicas},

6
daemon/cluster/convert/task.go
View file

@ -65,5 +65,11 @@ func TaskFromGRPC(t swarmapi.Task) (types.Task, error) {
})
}
if t.JobIteration != nil {
task.JobIteration = &types.Version{
Index: t.JobIteration.Index,
}
}
return task, nil
}

5
daemon/cluster/services.go
View file

@ -91,6 +91,10 @@ func (c *Cluster) GetServices(options apitypes.ServiceListOptions) ([]types.Serv
mode = "global"
case *swarmapi.ServiceSpec_Replicated:
mode = "replicated"
case *swarmapi.ServiceSpec_ReplicatedJob:
mode = "replicatedjob"
case *swarmapi.ServiceSpec_GlobalJob:
mode = "globaljob"
}
if !options.Filters.ExactMatch("mode", mode) {
@ -133,6 +137,7 @@ func (c *Cluster) GetServices(options apitypes.ServiceListOptions) ([]types.Serv
serviceMap[status.ServiceID] = &types.ServiceStatus{
RunningTasks: status.RunningTasks,
DesiredTasks: status.DesiredTasks,
CompletedTasks: status.CompletedTasks,
}
}

21
docs/api/version-history.md
View file

@ -32,8 +32,25 @@ keywords: "API, Docker, rcli, REST, documentation"
version. This change is not versioned, and affects all API versions if the daemon
has this patch.
* `GET /services` now accepts query parameter `status`. When set `true`,
services returned will include `ServiceStatus`, which provides Desired and
Running task counts for the service.
services returned will include `ServiceStatus`, which provides Desired,
Running, and Completed task counts for the service.
* `GET /services` may now include `ReplicatedJob` or `GlobalJob` as the `Mode`
in a `ServiceSpec`.
* `GET /services/{id}` may now include `ReplicatedJob` or `GlobalJob` as the
`Mode` in a `ServiceSpec`.
* `POST /services/create` now accepts `ReplicatedJob or `GlobalJob` as the `Mode`
in the `ServiceSpec.
* `POST /services/{id}/update` accepts updating the fields of the
`ReplicatedJob` object in the `ServiceSpec.Mode`. The service mode still
cannot be changed, however.
* `GET /services` now includes `JobStatus` on Services with mode
`ReplicatedJob` or `GlobalJob`.
* `GET /services/{id}` now includes `JobStatus` on Services with mode
`ReplicatedJob` or `GlobalJob`.
* `GET /tasks` now includes `JobIteration` on Tasks spawned from a job-mode
service.
* `GET /tasks/{id}` now includes `JobIteration` on the task if spawned from a
job-mode service.
## v1.40 API changes

9
integration/internal/swarm/service.go
View file

@ -20,7 +20,7 @@ import (
// ServicePoll tweaks the pollSettings for `service`
func ServicePoll(config *poll.Settings) {
// Override the default pollSettings for `service` resource here ...
config.Timeout = 30 * time.Second
config.Timeout = 15 * time.Second
config.Delay = 100 * time.Millisecond
if runtime.GOARCH == "arm64" || runtime.GOARCH == "arm" {
config.Timeout = 90 * time.Second
@ -91,6 +91,13 @@ func CreateServiceSpec(t *testing.T, opts ...ServiceSpecOpt) swarmtypes.ServiceS
return spec
}
// ServiceWithMode sets the mode of the service to the provided mode.
func ServiceWithMode(mode swarmtypes.ServiceMode) func(*swarmtypes.ServiceSpec) {
return func(spec *swarmtypes.ServiceSpec) {
spec.Mode = mode
}
}
// ServiceWithInit sets whether the service should use init or not
func ServiceWithInit(b *bool) func(*swarmtypes.ServiceSpec) {
return func(spec *swarmtypes.ServiceSpec) {

81
integration/internal/swarm/states.go
View file

@ -2,6 +2,7 @@ package swarm
import (
"context"
"fmt"
"github.com/docker/docker/api/types"
"github.com/docker/docker/api/types/filters"
@ -82,3 +83,83 @@ func RunningTasksCount(client client.ServiceAPIClient, serviceID string, instanc
}
}
}
// JobComplete is a poll function for determining that a ReplicatedJob is
// completed additionally, while polling, it verifies that the job never
// exceeds MaxConcurrent running tasks
func JobComplete(client client.CommonAPIClient, service swarmtypes.Service) func(log poll.LogT) poll.Result {
filter := filters.NewArgs()
filter.Add("service", service.ID)
var jobIteration swarmtypes.Version
if service.JobStatus != nil {
jobIteration = service.JobStatus.JobIteration
}
maxRaw := service.Spec.Mode.ReplicatedJob.MaxConcurrent
totalRaw := service.Spec.Mode.ReplicatedJob.TotalCompletions
max := int(*maxRaw)
total := int(*totalRaw)
previousResult := ""
return func(log poll.LogT) poll.Result {
tasks, err := client.TaskList(context.Background(), types.TaskListOptions{
Filters: filter,
})
if err != nil {
poll.Error(err)
}
var running int
var completed int
var runningSlot []int
var runningID []string
for _, task := range tasks {
// make sure the task has the same job iteration
if task.JobIteration == nil || task.JobIteration.Index != jobIteration.Index {
continue
}
switch task.Status.State {
case swarmtypes.TaskStateRunning:
running++
runningSlot = append(runningSlot, task.Slot)
runningID = append(runningID, task.ID)
case swarmtypes.TaskStateComplete:
completed++
}
}
switch {
case running > max:
return poll.Error(fmt.Errorf(
"number of running tasks (%v) exceeds max (%v)", running, max,
))
case (completed + running) > total:
return poll.Error(fmt.Errorf(
"number of tasks exceeds total (%v), %v running and %v completed",
total, running, completed,
))
case completed == total && running == 0:
return poll.Success()
default:
newRes := fmt.Sprintf(
"Completed: %2d Running: %v\n\t%v",
completed, runningSlot, runningID,
)
if newRes == previousResult {
} else {
previousResult = newRes
}
return poll.Continue(
"Job not yet finished, %v completed and %v running out of %v total",
completed, running, total,
)
}
}
}

143
integration/service/jobs_test.go Normal file
View file

@ -0,0 +1,143 @@
package service
import (
"context"
"testing"
"github.com/docker/docker/api/types"
swarmtypes "github.com/docker/docker/api/types/swarm"
"github.com/docker/docker/integration/internal/swarm"
"gotest.tools/assert"
"gotest.tools/poll"
"gotest.tools/skip"
)
// The file jobs_test.go contains tests that verify that services which are in
// the mode ReplicatedJob or GlobalJob.
// TestCreateJob tests that a Service can be created and run with
// mode ReplicatedJob
func TestCreateJob(t *testing.T) {
skip.If(t, testEnv.IsRemoteDaemon)
skip.If(t, testEnv.DaemonInfo.OSType == "windows")
defer setupTest(t)
d := swarm.NewSwarm(t, testEnv)
defer d.Stop(t)
client := d.NewClientT(t)
defer client.Close()
for _, mode := range []swarmtypes.ServiceMode{
{ReplicatedJob: &swarmtypes.ReplicatedJob{}},
{GlobalJob: &swarmtypes.GlobalJob{}},
} {
id := swarm.CreateService(t, d, swarm.ServiceWithMode(mode))
poll.WaitOn(t, swarm.RunningTasksCount(client, id, 1), swarm.ServicePoll)
}
}
// TestReplicatedJob tests that running a replicated job starts the requisite
// number of tasks,
func TestReplicatedJob(t *testing.T) {
skip.If(t, testEnv.IsRemoteDaemon)
skip.If(t, testEnv.DaemonInfo.OSType == "windows")
// we need variables, because the replicas field takes a pointer
maxConcurrent := uint64(2)
// there is overhead, especially in the test environment, associated with
// starting tasks. if total is set too high, then the time needed to
// complete the test, even if everything is proceeding ideally, may exceed
// the time the test has to execute
//
// in CI,the test has been seen to time out with as few as 7 completions
// after 15 seconds. this means 7 completions ought not be too many.
total := uint64(7)
defer setupTest(t)
d := swarm.NewSwarm(t, testEnv)
defer d.Stop(t)
client := d.NewClientT(t)
defer client.Close()
id := swarm.CreateService(t, d,
swarm.ServiceWithMode(swarmtypes.ServiceMode{
ReplicatedJob: &swarmtypes.ReplicatedJob{
MaxConcurrent: &maxConcurrent,
TotalCompletions: &total,
},
}),
// just run a command to execute and exit peacefully.
swarm.ServiceWithCommand([]string{"true"}),
)
service, _, err := client.ServiceInspectWithRaw(
context.Background(), id, types.ServiceInspectOptions{},
)
assert.NilError(t, err)
poll.WaitOn(t, swarm.JobComplete(client, service), swarm.ServicePoll)
}
// TestUpdateJob tests that a job can be updated, and that it runs with the
// correct parameters.
func TestUpdateReplicatedJob(t *testing.T) {
skip.If(t, testEnv.IsRemoteDaemon)
skip.If(t, testEnv.DaemonInfo.OSType == "windows")
defer setupTest(t)()
d := swarm.NewSwarm(t, testEnv)
defer d.Stop(t)
client := d.NewClientT(t)
defer client.Close()
// avoid writing "context.Background()" over and over again
ctx := context.Background()
// Create the job service
id := swarm.CreateService(t, d,
swarm.ServiceWithMode(swarmtypes.ServiceMode{
ReplicatedJob: &swarmtypes.ReplicatedJob{
// use the default, empty values.
},
}),
// run "true" so the task exits with 0
swarm.ServiceWithCommand([]string{"true"}),
)
service, _, err := client.ServiceInspectWithRaw(
ctx, id, types.ServiceInspectOptions{},
)
assert.NilError(t, err)
// wait for the job to completed
poll.WaitOn(t, swarm.JobComplete(client, service), swarm.ServicePoll)
// update the job.
spec := service.Spec
spec.TaskTemplate.ForceUpdate++
_, err = client.ServiceUpdate(
ctx, id, service.Version, spec, types.ServiceUpdateOptions{},
)
assert.NilError(t, err)
service2, _, err := client.ServiceInspectWithRaw(
ctx, id, types.ServiceInspectOptions{},
)
assert.NilError(t, err)
// assert that the job iteration has increased
assert.Assert(t,
service.JobStatus.JobIteration.Index < service2.JobStatus.JobIteration.Index,
)
// now wait for the service to complete a second time.
poll.WaitOn(t, swarm.JobComplete(client, service2), swarm.ServicePoll)
}

2
vendor.conf
View file

@ -128,7 +128,7 @@ github.com/containerd/ttrpc 92c8520ef9f86600c650dd540266
github.com/gogo/googleapis d31c731455cb061f42baff3bda55bad0118b126b # v1.2.0
# cluster
github.com/docker/swarmkit 24fb4cfe8af56803640180c5592bf32da732ced2
github.com/docker/swarmkit ef128ab4f5d50ffe4851d937b2b296e55562d10f
github.com/gogo/protobuf ba06b47c162d49f2af050fb4c75bcbc86a159d5c # v1.2.1
github.com/golang/protobuf aa810b61a9c79d51363740d207bb46cf8e620ed5 # v1.2.0
github.com/cloudflare/cfssl 5d63dbd981b5c408effbb58c442d54761ff94fbd # 1.3.2

383
vendor/github.com/docker/swarmkit/api/control.pb.go generated vendored
View file

@ -1167,6 +1167,12 @@ type ListServiceStatusesResponse_ServiceStatus struct {
// request time. This may be larger than desired tasks if, for example, a
// service has been scaled down.
RunningTasks uint64 `protobuf:"varint,3,opt,name=running_tasks,json=runningTasks,proto3" json:"running_tasks,omitempty"`
// CompletedTasks is the number of tasks in state Completed, if this
// service is in mode ReplicatedJob or GlobalJob. This must be
// cross-referenced with the service type, because the default value of 0
// may mean that a service is not in a Job mode, or it may mean the Job has
// yet to complete any Tasks.
CompletedTasks uint64 `protobuf:"varint,4,opt,name=completed_tasks,json=completedTasks,proto3" json:"completed_tasks,omitempty"`
}
func (m *ListServiceStatusesResponse_ServiceStatus) Reset() {
@ -3435,180 +3441,181 @@ func init() {
}
var fileDescriptor_b37401dd08bf8930 = []byte{
// 2760 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0x49, 0x6f, 0x1b, 0xc9,
0x15, 0x16, 0x29, 0x4a, 0x22, 0x1f, 0xb5, 0xb9, 0x2c, 0x8f, 0x35, 0xb4, 0x23, 0x19, 0xed, 0x8d,
0x76, 0x1c, 0x72, 0x86, 0xce, 0x64, 0x1c, 0xcf, 0x38, 0x89, 0x65, 0x79, 0xa1, 0x17, 0xd9, 0x68,
0xc9, 0x46, 0x72, 0x08, 0x04, 0x8a, 0x2c, 0x69, 0xda, 0xa4, 0xba, 0x99, 0xee, 0xa6, 0xc7, 0x42,
0x90, 0x20, 0x8b, 0x83, 0x39, 0x05, 0xc8, 0x25, 0x40, 0x90, 0x43, 0x80, 0x9c, 0x02, 0xe4, 0x90,
0x43, 0x4e, 0x39, 0xe4, 0x07, 0x18, 0x39, 0xcd, 0x71, 0x4e, 0x4a, 0x46, 0x46, 0x80, 0x9c, 0xf2,
0x17, 0x12, 0xd4, 0xd6, 0x4b, 0xb1, 0x7a, 0xe1, 0x02, 0x78, 0x4e, 0x12, 0xab, 0xbf, 0xb7, 0x54,
0xbd, 0xd7, 0x5f, 0x55, 0xbf, 0x57, 0x70, 0x65, 0xcf, 0x70, 0x3f, 0xe9, 0xed, 0x54, 0x9a, 0xd6,
0x7e, 0xb5, 0x65, 0x35, 0xdb, 0xd8, 0xae, 0x3a, 0x9f, 0x36, 0xec, 0xfd, 0xb6, 0xe1, 0x56, 0x1b,
0x5d, 0xa3, 0xda, 0xb4, 0x4c, 0xd7, 0xb6, 0x3a, 0x95, 0xae, 0x6d, 0xb9, 0x16, 0x42, 0x0c, 0x52,
0x11, 0x90, 0xca, 0x8b, 0xf7, 0x4b, 0x97, 0x13, 0x34, 0x38, 0x5d, 0xdc, 0x74, 0x98, 0x7c, 0x29,
0xc9, 0x9a, 0xb5, 0xf3, 0x1c, 0x37, 0x5d, 0x81, 0x4e, 0xd2, 0xec, 0x1e, 0x74, 0xb1, 0xc0, 0x2e,
0xed, 0x59, 0x7b, 0x16, 0xfd, 0xb7, 0x4a, 0xfe, 0xe3, 0xa3, 0xef, 0xee, 0x59, 0xd6, 0x5e, 0x07,
0x57, 0xe9, 0xaf, 0x9d, 0xde, 0x6e, 0xb5, 0x61, 0x1e, 0xf0, 0x47, 0x1f, 0xc6, 0x28, 0xf7, 0xe0,
0xdd, 0x4e, 0x6f, 0xcf, 0x30, 0xf9, 0x1f, 0x26, 0xa8, 0x7d, 0x00, 0xf3, 0x77, 0xb1, 0xbb, 0x61,
0xb5, 0xb0, 0x8e, 0x7f, 0xd4, 0xc3, 0x8e, 0x8b, 0xce, 0xc2, 0x8c, 0x69, 0xb5, 0xf0, 0xb6, 0xd1,
0x5a, 0xce, 0x9c, 0xc9, 0x94, 0x0b, 0x6b, 0x70, 0x74, 0xb8, 0x3a, 0x4d, 0x10, 0xf5, 0x75, 0x7d,
0x9a, 0x3c, 0xaa, 0xb7, 0xb4, 0xef, 0xc2, 0x82, 0x27, 0xe6, 0x74, 0x2d, 0xd3, 0xc1, 0xe8, 0x0a,
0xe4, 0xc8, 0x43, 0x2a, 0x54, 0xac, 0x2d, 0x57, 0xfa, 0x17, 0xb7, 0x42, 0xf1, 0x14, 0xa5, 0xbd,
0x9a, 0x82, 0xc5, 0x87, 0x86, 0x43, 0x55, 0x38, 0xc2, 0xf4, 0x1d, 0x98, 0xd9, 0x35, 0x3a, 0x2e,
0xb6, 0x1d, 0xae, 0xe5, 0x8a, 0x4a, 0x8b, 0x2c, 0x56, 0xb9, 0xc3, 0x64, 0x74, 0x21, 0x5c, 0xfa,
0x53, 0x0e, 0x66, 0xf8, 0x20, 0x5a, 0x82, 0x29, 0xb3, 0xb1, 0x8f, 0x89, 0xc6, 0xc9, 0x72, 0x41,
0x67, 0x3f, 0x50, 0x15, 0x8a, 0x46, 0x6b, 0xbb, 0x6b, 0xe3, 0x5d, 0xe3, 0x25, 0x76, 0x96, 0xb3,
0xe4, 0xd9, 0xda, 0xfc, 0xd1, 0xe1, 0x2a, 0xd4, 0xd7, 0x9f, 0xf0, 0x51, 0x1d, 0x8c, 0x96, 0xf8,
0x1f, 0x3d, 0x81, 0xe9, 0x4e, 0x63, 0x07, 0x77, 0x9c, 0xe5, 0xc9, 0x33, 0x93, 0xe5, 0x62, 0xed,
0xda, 0x20, 0x9e, 0x55, 0x1e, 0x52, 0xd1, 0xdb, 0xa6, 0x6b, 0x1f, 0xe8, 0x5c, 0x0f, 0xfa, 0x21,
0x14, 0xe9, 0x3a, 0x73, 0xb5, 0x33, 0x54, 0xed, 0xc7, 0x03, 0xa9, 0x25, 0x83, 0x41, 0xd5, 0x60,
0x7a, 0x03, 0xe8, 0x11, 0x14, 0xf7, 0xf1, 0xfe, 0x0e, 0xb6, 0x9d, 0x4f, 0x8c, 0xae, 0xb3, 0x9c,
0x3b, 0x33, 0x59, 0x9e, 0xaf, 0x5d, 0x8c, 0x8a, 0xca, 0x66, 0x17, 0x37, 0x2b, 0x8f, 0x3c, 0xfc,
0x5a, 0x76, 0x71, 0x42, 0x0f, 0xca, 0xa3, 0x6f, 0xc1, 0x94, 0x6d, 0x75, 0xb0, 0xb3, 0x3c, 0x45,
0x15, 0x9d, 0x8e, 0x0c, 0xaf, 0xd5, 0xc1, 0x54, 0x9a, 0xc1, 0xd1, 0x59, 0x98, 0x23, 0x2b, 0xee,
0x2f, 0xf5, 0x34, 0x0d, 0xc3, 0x2c, 0x19, 0x14, 0x8b, 0x5b, 0xfa, 0x36, 0x14, 0x03, 0xd3, 0x40,
0x8b, 0x30, 0xd9, 0xc6, 0x07, 0x2c, 0xfb, 0x74, 0xf2, 0x2f, 0x09, 0xe2, 0x8b, 0x46, 0xa7, 0x87,
0x97, 0xb3, 0x74, 0x8c, 0xfd, 0xb8, 0x9e, 0xbd, 0x96, 0x29, 0xdd, 0x80, 0x05, 0x69, 0x15, 0x06,
0x11, 0xd7, 0x6e, 0xc1, 0xb1, 0xc0, 0xea, 0xf2, 0x4c, 0xae, 0xc0, 0x14, 0x59, 0x48, 0x96, 0x32,
0x71, 0xa9, 0xcc, 0x60, 0xda, 0x9f, 0x33, 0x70, 0xec, 0x69, 0xb7, 0xd5, 0x70, 0xf1, 0xa0, 0xef,
0x11, 0xfa, 0x0e, 0xcc, 0x52, 0xd0, 0x0b, 0x6c, 0x3b, 0x86, 0x65, 0x52, 0x07, 0x8b, 0xb5, 0x53,
0x2a, 0x8b, 0xcf, 0x18, 0x44, 0xa7, 0x59, 0xc3, 0x7f, 0xa0, 0xf7, 0x20, 0x47, 0x18, 0x69, 0x79,
0x92, 0xca, 0x9d, 0x8e, 0x0b, 0xaf, 0x4e, 0x91, 0xda, 0x1a, 0xa0, 0xa0, 0xaf, 0x43, 0xbd, 0xbc,
0x1b, 0x70, 0x4c, 0xc7, 0xfb, 0xd6, 0x8b, 0xc1, 0xe7, 0xbb, 0x04, 0x53, 0xbb, 0x96, 0xdd, 0x64,
0x91, 0xc8, 0xeb, 0xec, 0x87, 0xb6, 0x04, 0x28, 0xa8, 0x8f, 0xf9, 0xc4, 0xa9, 0x69, 0xab, 0xe1,
0xb4, 0x03, 0x26, 0xdc, 0x86, 0xd3, 0x96, 0x4c, 0x10, 0x04, 0x31, 0x41, 0x1e, 0x79, 0xd4, 0xc4,
0xc4, 0xfc, 0xd9, 0x91, 0x87, 0x71, 0xb3, 0xa3, 0x78, 0x8a, 0xd2, 0xae, 0x89, 0xd9, 0x0d, 0x6c,
0xda, 0x9b, 0x47, 0xd0, 0xba, 0xf6, 0xf7, 0x1c, 0xa3, 0x3a, 0x32, 0x38, 0x04, 0xd5, 0x05, 0xc5,
0xfa, 0xa9, 0xee, 0x9f, 0x93, 0x6f, 0x8f, 0xea, 0x54, 0x9e, 0x29, 0xa9, 0xae, 0x0a, 0x45, 0x07,
0xdb, 0x2f, 0x8c, 0x26, 0xc9, 0x0e, 0xc6, 0x45, 0xdc, 0x85, 0x4d, 0x36, 0x5c, 0x5f, 0x77, 0x74,
0xe0, 0x90, 0x7a, 0xcb, 0x41, 0x17, 0x20, 0xcf, 0x73, 0x89, 0x11, 0x4e, 0x61, 0xad, 0x78, 0x74,
0xb8, 0x3a, 0xc3, 0x92, 0xc9, 0xd1, 0x67, 0x58, 0x36, 0x39, 0xe8, 0x1e, 0xcc, 0xb7, 0xb0, 0x63,
0xd8, 0xb8, 0xb5, 0xed, 0xb8, 0x0d, 0x97, 0xd3, 0xcb, 0x7c, 0xed, 0x6b, 0x51, 0x21, 0xde, 0x24,
0x28, 0xca, 0x4f, 0x73, 0x5c, 0x90, 0x8e, 0x28, 0x78, 0x6a, 0xa6, 0x9f, 0xa7, 0x50, 0x09, 0xf2,
0x76, 0xcf, 0x74, 0x0d, 0xb2, 0xc6, 0x05, 0xfa, 0xdc, 0xfb, 0x8d, 0x4e, 0x03, 0xf4, 0xba, 0xdb,
0xae, 0xb5, 0x4d, 0xde, 0xad, 0xe5, 0x3c, 0x4d, 0xef, 0x7c, 0xaf, 0xbb, 0x65, 0xad, 0x37, 0x5c,
0x3c, 0x02, 0xc3, 0x09, 0x8a, 0xe2, 0x8b, 0xed, 0x53, 0x14, 0xc9, 0xb9, 0x58, 0x8a, 0xa2, 0x49,
0xc8, 0x60, 0xda, 0x03, 0x58, 0xba, 0x65, 0xe3, 0x86, 0x8b, 0xf9, 0x82, 0x8b, 0x34, 0xbc, 0xca,
0xf9, 0x83, 0xe5, 0xe0, 0xaa, 0x4a, 0x0d, 0x97, 0x08, 0x50, 0xc8, 0x06, 0x9c, 0x90, 0x94, 0x71,
0xaf, 0x3e, 0x80, 0x19, 0x1e, 0x44, 0xae, 0xf0, 0x54, 0x8c, 0x42, 0x5d, 0x60, 0xb5, 0xe7, 0x70,
0xec, 0x2e, 0x76, 0x25, 0xcf, 0xae, 0x00, 0xf8, 0x39, 0xc3, 0xdf, 0xb9, 0xb9, 0xa3, 0xc3, 0xd5,
0x82, 0x97, 0x32, 0x7a, 0xc1, 0xcb, 0x18, 0x74, 0x11, 0x16, 0x0c, 0xd3, 0xc1, 0xb6, 0xbb, 0xdd,
0xc2, 0xbb, 0x8d, 0x5e, 0xc7, 0x75, 0x38, 0xc3, 0xcc, 0xb3, 0xe1, 0x75, 0x3e, 0xaa, 0x3d, 0x00,
0x14, 0xb4, 0x35, 0x9a, 0xe3, 0x7f, 0xcd, 0xc2, 0x12, 0x23, 0xd3, 0x91, 0x9c, 0x5f, 0x87, 0x05,
0x81, 0x1e, 0x60, 0x1f, 0x98, 0xe7, 0x32, 0x62, 0x2b, 0xb8, 0x1a, 0xda, 0x0a, 0xd2, 0x85, 0x12,
0x3d, 0x82, 0xbc, 0x6d, 0x75, 0x3a, 0x3b, 0x8d, 0x66, 0x7b, 0x39, 0x77, 0x26, 0x53, 0x9e, 0xaf,
0xbd, 0xaf, 0x12, 0x54, 0x4d, 0xb2, 0xa2, 0x73, 0x41, 0xdd, 0x53, 0xa1, 0x69, 0x90, 0x17, 0xa3,
0x28, 0x0f, 0xb9, 0x8d, 0xc7, 0x1b, 0xb7, 0x17, 0x27, 0xd0, 0x2c, 0xe4, 0x9f, 0xe8, 0xb7, 0x9f,
0xd5, 0x1f, 0x3f, 0xdd, 0x5c, 0xcc, 0x90, 0xec, 0x91, 0xd4, 0x8d, 0x16, 0x84, 0x75, 0x58, 0x62,
0xa4, 0x3b, 0x4a, 0x0c, 0xb4, 0x93, 0x70, 0x42, 0xd2, 0xc2, 0xd9, 0xfb, 0xd5, 0x24, 0x1c, 0x27,
0xef, 0x1f, 0x1f, 0xf7, 0x08, 0xbc, 0x2e, 0x13, 0x78, 0x35, 0x8a, 0x26, 0x25, 0xc9, 0x7e, 0x0e,
0xff, 0x63, 0x76, 0xec, 0x1c, 0xbe, 0x29, 0x71, 0xf8, 0x47, 0x03, 0x3a, 0xa7, 0xa4, 0xf1, 0x3e,
0x8e, 0xcc, 0x25, 0x70, 0xe4, 0x54, 0x98, 0x23, 0x47, 0x61, 0xc1, 0xc7, 0xb0, 0x14, 0x76, 0x97,
0x27, 0xcd, 0x87, 0x90, 0xe7, 0x41, 0x14, 0x5c, 0x18, 0x9b, 0x35, 0x1e, 0x58, 0xbb, 0x06, 0xa5,
0x80, 0x42, 0xb2, 0x0b, 0xf4, 0x1c, 0x3f, 0xba, 0x25, 0x49, 0x6d, 0x21, 0x20, 0xf9, 0x8b, 0x2c,
0x9c, 0x52, 0x8a, 0x72, 0x97, 0x7e, 0x00, 0x79, 0x87, 0x8f, 0x71, 0x97, 0x6e, 0x24, 0xac, 0xbe,
0xac, 0xa2, 0x12, 0x1a, 0xd7, 0x3d, 0x75, 0xa5, 0xcf, 0x32, 0x30, 0x17, 0x7a, 0x36, 0x20, 0xd3,
0x9c, 0x05, 0xb1, 0xed, 0x6d, 0xb3, 0xed, 0x83, 0xac, 0x73, 0x4e, 0x9f, 0xe5, 0x83, 0x74, 0x8f,
0x21, 0x20, 0xbb, 0x67, 0x9a, 0x86, 0xb9, 0xc7, 0x41, 0x93, 0x0c, 0xc4, 0x07, 0xb7, 0xc2, 0x1b,
0xca, 0x06, 0x76, 0x3f, 0xb5, 0xec, 0xf6, 0x00, 0x1b, 0x0a, 0x97, 0x50, 0x6d, 0x28, 0x9e, 0x32,
0x9f, 0x12, 0x4c, 0x36, 0x14, 0x47, 0x09, 0x42, 0x4a, 0x60, 0xb5, 0xa7, 0x74, 0x43, 0x91, 0x3c,
0x43, 0x90, 0x23, 0x89, 0xca, 0xd3, 0x8d, 0xfe, 0x4f, 0x56, 0x8f, 0xcb, 0x90, 0xd5, 0xcb, 0xfa,
0xab, 0xc7, 0x65, 0xc9, 0xea, 0x71, 0x40, 0xbd, 0xc5, 0xf7, 0x8e, 0x31, 0xf9, 0xf8, 0x7d, 0x41,
0x5b, 0x63, 0x77, 0xd3, 0xa3, 0x32, 0xc9, 0x53, 0xed, 0x3f, 0x59, 0x46, 0x65, 0x7c, 0x7c, 0x08,
0x2a, 0x93, 0x24, 0xfb, 0xa9, 0xec, 0x57, 0x6f, 0x91, 0xca, 0x22, 0x9c, 0x1b, 0x9a, 0xca, 0xc6,
0x40, 0x57, 0xbe, 0x4b, 0x3e, 0x5d, 0xf1, 0x40, 0xc5, 0xd2, 0x95, 0x88, 0x9c, 0x07, 0xd6, 0x6e,
0xd2, 0x94, 0xbe, 0xd5, 0xe9, 0x39, 0x2e, 0xb6, 0x03, 0x5b, 0x5c, 0x93, 0x8d, 0x48, 0x2f, 0x3f,
0xc7, 0x91, 0xbc, 0xe0, 0x00, 0x2f, 0x7d, 0x3d, 0x15, 0x7e, 0xfa, 0x72, 0x48, 0x5c, 0xfa, 0x0a,
0x29, 0x81, 0xf5, 0x72, 0x89, 0x3f, 0x18, 0x22, 0x97, 0x24, 0xc9, 0xaf, 0x56, 0x2e, 0x45, 0x38,
0xf7, 0x36, 0x73, 0xc9, 0x77, 0xc9, 0xcf, 0x25, 0x1e, 0x8d, 0xd8, 0x5c, 0x12, 0xa1, 0xf3, 0xc0,
0xda, 0x6f, 0x33, 0x50, 0x7c, 0x80, 0x0f, 0x74, 0xcb, 0x6d, 0xb8, 0xe4, 0xe4, 0x78, 0x19, 0x8e,
0x91, 0x24, 0xc3, 0xf6, 0xf6, 0x73, 0xcb, 0x30, 0xb7, 0x5d, 0xab, 0x8d, 0x4d, 0xea, 0x5a, 0x5e,
0x5f, 0x60, 0x0f, 0xee, 0x5b, 0x86, 0xb9, 0x45, 0x86, 0xd1, 0x15, 0x40, 0xfb, 0x0d, 0xb3, 0xb1,
0x17, 0x06, 0xb3, 0xb3, 0xf6, 0x22, 0x7f, 0xa2, 0x44, 0xf7, 0xcc, 0x8e, 0xd5, 0x6c, 0x6f, 0x93,
0x59, 0x4f, 0x86, 0xd0, 0x4f, 0xe9, 0x83, 0x07, 0xf8, 0x80, 0x6c, 0xac, 0xfc, 0x38, 0x3d, 0x4a,
0x9e, 0x93, 0xe3, 0xb4, 0x40, 0x0f, 0x72, 0x9c, 0xe6, 0x32, 0x03, 0x1c, 0xa7, 0xb9, 0xf5, 0xc0,
0x71, 0xfa, 0x26, 0x39, 0x4e, 0xb3, 0x55, 0xa5, 0xc7, 0xe9, 0x08, 0xc1, 0xc0, 0xe2, 0xaf, 0xe5,
0x5e, 0x1f, 0xae, 0x4e, 0xe8, 0x9e, 0x98, 0x7f, 0x3c, 0x1e, 0xd3, 0x8b, 0x7a, 0x03, 0x16, 0xe9,
0x07, 0x4f, 0xd3, 0xc6, 0xae, 0x58, 0xcf, 0x4b, 0x50, 0x70, 0xe8, 0x80, 0xbf, 0x9c, 0xb3, 0x47,
0x87, 0xab, 0x79, 0x86, 0xaa, 0xaf, 0x93, 0xc3, 0x0e, 0xfd, 0xaf, 0xa5, 0xdd, 0xe5, 0xdf, 0x66,
0x4c, 0x9c, 0xbb, 0x52, 0x83, 0x69, 0x06, 0xe0, 0x9e, 0x94, 0xd4, 0x47, 0x2e, 0x2a, 0xc3, 0x91,
0xda, 0xdf, 0x32, 0x70, 0x5c, 0x9c, 0xfb, 0x87, 0xf3, 0x05, 0xad, 0xc1, 0x3c, 0x87, 0x0e, 0x10,
0xd7, 0x39, 0x26, 0x22, 0xc2, 0x5a, 0x0b, 0x85, 0x75, 0x25, 0xda, 0xf1, 0xc0, 0xf1, 0xe4, 0xbe,
0xff, 0x95, 0x37, 0xf2, 0x32, 0xfc, 0x3b, 0x0b, 0x88, 0x9d, 0xfc, 0xc8, 0x4f, 0x8f, 0x36, 0xef,
0xc9, 0xb4, 0x59, 0x89, 0x3e, 0x32, 0x06, 0x05, 0xfb, 0x59, 0xf3, 0xd5, 0xf8, 0x59, 0x53, 0x97,
0x58, 0xf3, 0xfa, 0x60, 0xbe, 0xbd, 0x15, 0xd2, 0x7c, 0x20, 0xbe, 0xda, 0xb8, 0x47, 0x3c, 0x64,
0xdf, 0x24, 0xdf, 0x98, 0x74, 0x88, 0x53, 0x66, 0x5c, 0xcc, 0x04, 0x54, 0xab, 0xc3, 0x71, 0x51,
0xf0, 0x08, 0xa6, 0x6e, 0x2d, 0x74, 0xd6, 0x4d, 0x9d, 0x4b, 0x61, 0x55, 0x23, 0xe4, 0xd2, 0xf7,
0xe0, 0xb8, 0xf8, 0x66, 0x1d, 0xf2, 0xed, 0x7e, 0xc7, 0xff, 0x76, 0x0e, 0x7a, 0xc3, 0x49, 0xe3,
0x96, 0x65, 0xee, 0x1a, 0x7b, 0x01, 0xb5, 0x4d, 0x3a, 0x20, 0xa9, 0x65, 0x28, 0xa2, 0x96, 0x3d,
0xf6, 0x48, 0x43, 0x88, 0xfb, 0x33, 0x64, 0x80, 0xb8, 0x19, 0x72, 0x19, 0x8e, 0x0c, 0x90, 0xc6,
0xb0, 0xbe, 0x10, 0xd2, 0xe0, 0xd0, 0x41, 0x48, 0x83, 0x89, 0x0c, 0x40, 0x1a, 0xcc, 0xb2, 0x8a,
0x34, 0xc6, 0xb0, 0x0c, 0x82, 0x34, 0xd8, 0xf0, 0x10, 0xa4, 0x11, 0x16, 0xfc, 0x6a, 0x91, 0x86,
0xda, 0xb7, 0xb7, 0x49, 0x1a, 0x9e, 0x47, 0x3e, 0x69, 0xb0, 0x40, 0xc4, 0x92, 0x06, 0x8f, 0x99,
0x80, 0xfa, 0xa4, 0x11, 0x4e, 0xdd, 0x14, 0xa4, 0xa1, 0xca, 0xa5, 0xb0, 0xaa, 0x11, 0x72, 0xc9,
0x23, 0x8d, 0xa1, 0xdf, 0x6e, 0x8f, 0x34, 0xc2, 0xde, 0x68, 0x3f, 0x81, 0x77, 0x98, 0x97, 0xb7,
0x5f, 0xba, 0xd8, 0xa4, 0xef, 0x11, 0x57, 0x7e, 0x13, 0x8a, 0x0d, 0xd3, 0xe4, 0x27, 0x1c, 0x27,
0xae, 0x36, 0x70, 0xd3, 0x87, 0xe9, 0x41, 0x19, 0x74, 0x06, 0x8a, 0x2d, 0xec, 0x34, 0x6d, 0xa3,
0xeb, 0x8a, 0x77, 0xb8, 0xa0, 0x07, 0x87, 0xb4, 0x67, 0x70, 0xb2, 0xcf, 0x3c, 0x5f, 0xa7, 0x8f,
0xa0, 0x80, 0xc5, 0x20, 0xb7, 0xae, 0xec, 0x10, 0xf8, 0x92, 0x3e, 0x5e, 0x7b, 0x08, 0xef, 0xb0,
0xe9, 0xf6, 0x4d, 0xab, 0x06, 0xb3, 0x1e, 0xcc, 0x5f, 0xb6, 0x85, 0xa3, 0xc3, 0xd5, 0xa2, 0x87,
0xad, 0xaf, 0xeb, 0x45, 0x0f, 0x54, 0x6f, 0x69, 0xef, 0xc2, 0xc9, 0x3e, 0x6d, 0x7c, 0xfd, 0xea,
0x70, 0xfc, 0x2e, 0x76, 0xc7, 0x62, 0x65, 0x13, 0x96, 0xc2, 0xaa, 0xc6, 0xb1, 0x10, 0x7f, 0xc8,
0x88, 0x32, 0x8d, 0x8e, 0x1d, 0xab, 0x67, 0xfb, 0xa5, 0xd6, 0x31, 0xc4, 0x17, 0x41, 0xae, 0x6d,
0x98, 0xbc, 0xb8, 0xa1, 0xd3, 0xff, 0x51, 0x05, 0x66, 0xba, 0x8d, 0x83, 0x8e, 0xd5, 0x68, 0x71,
0xe6, 0x5d, 0xaa, 0xb0, 0x1b, 0x10, 0x15, 0x71, 0xa5, 0xa1, 0x72, 0xd3, 0x3c, 0xd0, 0x05, 0x48,
0xd3, 0x45, 0x02, 0xfa, 0xfe, 0xf1, 0x79, 0x5f, 0x83, 0xbc, 0xcd, 0xc7, 0xb8, 0x77, 0xca, 0x56,
0xa9, 0x27, 0xe7, 0xa1, 0xb5, 0x7b, 0xa2, 0x98, 0x22, 0xcf, 0xb9, 0x0a, 0x45, 0x01, 0xf2, 0xa3,
0x42, 0x09, 0x51, 0x20, 0xeb, 0xeb, 0x3a, 0x08, 0x48, 0xbd, 0xa5, 0x2d, 0x8b, 0x3c, 0x92, 0xbd,
0xd3, 0x7e, 0x99, 0x15, 0x67, 0xfe, 0x51, 0x8d, 0xa0, 0x3b, 0xb0, 0xe8, 0x09, 0x0c, 0xb0, 0xdf,
0x2d, 0x08, 0x21, 0xb1, 0xe3, 0x49, 0x11, 0x9d, 0x1c, 0x22, 0xa2, 0x81, 0xe8, 0xe5, 0x52, 0x46,
0x4f, 0x5e, 0x84, 0x91, 0xa3, 0x77, 0x9b, 0x96, 0x3c, 0x46, 0x0e, 0xdd, 0x63, 0xfa, 0x66, 0x8e,
0xd1, 0xaf, 0xff, 0x65, 0xd9, 0x37, 0xbd, 0x78, 0xe4, 0x6d, 0xe9, 0xf7, 0xe5, 0x2d, 0xfd, 0xbd,
0xa8, 0x6d, 0x53, 0x16, 0xed, 0xdf, 0xd4, 0x7f, 0x3f, 0xfe, 0x4d, 0x7d, 0x4b, 0xda, 0xd4, 0x3f,
0x1e, 0xd4, 0xbb, 0xe1, 0xfb, 0x0a, 0x82, 0x20, 0xa6, 0x7c, 0x82, 0x18, 0x65, 0xab, 0xdf, 0x84,
0x13, 0x92, 0x9f, 0x3c, 0xa8, 0xd7, 0xa1, 0x20, 0xc2, 0x24, 0xb6, 0xfb, 0xf8, 0xa8, 0xfa, 0xf0,
0xda, 0x67, 0xe7, 0x60, 0xe6, 0x16, 0xbb, 0x62, 0x86, 0x0c, 0x98, 0xe1, 0x37, 0xa4, 0x90, 0xa6,
0x92, 0x0f, 0xdf, 0xba, 0x2a, 0x9d, 0x8d, 0xc5, 0x70, 0xa2, 0x38, 0xf1, 0x8f, 0xbf, 0xfc, 0xf7,
0x77, 0xd9, 0x05, 0x98, 0xa3, 0xa0, 0x6f, 0xf0, 0x02, 0x0a, 0xb2, 0xa0, 0xe0, 0x5d, 0x62, 0x41,
0xe7, 0xd2, 0xdc, 0x20, 0x2a, 0x9d, 0x4f, 0x40, 0xc5, 0x1b, 0xb4, 0x01, 0xfc, 0x3b, 0x24, 0xe8,
0x7c, 0x74, 0xc7, 0x30, 0x38, 0xc3, 0x0b, 0x49, 0xb0, 0x44, 0x9b, 0xfe, 0x1d, 0x11, 0xb5, 0xcd,
0xbe, 0x3b, 0x29, 0x6a, 0x9b, 0x8a, 0xab, 0x26, 0x11, 0x36, 0x59, 0x0c, 0xb7, 0x1a, 0x4e, 0x3b,
0x32, 0x86, 0x81, 0x3b, 0x22, 0x91, 0x31, 0x0c, 0xdd, 0x06, 0x89, 0x8f, 0x21, 0xeb, 0xc0, 0x9c,
0x4b, 0x73, 0xe3, 0x22, 0x3a, 0x86, 0xa1, 0xab, 0x02, 0x89, 0xeb, 0x49, 0xa7, 0x17, 0xb3, 0x9e,
0xc1, 0x19, 0x5e, 0x48, 0x82, 0x25, 0xda, 0xf4, 0x9b, 0xef, 0x6a, 0x9b, 0x7d, 0x17, 0x01, 0xd4,
0x36, 0xfb, 0x7b, 0xf8, 0x51, 0x36, 0x5f, 0xc2, 0x6c, 0xb0, 0x71, 0x88, 0x2e, 0xa6, 0xec, 0x84,
0x96, 0xca, 0xc9, 0xc0, 0x78, 0xcb, 0x3f, 0x86, 0xb9, 0xd0, 0x35, 0x09, 0xa4, 0xd4, 0xa8, 0xba,
0x96, 0x51, 0xba, 0x94, 0x02, 0x99, 0x68, 0x3c, 0xd4, 0x65, 0x57, 0x1b, 0x57, 0xf5, 0xf5, 0xd5,
0xc6, 0x95, 0x2d, 0xfb, 0x18, 0xe3, 0xa1, 0x66, 0xba, 0xda, 0xb8, 0xaa, 0x6b, 0xaf, 0x36, 0xae,
0xee, 0xcc, 0x47, 0x18, 0xff, 0x75, 0x26, 0xd4, 0xb0, 0x17, 0xbd, 0x55, 0x54, 0x49, 0xdd, 0x84,
0x65, 0x9e, 0x54, 0x07, 0x6c, 0xda, 0xc6, 0x27, 0x3d, 0xef, 0xe8, 0x44, 0x26, 0x7d, 0xb8, 0x0b,
0x18, 0x99, 0xf4, 0x72, 0x4b, 0x2f, 0x3e, 0xe9, 0x45, 0xfb, 0x29, 0x3a, 0xe9, 0xa5, 0x9e, 0x59,
0x74, 0xd2, 0xcb, 0x9d, 0xac, 0xc4, 0xa4, 0x17, 0x13, 0x8e, 0x49, 0x7a, 0x69, 0xce, 0x97, 0x52,
0x20, 0x53, 0xe6, 0x5d, 0xac, 0x71, 0x55, 0xdb, 0x35, 0x2e, 0xef, 0x52, 0x1a, 0x67, 0x71, 0xe6,
0xf5, 0xf7, 0xc8, 0x38, 0x87, 0x3b, 0x1b, 0x91, 0x71, 0x96, 0x8a, 0xff, 0x09, 0x71, 0x16, 0xad,
0xa1, 0xe8, 0x38, 0x4b, 0xfd, 0xac, 0xe8, 0x38, 0xcb, 0x5d, 0xa6, 0x44, 0x7e, 0x11, 0x13, 0x8e,
0xe1, 0x17, 0x69, 0xce, 0x97, 0x52, 0x20, 0x13, 0x37, 0x4b, 0xaf, 0x29, 0xa1, 0xde, 0x2c, 0xe5,
0x96, 0x47, 0xe9, 0x7c, 0x02, 0x2a, 0x71, 0x9d, 0x83, 0x1d, 0x00, 0xf5, 0x3a, 0x2b, 0xba, 0x1b,
0xa5, 0x72, 0x32, 0x30, 0xde, 0x72, 0x0f, 0x8a, 0x81, 0x3a, 0x36, 0xba, 0x90, 0xae, 0xf4, 0x5e,
0xba, 0x98, 0x88, 0x4b, 0x9c, 0x70, 0xb0, 0x4c, 0xad, 0x9e, 0xb0, 0xa2, 0x26, 0x5e, 0x2a, 0x27,
0x03, 0x13, 0x2d, 0x07, 0x4b, 0xd2, 0x6a, 0xcb, 0x8a, 0xb2, 0x77, 0xa9, 0x9c, 0x0c, 0x4c, 0x93,
0x55, 0xac, 0xa8, 0x15, 0x99, 0x55, 0xa1, 0xaa, 0x59, 0x64, 0x56, 0x49, 0x95, 0xb1, 0xa4, 0xac,
0xe2, 0x36, 0x63, 0xb2, 0x2a, 0x6c, 0xb6, 0x9c, 0x0c, 0x4c, 0x95, 0x55, 0xbc, 0xd0, 0x19, 0x9d,
0x55, 0xe1, 0xda, 0x6c, 0x74, 0x56, 0x49, 0x15, 0xd3, 0xc4, 0xac, 0x8a, 0x9b, 0xb0, 0xa2, 0x68,
0x1a, 0x97, 0x55, 0xa9, 0x97, 0x3a, 0x58, 0xb3, 0x8c, 0xcb, 0xaa, 0x14, 0x96, 0x95, 0xe5, 0xcf,
0x68, 0xcb, 0xc1, 0x52, 0x9c, 0xda, 0xb2, 0xa2, 0xee, 0xa7, 0xb6, 0xac, 0xaa, 0xea, 0x45, 0x59,
0xfe, 0x79, 0x06, 0x16, 0xa4, 0x8a, 0x28, 0xba, 0x1c, 0xbd, 0x90, 0x7d, 0x0e, 0x7c, 0x3d, 0x15,
0x36, 0xd9, 0x07, 0xa9, 0xde, 0xa9, 0xf6, 0x41, 0x5d, 0x62, 0x55, 0xfb, 0x10, 0x55, 0x40, 0x8d,
0x4e, 0xf6, 0x40, 0xf5, 0x06, 0x45, 0x6d, 0xb9, 0x52, 0x95, 0xa8, 0x74, 0x31, 0x11, 0x17, 0x6f,
0xf6, 0xa7, 0x30, 0x1f, 0xae, 0x67, 0xa1, 0x98, 0x8d, 0x4f, 0x36, 0x7e, 0x39, 0x0d, 0x34, 0x71,
0x87, 0x0e, 0x55, 0x38, 0x50, 0x39, 0x6d, 0xb1, 0x46, 0xbd, 0x43, 0x2b, 0xcb, 0x25, 0x31, 0x93,
0x0f, 0x97, 0x62, 0x51, 0xcc, 0xe9, 0x2e, 0xd5, 0xe4, 0xd5, 0x95, 0xdd, 0x18, 0xfb, 0xe1, 0x62,
0x2b, 0x8a, 0x39, 0xe0, 0xa5, 0xb2, 0x1f, 0x51, 0xbb, 0x55, 0xdb, 0x5f, 0x3b, 0xf7, 0xfa, 0xcb,
0x95, 0x89, 0x2f, 0xbe, 0x5c, 0x99, 0xf8, 0xd9, 0xd1, 0x4a, 0xe6, 0xf5, 0xd1, 0x4a, 0xe6, 0xf3,
0xa3, 0x95, 0xcc, 0xbf, 0x8e, 0x56, 0x32, 0xbf, 0x79, 0xb3, 0x32, 0xf1, 0xf9, 0x9b, 0x95, 0x89,
0x2f, 0xde, 0xac, 0x4c, 0xec, 0x4c, 0xd3, 0x4a, 0xe8, 0xd5, 0xff, 0x07, 0x00, 0x00, 0xff, 0xff,
0x61, 0x29, 0x54, 0xa3, 0xb7, 0x38, 0x00, 0x00,
// 2778 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x5a, 0xdb, 0x6f, 0x1b, 0x59,
0x19, 0x8f, 0x1d, 0x27, 0xb6, 0x3f, 0x27, 0x4e, 0x7a, 0x9a, 0xb6, 0x5e, 0xb7, 0x24, 0xd5, 0xf4,
0x12, 0xb7, 0x14, 0x7b, 0xd7, 0x65, 0xd9, 0xd2, 0xdd, 0x02, 0x4d, 0xd3, 0x8b, 0x7b, 0x49, 0xab,
0x49, 0x5a, 0xc1, 0x03, 0x8a, 0x1c, 0xfb, 0x24, 0x3b, 0xb5, 0x33, 0x63, 0x66, 0xc6, 0xdd, 0x46,
0x08, 0xc4, 0xa5, 0x88, 0x27, 0x24, 0x5e, 0x90, 0x10, 0x0f, 0x48, 0x3c, 0x21, 0x81, 0x84, 0x10,
0x4f, 0x3c, 0xf0, 0x07, 0x54, 0x3c, 0xed, 0xe3, 0x3e, 0x05, 0x36, 0x15, 0x12, 0x4f, 0xfc, 0x0b,
0xac, 0xce, 0x6d, 0x6e, 0x3e, 0x73, 0xf1, 0x45, 0xea, 0x3e, 0x25, 0x3e, 0xf3, 0xfb, 0x2e, 0xe7,
0xfb, 0xbe, 0xf9, 0x9d, 0x33, 0xdf, 0x39, 0x70, 0x65, 0x4f, 0xb3, 0x3f, 0xee, 0xef, 0x54, 0x5b,
0xc6, 0x7e, 0xad, 0x6d, 0xb4, 0x3a, 0xd8, 0xac, 0x59, 0x9f, 0x34, 0xcd, 0xfd, 0x8e, 0x66, 0xd7,
0x9a, 0x3d, 0xad, 0xd6, 0x32, 0x74, 0xdb, 0x34, 0xba, 0xd5, 0x9e, 0x69, 0xd8, 0x06, 0x42, 0x0c,
0x52, 0x15, 0x90, 0xea, 0x8b, 0xf7, 0xca, 0x97, 0x63, 0x34, 0x58, 0x3d, 0xdc, 0xb2, 0x98, 0x7c,
0x39, 0xce, 0x9a, 0xb1, 0xf3, 0x1c, 0xb7, 0x6c, 0x81, 0x8e, 0xd3, 0x6c, 0x1f, 0xf4, 0xb0, 0xc0,
0x2e, 0xed, 0x19, 0x7b, 0x06, 0xfd, 0xb7, 0x46, 0xfe, 0xe3, 0xa3, 0xef, 0xec, 0x19, 0xc6, 0x5e,
0x17, 0xd7, 0xe8, 0xaf, 0x9d, 0xfe, 0x6e, 0xad, 0xa9, 0x1f, 0xf0, 0x47, 0x1f, 0x44, 0x28, 0x77,
0xe0, 0xbd, 0x6e, 0x7f, 0x4f, 0xd3, 0xf9, 0x1f, 0x26, 0xa8, 0xbc, 0x0f, 0xc5, 0xbb, 0xd8, 0xde,
0x30, 0xda, 0x58, 0xc5, 0x3f, 0xe8, 0x63, 0xcb, 0x46, 0xe7, 0x20, 0xab, 0x1b, 0x6d, 0xbc, 0xad,
0xb5, 0x4b, 0xa9, 0xb3, 0xa9, 0x4a, 0x7e, 0x0d, 0x8e, 0x0e, 0x57, 0x66, 0x09, 0xa2, 0xb1, 0xae,
0xce, 0x92, 0x47, 0x8d, 0xb6, 0xf2, 0x6d, 0x58, 0x70, 0xc4, 0xac, 0x9e, 0xa1, 0x5b, 0x18, 0x5d,
0x81, 0x0c, 0x79, 0x48, 0x85, 0x0a, 0xf5, 0x52, 0x75, 0x30, 0xb8, 0x55, 0x8a, 0xa7, 0x28, 0xe5,
0xd5, 0x0c, 0x2c, 0x3e, 0xd4, 0x2c, 0xaa, 0xc2, 0x12, 0xa6, 0xef, 0x40, 0x76, 0x57, 0xeb, 0xda,
0xd8, 0xb4, 0xb8, 0x96, 0x2b, 0x32, 0x2d, 0x41, 0xb1, 0xea, 0x1d, 0x26, 0xa3, 0x0a, 0xe1, 0xf2,
0x1f, 0x33, 0x90, 0xe5, 0x83, 0x68, 0x09, 0x66, 0xf4, 0xe6, 0x3e, 0x26, 0x1a, 0xa7, 0x2b, 0x79,
0x95, 0xfd, 0x40, 0x35, 0x28, 0x68, 0xed, 0xed, 0x9e, 0x89, 0x77, 0xb5, 0x97, 0xd8, 0x2a, 0xa5,
0xc9, 0xb3, 0xb5, 0xe2, 0xd1, 0xe1, 0x0a, 0x34, 0xd6, 0x9f, 0xf0, 0x51, 0x15, 0xb4, 0xb6, 0xf8,
0x1f, 0x3d, 0x81, 0xd9, 0x6e, 0x73, 0x07, 0x77, 0xad, 0xd2, 0xf4, 0xd9, 0xe9, 0x4a, 0xa1, 0x7e,
0x6d, 0x18, 0xcf, 0xaa, 0x0f, 0xa9, 0xe8, 0x6d, 0xdd, 0x36, 0x0f, 0x54, 0xae, 0x07, 0x7d, 0x1f,
0x0a, 0x34, 0xce, 0x5c, 0x6d, 0x96, 0xaa, 0xfd, 0x68, 0x28, 0xb5, 0x64, 0xd0, 0xab, 0x1a, 0x74,
0x67, 0x00, 0x3d, 0x82, 0xc2, 0x3e, 0xde, 0xdf, 0xc1, 0xa6, 0xf5, 0xb1, 0xd6, 0xb3, 0x4a, 0x99,
0xb3, 0xd3, 0x95, 0x62, 0x7d, 0x35, 0x2c, 0x2b, 0x9b, 0x3d, 0xdc, 0xaa, 0x3e, 0x72, 0xf0, 0x6b,
0xe9, 0xc5, 0x29, 0xd5, 0x2b, 0x8f, 0xbe, 0x01, 0x33, 0xa6, 0xd1, 0xc5, 0x56, 0x69, 0x86, 0x2a,
0x3a, 0x13, 0x9a, 0x5e, 0xa3, 0x8b, 0xa9, 0x34, 0x83, 0xa3, 0x73, 0x30, 0x4f, 0x22, 0xee, 0x86,
0x7a, 0x96, 0xa6, 0x61, 0x8e, 0x0c, 0x8a, 0xe0, 0x96, 0xbf, 0x09, 0x05, 0xcf, 0x34, 0xd0, 0x22,
0x4c, 0x77, 0xf0, 0x01, 0xab, 0x3e, 0x95, 0xfc, 0x4b, 0x92, 0xf8, 0xa2, 0xd9, 0xed, 0xe3, 0x52,
0x9a, 0x8e, 0xb1, 0x1f, 0xd7, 0xd3, 0xd7, 0x52, 0xe5, 0x1b, 0xb0, 0x10, 0x88, 0xc2, 0x30, 0xe2,
0xca, 0x2d, 0x38, 0xe6, 0x89, 0x2e, 0xaf, 0xe4, 0x2a, 0xcc, 0x90, 0x40, 0xb2, 0x92, 0x89, 0x2a,
0x65, 0x06, 0x53, 0xfe, 0x94, 0x82, 0x63, 0x4f, 0x7b, 0xed, 0xa6, 0x8d, 0x87, 0x7d, 0x8f, 0xd0,
0xb7, 0x60, 0x8e, 0x82, 0x5e, 0x60, 0xd3, 0xd2, 0x0c, 0x9d, 0x3a, 0x58, 0xa8, 0x9f, 0x96, 0x59,
0x7c, 0xc6, 0x20, 0x2a, 0xad, 0x1a, 0xfe, 0x03, 0xbd, 0x0b, 0x19, 0xc2, 0x48, 0xa5, 0x69, 0x2a,
0x77, 0x26, 0x2a, 0xbd, 0x2a, 0x45, 0x2a, 0x6b, 0x80, 0xbc, 0xbe, 0x8e, 0xf4, 0xf2, 0x6e, 0xc0,
0x31, 0x15, 0xef, 0x1b, 0x2f, 0x86, 0x9f, 0xef, 0x12, 0xcc, 0xec, 0x1a, 0x66, 0x8b, 0x65, 0x22,
0xa7, 0xb2, 0x1f, 0xca, 0x12, 0x20, 0xaf, 0x3e, 0xe6, 0x13, 0xa7, 0xa6, 0xad, 0xa6, 0xd5, 0xf1,
0x98, 0xb0, 0x9b, 0x56, 0x27, 0x60, 0x82, 0x20, 0x88, 0x09, 0xf2, 0xc8, 0xa1, 0x26, 0x26, 0xe6,
0xce, 0x8e, 0x3c, 0x8c, 0x9a, 0x1d, 0xc5, 0x53, 0x94, 0x72, 0x4d, 0xcc, 0x6e, 0x68, 0xd3, 0xce,
0x3c, 0xbc, 0xd6, 0x95, 0x7f, 0x64, 0x18, 0xd5, 0x91, 0xc1, 0x11, 0xa8, 0xce, 0x2b, 0x36, 0x48,
0x75, 0xff, 0x9a, 0x7e, 0x7b, 0x54, 0x27, 0xf3, 0x4c, 0x4a, 0x75, 0x35, 0x28, 0x58, 0xd8, 0x7c,
0xa1, 0xb5, 0x48, 0x75, 0x30, 0x2e, 0xe2, 0x2e, 0x6c, 0xb2, 0xe1, 0xc6, 0xba, 0xa5, 0x02, 0x87,
0x34, 0xda, 0x16, 0xba, 0x08, 0x39, 0x5e, 0x4b, 0x8c, 0x70, 0xf2, 0x6b, 0x85, 0xa3, 0xc3, 0x95,
0x2c, 0x2b, 0x26, 0x4b, 0xcd, 0xb2, 0x6a, 0xb2, 0xd0, 0x3d, 0x28, 0xb6, 0xb1, 0xa5, 0x99, 0xb8,
0xbd, 0x6d, 0xd9, 0x4d, 0x9b, 0xd3, 0x4b, 0xb1, 0xfe, 0x95, 0xb0, 0x14, 0x6f, 0x12, 0x14, 0xe5,
0xa7, 0x79, 0x2e, 0x48, 0x47, 0x24, 0x3c, 0x95, 0x1d, 0xe4, 0x29, 0x54, 0x86, 0x9c, 0xd9, 0xd7,
0x6d, 0x8d, 0xc4, 0x38, 0x4f, 0x9f, 0x3b, 0xbf, 0xd1, 0x19, 0x80, 0x7e, 0x6f, 0xdb, 0x36, 0xb6,
0xc9, 0xbb, 0x55, 0xca, 0xd1, 0xf2, 0xce, 0xf5, 0x7b, 0x5b, 0xc6, 0x7a, 0xd3, 0xc6, 0x63, 0x30,
0x9c, 0xa0, 0x28, 0x1e, 0x6c, 0x97, 0xa2, 0x48, 0xcd, 0x45, 0x52, 0x14, 0x2d, 0x42, 0x06, 0x53,
0x1e, 0xc0, 0xd2, 0x2d, 0x13, 0x37, 0x6d, 0xcc, 0x03, 0x2e, 0xca, 0xf0, 0x2a, 0xe7, 0x0f, 0x56,
0x83, 0x2b, 0x32, 0x35, 0x5c, 0xc2, 0x43, 0x21, 0x1b, 0x70, 0x22, 0xa0, 0x8c, 0x7b, 0xf5, 0x3e,
0x64, 0x79, 0x12, 0xb9, 0xc2, 0xd3, 0x11, 0x0a, 0x55, 0x81, 0x55, 0x9e, 0xc3, 0xb1, 0xbb, 0xd8,
0x0e, 0x78, 0x76, 0x05, 0xc0, 0xad, 0x19, 0xfe, 0xce, 0xcd, 0x1f, 0x1d, 0xae, 0xe4, 0x9d, 0x92,
0x51, 0xf3, 0x4e, 0xc5, 0xa0, 0x55, 0x58, 0xd0, 0x74, 0x0b, 0x9b, 0xf6, 0x76, 0x1b, 0xef, 0x36,
0xfb, 0x5d, 0xdb, 0xe2, 0x0c, 0x53, 0x64, 0xc3, 0xeb, 0x7c, 0x54, 0x79, 0x00, 0xc8, 0x6b, 0x6b,
0x3c, 0xc7, 0xff, 0x96, 0x86, 0x25, 0x46, 0xa6, 0x63, 0x39, 0xbf, 0x0e, 0x0b, 0x02, 0x3d, 0xc4,
0x3a, 0x50, 0xe4, 0x32, 0x62, 0x29, 0xb8, 0xea, 0x5b, 0x0a, 0x92, 0xa5, 0x12, 0x3d, 0x82, 0x9c,
0x69, 0x74, 0xbb, 0x3b, 0xcd, 0x56, 0xa7, 0x94, 0x39, 0x9b, 0xaa, 0x14, 0xeb, 0xef, 0xc9, 0x04,
0x65, 0x93, 0xac, 0xaa, 0x5c, 0x50, 0x75, 0x54, 0x28, 0x0a, 0xe4, 0xc4, 0x28, 0xca, 0x41, 0x66,
0xe3, 0xf1, 0xc6, 0xed, 0xc5, 0x29, 0x34, 0x07, 0xb9, 0x27, 0xea, 0xed, 0x67, 0x8d, 0xc7, 0x4f,
0x37, 0x17, 0x53, 0xa4, 0x7a, 0x02, 0xea, 0xc6, 0x4b, 0xc2, 0x3a, 0x2c, 0x31, 0xd2, 0x1d, 0x27,
0x07, 0xca, 0x29, 0x38, 0x11, 0xd0, 0xc2, 0xd9, 0xfb, 0xd5, 0x34, 0x1c, 0x27, 0xef, 0x1f, 0x1f,
0x77, 0x08, 0xbc, 0x11, 0x24, 0xf0, 0x5a, 0x18, 0x4d, 0x06, 0x24, 0x07, 0x39, 0xfc, 0x0f, 0xe9,
0x89, 0x73, 0xf8, 0x66, 0x80, 0xc3, 0x3f, 0x1c, 0xd2, 0x39, 0x29, 0x8d, 0x0f, 0x70, 0x64, 0x26,
0x86, 0x23, 0x67, 0xfc, 0x1c, 0x39, 0x0e, 0x0b, 0x3e, 0x86, 0x25, 0xbf, 0xbb, 0xbc, 0x68, 0x3e,
0x80, 0x1c, 0x4f, 0xa2, 0xe0, 0xc2, 0xc8, 0xaa, 0x71, 0xc0, 0xca, 0x35, 0x28, 0x7b, 0x14, 0x92,
0x55, 0xa0, 0x6f, 0xb9, 0xd9, 0x2d, 0x07, 0xd4, 0xe6, 0x3d, 0x92, 0x7f, 0x4e, 0xc3, 0x69, 0xa9,
0x28, 0x77, 0xe9, 0x7b, 0x90, 0xb3, 0xf8, 0x18, 0x77, 0xe9, 0x46, 0x4c, 0xf4, 0x83, 0x2a, 0xaa,
0xbe, 0x71, 0xd5, 0x51, 0x57, 0xfe, 0x6b, 0x0a, 0xe6, 0x7d, 0xcf, 0x86, 0x64, 0x9a, 0x73, 0x20,
0x96, 0xbd, 0x6d, 0xb6, 0x7c, 0x90, 0x38, 0x67, 0xd4, 0x39, 0x3e, 0x48, 0xd7, 0x18, 0x02, 0x32,
0xfb, 0xba, 0xae, 0xe9, 0x7b, 0x1c, 0x34, 0xcd, 0x40, 0x7c, 0x90, 0x81, 0x56, 0x61, 0xa1, 0x65,
0xec, 0xf7, 0xba, 0xd8, 0x76, 0x74, 0x65, 0x28, 0xac, 0xe8, 0x0c, 0x6f, 0xf9, 0x57, 0x9e, 0x0d,
0x6c, 0x7f, 0x62, 0x98, 0x9d, 0x21, 0x56, 0x1e, 0x2e, 0x21, 0x5b, 0x79, 0x1c, 0x65, 0x2e, 0x77,
0xe8, 0x6c, 0x28, 0x8a, 0x3b, 0x84, 0x94, 0xc0, 0x2a, 0x4f, 0xe9, 0xca, 0x13, 0xf0, 0x0c, 0x41,
0x86, 0x54, 0x34, 0xaf, 0x4b, 0xfa, 0x3f, 0x09, 0x33, 0x97, 0x21, 0x61, 0x4e, 0xbb, 0x61, 0xe6,
0xb2, 0x24, 0xcc, 0x1c, 0xd0, 0x68, 0xf3, 0x45, 0x66, 0x42, 0x3e, 0x7e, 0x57, 0xf0, 0xdb, 0xc4,
0xdd, 0x74, 0x38, 0x2f, 0xe0, 0xa9, 0xf2, 0xdf, 0x34, 0xe3, 0x3c, 0x3e, 0x3e, 0x02, 0xe7, 0x05,
0x24, 0x07, 0x39, 0xef, 0x17, 0x6f, 0x91, 0xf3, 0x42, 0x9c, 0x1b, 0x99, 0xf3, 0x26, 0xc0, 0x6b,
0xae, 0x4b, 0x2e, 0xaf, 0xf1, 0x44, 0x45, 0xf2, 0x9a, 0xc8, 0x9c, 0x03, 0x56, 0x6e, 0xd2, 0x92,
0xbe, 0xd5, 0xed, 0x5b, 0x36, 0x36, 0x3d, 0x6b, 0x61, 0x8b, 0x8d, 0x04, 0x58, 0x82, 0xe3, 0x48,
0x5d, 0x70, 0x80, 0x53, 0xbe, 0x8e, 0x0a, 0xb7, 0x7c, 0x39, 0x24, 0xaa, 0x7c, 0x85, 0x94, 0xc0,
0x3a, 0xb5, 0xc4, 0x1f, 0x8c, 0x50, 0x4b, 0x01, 0xc9, 0x2f, 0x57, 0x2d, 0x85, 0x38, 0xf7, 0x36,
0x6b, 0xc9, 0x75, 0xc9, 0xad, 0x25, 0x9e, 0x8d, 0xc8, 0x5a, 0x12, 0xa9, 0x73, 0xc0, 0xca, 0x6f,
0x52, 0x50, 0x78, 0x80, 0x0f, 0x54, 0xc3, 0x6e, 0xda, 0x64, 0x8b, 0x79, 0x19, 0x8e, 0x91, 0x22,
0xc3, 0xe6, 0xf6, 0x73, 0x43, 0xd3, 0xb7, 0x6d, 0xa3, 0x83, 0x75, 0xea, 0x5a, 0x4e, 0x5d, 0x60,
0x0f, 0xee, 0x1b, 0x9a, 0xbe, 0x45, 0x86, 0xd1, 0x15, 0x40, 0xfb, 0x4d, 0xbd, 0xb9, 0xe7, 0x07,
0xb3, 0x4d, 0xf9, 0x22, 0x7f, 0x22, 0x45, 0xf7, 0xf5, 0xae, 0xd1, 0xea, 0x6c, 0x93, 0x59, 0x4f,
0xfb, 0xd0, 0x4f, 0xe9, 0x83, 0x07, 0xf8, 0x40, 0xf9, 0x99, 0xb3, 0xef, 0x1e, 0xa7, 0xce, 0xc9,
0xbe, 0x5b, 0xa0, 0x87, 0xd9, 0x77, 0x73, 0x99, 0x21, 0xf6, 0xdd, 0xdc, 0xba, 0x67, 0xdf, 0x7d,
0x93, 0xec, 0xbb, 0x59, 0x54, 0xe9, 0xba, 0x19, 0x22, 0xe8, 0x09, 0xfe, 0x5a, 0xe6, 0xf5, 0xe1,
0xca, 0x94, 0xea, 0x88, 0xb9, 0xfb, 0xe8, 0x09, 0xbd, 0xa8, 0x37, 0x60, 0x91, 0x7e, 0x19, 0xb5,
0x4c, 0x6c, 0x8b, 0x78, 0x5e, 0x82, 0xbc, 0x45, 0x07, 0xdc, 0x70, 0xce, 0x1d, 0x1d, 0xae, 0xe4,
0x18, 0xaa, 0xb1, 0x4e, 0x76, 0x45, 0xf4, 0xbf, 0xb6, 0x72, 0x97, 0x7f, 0xc4, 0x31, 0x71, 0xee,
0x4a, 0x1d, 0x66, 0x19, 0x80, 0x7b, 0x52, 0x96, 0xef, 0xcd, 0xa8, 0x0c, 0x47, 0x2a, 0x7f, 0x4f,
0xc1, 0x71, 0xf1, 0x81, 0x30, 0x9a, 0x2f, 0x68, 0x0d, 0x8a, 0x1c, 0x3a, 0x44, 0x5e, 0xe7, 0x99,
0x88, 0x48, 0x6b, 0xdd, 0x97, 0xd6, 0xe5, 0x70, 0xc7, 0x3d, 0xdb, 0x93, 0xfb, 0xee, 0xe7, 0xe0,
0xd8, 0x61, 0xf8, 0x4f, 0x1a, 0x10, 0xdb, 0x22, 0x92, 0x9f, 0x0e, 0x6d, 0xde, 0x0b, 0xd2, 0x66,
0x35, 0x7c, 0x6f, 0xe9, 0x15, 0x1c, 0x64, 0xcd, 0x57, 0x93, 0x67, 0x4d, 0x35, 0xc0, 0x9a, 0xd7,
0x87, 0xf3, 0xed, 0xad, 0x90, 0xe6, 0x03, 0xf1, 0x79, 0xc7, 0x3d, 0xe2, 0x29, 0xfb, 0x3a, 0xf9,
0x18, 0xa5, 0x43, 0x9c, 0x32, 0xa3, 0x72, 0x26, 0xa0, 0x4a, 0x03, 0x8e, 0x8b, 0xce, 0x88, 0xb7,
0x74, 0xeb, 0xbe, 0xbd, 0x6e, 0xe2, 0x5a, 0xf2, 0xab, 0x1a, 0xa3, 0x96, 0xbe, 0x03, 0xc7, 0xc5,
0xc7, 0xed, 0x88, 0x6f, 0xf7, 0x49, 0xf7, 0x23, 0xdb, 0xeb, 0x0d, 0x27, 0x8d, 0x5b, 0x86, 0xbe,
0xab, 0xed, 0x79, 0xd4, 0xb6, 0xe8, 0x40, 0x40, 0x2d, 0x43, 0x11, 0xb5, 0xec, 0xb1, 0x43, 0x1a,
0x42, 0xdc, 0x9d, 0x21, 0x03, 0x44, 0xcd, 0x90, 0xcb, 0x70, 0xa4, 0x87, 0x34, 0x46, 0xf5, 0x85,
0x90, 0x06, 0x87, 0x0e, 0x43, 0x1a, 0x4c, 0x64, 0x08, 0xd2, 0x60, 0x96, 0x65, 0xa4, 0x31, 0x81,
0x30, 0x08, 0xd2, 0x60, 0xc3, 0x23, 0x90, 0x86, 0x5f, 0xf0, 0xcb, 0x45, 0x1a, 0x72, 0xdf, 0xde,
0x26, 0x69, 0x38, 0x1e, 0xb9, 0xa4, 0xc1, 0x12, 0x11, 0x49, 0x1a, 0x3c, 0x67, 0x02, 0xea, 0x92,
0x86, 0xbf, 0x74, 0x13, 0x90, 0x86, 0xac, 0x96, 0xfc, 0xaa, 0xc6, 0xa8, 0x25, 0x87, 0x34, 0x46,
0x7e, 0xbb, 0x1d, 0xd2, 0xf0, 0x7b, 0xa3, 0xfc, 0x08, 0x4e, 0x32, 0x2f, 0x6f, 0xbf, 0xb4, 0xb1,
0x4e, 0xdf, 0x23, 0xae, 0xfc, 0x26, 0x14, 0x9a, 0xba, 0xce, 0x77, 0x38, 0x56, 0x54, 0x6f, 0xe0,
0xa6, 0x0b, 0x53, 0xbd, 0x32, 0xe8, 0x2c, 0x14, 0xda, 0xd8, 0x6a, 0x99, 0x5a, 0xcf, 0x16, 0xef,
0x70, 0x5e, 0xf5, 0x0e, 0x29, 0xcf, 0xe0, 0xd4, 0x80, 0x79, 0x1e, 0xa7, 0x0f, 0x21, 0x8f, 0xc5,
0x20, 0xb7, 0x2e, 0x3d, 0x4a, 0x70, 0x25, 0x5d, 0xbc, 0xf2, 0x10, 0x4e, 0xb2, 0xe9, 0x0e, 0x4c,
0xab, 0x0e, 0x73, 0x0e, 0xcc, 0x0d, 0xdb, 0xc2, 0xd1, 0xe1, 0x4a, 0xc1, 0xc1, 0x36, 0xd6, 0xd5,
0x82, 0x03, 0x6a, 0xb4, 0x95, 0x77, 0xe0, 0xd4, 0x80, 0x36, 0x1e, 0xbf, 0x06, 0x1c, 0xbf, 0x8b,
0xed, 0x89, 0x58, 0xd9, 0x84, 0x25, 0xbf, 0xaa, 0x49, 0x04, 0xe2, 0xf7, 0x29, 0xd1, 0xa6, 0x51,
0xb1, 0x65, 0xf4, 0x4d, 0xb7, 0x27, 0x3b, 0x81, 0xfc, 0x22, 0xc8, 0x74, 0x34, 0x9d, 0x37, 0x37,
0x54, 0xfa, 0x3f, 0xaa, 0x42, 0xb6, 0xd7, 0x3c, 0xe8, 0x1a, 0xcd, 0x36, 0x67, 0xde, 0xa5, 0x2a,
0xbb, 0x2a, 0x51, 0x15, 0x77, 0x1f, 0xaa, 0x37, 0xf5, 0x03, 0x55, 0x80, 0x14, 0x55, 0x14, 0xa0,
0xeb, 0x1f, 0x9f, 0xf7, 0x35, 0xc8, 0x99, 0x7c, 0x8c, 0x7b, 0x27, 0x3d, 0x53, 0x75, 0xe4, 0x1c,
0xb4, 0x72, 0x4f, 0x34, 0x53, 0x82, 0x73, 0xae, 0x41, 0x41, 0x80, 0xdc, 0xac, 0x50, 0x42, 0x14,
0xc8, 0xc6, 0xba, 0x0a, 0x02, 0xd2, 0x68, 0x2b, 0x25, 0x51, 0x47, 0x41, 0xef, 0x94, 0x9f, 0xa7,
0xc5, 0x9e, 0x7f, 0x5c, 0x23, 0xe8, 0x0e, 0x2c, 0x3a, 0x02, 0x43, 0xac, 0x77, 0x0b, 0x42, 0x48,
0xac, 0x78, 0x81, 0x8c, 0x4e, 0x8f, 0x90, 0x51, 0x4f, 0xf6, 0x32, 0x09, 0xb3, 0x17, 0x0c, 0xc2,
0xd8, 0xd9, 0xbb, 0x4d, 0x5b, 0x1e, 0x63, 0xa7, 0xee, 0x31, 0x7d, 0x33, 0x27, 0xe8, 0xd7, 0xff,
0xd3, 0xec, 0x9b, 0x5e, 0x3c, 0x72, 0x96, 0xf4, 0xfb, 0xc1, 0x25, 0xfd, 0xdd, 0xb0, 0x65, 0x33,
0x28, 0x3a, 0xb8, 0xa8, 0xff, 0x6e, 0xf2, 0x8b, 0xfa, 0x56, 0x60, 0x51, 0xff, 0x68, 0x58, 0xef,
0x46, 0x3f, 0x80, 0x10, 0x04, 0x31, 0xe3, 0x12, 0xc4, 0x38, 0x4b, 0xfd, 0x26, 0x9c, 0x08, 0xf8,
0xc9, 0x93, 0x7a, 0x1d, 0xf2, 0x22, 0x4d, 0x62, 0xb9, 0x8f, 0xce, 0xaa, 0x0b, 0xaf, 0xff, 0xf2,
0x3c, 0x64, 0x6f, 0xb1, 0xbb, 0x68, 0x48, 0x83, 0x2c, 0xbf, 0x4a, 0x85, 0x14, 0x99, 0xbc, 0xff,
0x7a, 0x56, 0xf9, 0x5c, 0x24, 0x86, 0x13, 0xc5, 0x89, 0x7f, 0xfe, 0xe5, 0x7f, 0xbf, 0x4d, 0x2f,
0xc0, 0x3c, 0x05, 0x7d, 0x8d, 0x37, 0x50, 0x90, 0x01, 0x79, 0xe7, 0xb6, 0x0b, 0x3a, 0x9f, 0xe4,
0xaa, 0x51, 0xf9, 0x42, 0x0c, 0x2a, 0xda, 0xa0, 0x09, 0xe0, 0x5e, 0x36, 0x41, 0x17, 0xc2, 0x8f,
0x16, 0xbd, 0x33, 0xbc, 0x18, 0x07, 0x8b, 0xb5, 0xe9, 0x5e, 0x26, 0x91, 0xdb, 0x1c, 0xb8, 0xbc,
0x22, 0xb7, 0x29, 0xb9, 0x93, 0x12, 0x62, 0x93, 0xe5, 0x70, 0xab, 0x69, 0x75, 0x42, 0x73, 0xe8,
0xb9, 0x4c, 0x12, 0x9a, 0x43, 0xdf, 0xb5, 0x91, 0xe8, 0x1c, 0xb2, 0x53, 0x98, 0xf3, 0x49, 0xae,
0x66, 0x84, 0xe7, 0xd0, 0x77, 0xa7, 0x20, 0x36, 0x9e, 0x74, 0x7a, 0x11, 0xf1, 0xf4, 0xce, 0xf0,
0x62, 0x1c, 0x2c, 0xd6, 0xa6, 0x7b, 0x4a, 0x2f, 0xb7, 0x39, 0x70, 0x63, 0x40, 0x6e, 0x73, 0xf0,
0xb0, 0x3f, 0xcc, 0xe6, 0x4b, 0x98, 0xf3, 0x9e, 0x30, 0xa2, 0xd5, 0x84, 0x47, 0xa6, 0xe5, 0x4a,
0x3c, 0x30, 0xda, 0xf2, 0x0f, 0x61, 0xde, 0x77, 0x9f, 0x02, 0x49, 0x35, 0xca, 0xee, 0x6f, 0x94,
0x2f, 0x25, 0x40, 0xc6, 0x1a, 0xf7, 0x1d, 0xc7, 0xcb, 0x8d, 0xcb, 0x2e, 0x00, 0xc8, 0x8d, 0x4b,
0xcf, 0xf6, 0x23, 0x8c, 0xfb, 0x4e, 0xdd, 0xe5, 0xc6, 0x65, 0xc7, 0xfb, 0x72, 0xe3, 0xf2, 0x23,
0xfc, 0x10, 0xe3, 0xbf, 0x4a, 0xf9, 0x4e, 0xf6, 0xc5, 0x21, 0x2c, 0xaa, 0x26, 0x3e, 0xad, 0x65,
0x9e, 0xd4, 0x86, 0x3c, 0xdd, 0x8d, 0x2e, 0x7a, 0x7e, 0xa2, 0x13, 0x5a, 0xf4, 0xfe, 0x53, 0xc0,
0xd0, 0xa2, 0x0f, 0x1e, 0xe9, 0x45, 0x17, 0xbd, 0x38, 0x7e, 0x0a, 0x2f, 0xfa, 0xc0, 0x99, 0x59,
0x78, 0xd1, 0x07, 0x4f, 0xb2, 0x62, 0x8b, 0x5e, 0x4c, 0x38, 0xa2, 0xe8, 0x03, 0x73, 0xbe, 0x94,
0x00, 0x99, 0xb0, 0xee, 0x22, 0x8d, 0xcb, 0x8e, 0x5d, 0xa3, 0xea, 0x2e, 0xa1, 0x71, 0x96, 0x67,
0xde, 0x7f, 0x0f, 0xcd, 0xb3, 0xff, 0x64, 0x23, 0x34, 0xcf, 0x81, 0xe6, 0x7f, 0x4c, 0x9e, 0xc5,
0xd1, 0x50, 0x78, 0x9e, 0x03, 0xe7, 0x59, 0xe1, 0x79, 0x0e, 0x9e, 0x32, 0xc5, 0xf2, 0x8b, 0x98,
0x70, 0x04, 0xbf, 0x04, 0xe6, 0x7c, 0x29, 0x01, 0x32, 0x76, 0xb1, 0x74, 0x0e, 0x25, 0xe4, 0x8b,
0x65, 0xf0, 0xc8, 0xa3, 0x7c, 0x21, 0x06, 0x15, 0x1b, 0x67, 0xef, 0x09, 0x80, 0x3c, 0xce, 0x92,
0xd3, 0x8d, 0x72, 0x25, 0x1e, 0x18, 0x6d, 0xb9, 0x0f, 0x05, 0x4f, 0x1f, 0x1b, 0x5d, 0x4c, 0xd6,
0x7a, 0x2f, 0xaf, 0xc6, 0xe2, 0x62, 0x27, 0xec, 0x6d, 0x53, 0xcb, 0x27, 0x2c, 0xe9, 0x89, 0x97,
0x2b, 0xf1, 0xc0, 0x58, 0xcb, 0xde, 0x96, 0xb4, 0xdc, 0xb2, 0xa4, 0xed, 0x5d, 0xae, 0xc4, 0x03,
0x93, 0x54, 0x15, 0x6b, 0x6a, 0x85, 0x56, 0x95, 0xaf, 0x6b, 0x16, 0x5a, 0x55, 0x81, 0xce, 0x58,
0x5c, 0x55, 0x71, 0x9b, 0x11, 0x55, 0xe5, 0x37, 0x5b, 0x89, 0x07, 0x26, 0xaa, 0x2a, 0xde, 0xe8,
0x0c, 0xaf, 0x2a, 0x7f, 0x6f, 0x36, 0xbc, 0xaa, 0x02, 0x1d, 0xd3, 0xd8, 0xaa, 0x8a, 0x9a, 0xb0,
0xa4, 0x69, 0x1a, 0x55, 0x55, 0x89, 0x43, 0xed, 0xed, 0x59, 0x46, 0x55, 0x55, 0x02, 0xcb, 0xd2,
0xf6, 0x67, 0xb8, 0x65, 0x6f, 0x2b, 0x4e, 0x6e, 0x59, 0xd2, 0xf7, 0x93, 0x5b, 0x96, 0x75, 0xf5,
0xc2, 0x2c, 0xff, 0x34, 0x05, 0x0b, 0x81, 0x8e, 0x28, 0xba, 0x1c, 0x1e, 0xc8, 0x01, 0x07, 0xbe,
0x9a, 0x08, 0x1b, 0xef, 0x43, 0xa0, 0xdf, 0x29, 0xf7, 0x41, 0xde, 0x62, 0x95, 0xfb, 0x10, 0xd6,
0x40, 0x0d, 0x2f, 0x76, 0x4f, 0xf7, 0x06, 0x85, 0x2d, 0xb9, 0x81, 0x2e, 0x51, 0x79, 0x35, 0x16,
0x17, 0x6d, 0xf6, 0xc7, 0x50, 0xf4, 0xf7, 0xb3, 0x50, 0xc4, 0xc2, 0x17, 0x34, 0x7e, 0x39, 0x09,
0x34, 0x76, 0x85, 0xf6, 0x75, 0x38, 0x50, 0x25, 0x69, 0xb3, 0x46, 0xbe, 0x42, 0x4b, 0xdb, 0x25,
0x11, 0x93, 0xf7, 0xb7, 0x62, 0x51, 0xc4, 0xee, 0x2e, 0xd1, 0xe4, 0xe5, 0x9d, 0xdd, 0x08, 0xfb,
0xfe, 0x66, 0x2b, 0x8a, 0xd8, 0xe0, 0x25, 0xb2, 0x1f, 0xd2, 0xbb, 0x95, 0xdb, 0x5f, 0x3b, 0xff,
0xfa, 0xf3, 0xe5, 0xa9, 0xcf, 0x3e, 0x5f, 0x9e, 0xfa, 0xc9, 0xd1, 0x72, 0xea, 0xf5, 0xd1, 0x72,
0xea, 0xd3, 0xa3, 0xe5, 0xd4, 0xbf, 0x8f, 0x96, 0x53, 0xbf, 0x7e, 0xb3, 0x3c, 0xf5, 0xe9, 0x9b,
0xe5, 0xa9, 0xcf, 0xde, 0x2c, 0x4f, 0xed, 0xcc, 0xd2, 0x4e, 0xe8, 0xd5, 0x2f, 0x02, 0x00, 0x00,
0xff, 0xff, 0xf1, 0x75, 0x17, 0x2e, 0xe0, 0x38, 0x00, 0x00,
}
type authenticatedWrapperControlServer struct {
@ -8269,6 +8276,11 @@ func (m *ListServiceStatusesResponse_ServiceStatus) MarshalTo(dAtA []byte) (int,
i++
i = encodeVarintControl(dAtA, i, uint64(m.RunningTasks))
}
if m.CompletedTasks != 0 {
dAtA[i] = 0x20
i++
i = encodeVarintControl(dAtA, i, uint64(m.CompletedTasks))
}
return i, nil
}
@ -12102,6 +12114,9 @@ func (m *ListServiceStatusesResponse_ServiceStatus) Size() (n int) {
if m.RunningTasks != 0 {
n += 1 + sovControl(uint64(m.RunningTasks))
}
if m.CompletedTasks != 0 {
n += 1 + sovControl(uint64(m.CompletedTasks))
}
return n
}
@ -13373,6 +13388,7 @@ func (this *ListServiceStatusesResponse_ServiceStatus) String() string {
`ServiceID:` + fmt.Sprintf("%v", this.ServiceID) + `,`,
`DesiredTasks:` + fmt.Sprintf("%v", this.DesiredTasks) + `,`,
`RunningTasks:` + fmt.Sprintf("%v", this.RunningTasks) + `,`,
`CompletedTasks:` + fmt.Sprintf("%v", this.CompletedTasks) + `,`,
`}`,
}, "")
return s
@ -17797,6 +17813,25 @@ func (m *ListServiceStatusesResponse_ServiceStatus) Unmarshal(dAtA []byte) error
break
}
}
case 4:
if wireType != 0 {
return fmt.Errorf("proto: wrong wireType = %d for field CompletedTasks", wireType)
}
m.CompletedTasks = 0
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowControl
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
m.CompletedTasks |= uint64(b&0x7F) << shift
if b < 0x80 {
break
}
}
default:
iNdEx = preIndex
skippy, err := skipControl(dAtA[iNdEx:])

7
vendor/github.com/docker/swarmkit/api/control.proto generated vendored
View file

@ -433,6 +433,13 @@ message ListServiceStatusesResponse {
// request time. This may be larger than desired tasks if, for example, a
// service has been scaled down.
uint64 running_tasks = 3;
// CompletedTasks is the number of tasks in state Completed, if this
// service is in mode ReplicatedJob or GlobalJob. This must be
// cross-referenced with the service type, because the default value of 0
// may mean that a service is not in a Job mode, or it may mean the Job has
// yet to complete any Tasks.
uint64 completed_tasks = 4;
}
repeated ServiceStatus statuses = 1;

525
vendor/github.com/docker/swarmkit/api/objects.pb.go generated vendored
View file

@ -164,6 +164,9 @@ type Service struct {
// UpdateStatus contains the status of an update, if one is in
// progress.
UpdateStatus *UpdateStatus `protobuf:"bytes,5,opt,name=update_status,json=updateStatus,proto3" json:"update_status,omitempty"`
// JobStatus contains the status of a Service that is in one of the Job
// modes. It is absent on Replicated and Global services.
JobStatus *JobStatus `protobuf:"bytes,12,opt,name=job_status,json=jobStatus,proto3" json:"job_status,omitempty"`
// PendingDelete indicates that this service's deletion has been requested.
// Services, as well as all service-level resources, can only be deleted
// after all of the service's containers have properly shut down.
@ -359,6 +362,9 @@ type Task struct {
// If not present, the daemon's default will be used.
LogDriver *Driver `protobuf:"bytes,13,opt,name=log_driver,json=logDriver,proto3" json:"log_driver,omitempty"`
AssignedGenericResources []*GenericResource `protobuf:"bytes,15,rep,name=assigned_generic_resources,json=assignedGenericResources,proto3" json:"assigned_generic_resources,omitempty"`
// JobIteration is the iteration number of the Job-mode Service that this
// task belongs to.
JobIteration *Version `protobuf:"bytes,16,opt,name=job_iteration,json=jobIteration,proto3" json:"job_iteration,omitempty"`
}
func (m *Task) Reset() { *m = Task{} }
@ -767,111 +773,114 @@ func init() {
}
var fileDescriptor_6218a23329ef342d = []byte{
// 1654 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x73, 0x23, 0x47,
0x15, 0xf7, 0xc8, 0xb3, 0xfa, 0x78, 0xfa, 0x60, 0xe9, 0x18, 0x33, 0x2b, 0x8c, 0x64, 0x14, 0x42,
0x6d, 0xa5, 0xb6, 0xe4, 0xb0, 0x04, 0xf0, 0x1a, 0x42, 0x22, 0x59, 0x66, 0xa3, 0x4a, 0x36, 0xeb,
0x6a, 0x27, 0x9b, 0xdc, 0x86, 0xd6, 0x4c, 0x5b, 0x3b, 0x68, 0x34, 0x3d, 0x35, 0xdd, 0x52, 0x10,
0x27, 0xce, 0xcb, 0x85, 0xdb, 0xde, 0x38, 0x00, 0xff, 0x04, 0x17, 0x0e, 0x1c, 0xa8, 0xe5, 0x96,
0x13, 0x95, 0x93, 0x8b, 0xd5, 0xfe, 0x15, 0xdc, 0xa8, 0xee, 0xe9, 0x91, 0xc6, 0xd6, 0xf8, 0x8b,
0xda, 0x72, 0x71, 0x52, 0x7f, 0xfc, 0x7e, 0xaf, 0xdf, 0x7b, 0xdd, 0xef, 0x63, 0x04, 0xf7, 0x86,
0x9e, 0x78, 0x3a, 0x19, 0xb4, 0x1d, 0x36, 0xde, 0x71, 0x99, 0x33, 0xa2, 0xd1, 0x0e, 0xff, 0x92,
0x44, 0xe3, 0x91, 0x27, 0x76, 0x48, 0xe8, 0xed, 0xb0, 0xc1, 0xaf, 0xa9, 0x23, 0x78, 0x3b, 0x8c,
0x98, 0x60, 0x08, 0xc5, 0x90, 0x76, 0x02, 0x69, 0x4f, 0x7f, 0x58, 0x7f, 0xfb, 0x12, 0x09, 0x62,
0x16, 0x52, 0xcd, 0xbf, 0x14, 0xcb, 0x43, 0xea, 0x24, 0xd8, 0xe6, 0x90, 0xb1, 0xa1, 0x4f, 0x77,
0xd4, 0x6c, 0x30, 0x39, 0xde, 0x11, 0xde, 0x98, 0x72, 0x41, 0xc6, 0xa1, 0x06, 0x6c, 0x0c, 0xd9,
0x90, 0xa9, 0xe1, 0x8e, 0x1c, 0xe9, 0xd5, 0x3b, 0x67, 0x69, 0x24, 0x98, 0xe9, 0xad, 0x9f, 0x5e,
0x70, 0xfa, 0x02, 0x1e, 0xfa, 0x93, 0xa1, 0x17, 0xe8, 0x9f, 0x98, 0xd8, 0xfa, 0xab, 0x01, 0xe6,
0x23, 0x2a, 0x08, 0xfa, 0x19, 0x14, 0xa6, 0x34, 0xe2, 0x1e, 0x0b, 0x2c, 0x63, 0xdb, 0xb8, 0x5b,
0xbe, 0xff, 0x9d, 0xf6, 0xaa, 0x47, 0xda, 0x4f, 0x62, 0x48, 0xd7, 0x7c, 0x71, 0xd2, 0x5c, 0xc3,
0x09, 0x03, 0x3d, 0x00, 0x70, 0x22, 0x4a, 0x04, 0x75, 0x6d, 0x22, 0xac, 0x9c, 0xe2, 0xd7, 0xdb,
0xb1, 0xba, 0xed, 0xe4, 0xfc, 0xf6, 0xa7, 0x89, 0x95, 0xb8, 0xa4, 0xd1, 0x1d, 0x21, 0xa9, 0x93,
0xd0, 0x4d, 0xa8, 0xeb, 0x97, 0x53, 0x35, 0xba, 0x23, 0x5a, 0x7f, 0xb9, 0x05, 0xe6, 0x27, 0xcc,
0xa5, 0x68, 0x13, 0x72, 0x9e, 0xab, 0xd4, 0x2e, 0x75, 0xf3, 0xf3, 0x93, 0x66, 0xae, 0xdf, 0xc3,
0x39, 0xcf, 0x45, 0xf7, 0xc1, 0x1c, 0x53, 0x41, 0xb4, 0x42, 0x56, 0x96, 0x41, 0xd2, 0x76, 0x6d,
0x8d, 0xc2, 0xa2, 0x9f, 0x80, 0x29, 0xaf, 0x4a, 0x6b, 0xb2, 0x95, 0xc5, 0x91, 0x67, 0x1e, 0x85,
0xd4, 0x49, 0x78, 0x12, 0x8f, 0x0e, 0xa0, 0xec, 0x52, 0xee, 0x44, 0x5e, 0x28, 0xa4, 0x0f, 0x4d,
0x45, 0x7f, 0xf3, 0x3c, 0x7a, 0x6f, 0x09, 0xc5, 0x69, 0x1e, 0xfa, 0x39, 0xe4, 0xb9, 0x20, 0x62,
0xc2, 0xad, 0x5b, 0x4a, 0x42, 0xe3, 0x5c, 0x05, 0x14, 0x4a, 0xab, 0xa0, 0x39, 0xe8, 0x43, 0xa8,
0x8d, 0x49, 0x40, 0x86, 0x34, 0xb2, 0xb5, 0x94, 0xbc, 0x92, 0xf2, 0xbd, 0x4c, 0xd3, 0x63, 0x64,
0x2c, 0x08, 0x57, 0xc7, 0xe9, 0x29, 0xea, 0x03, 0x10, 0x21, 0x88, 0xf3, 0x74, 0x4c, 0x03, 0x61,
0x15, 0x94, 0x94, 0xb7, 0x32, 0x75, 0xa1, 0xe2, 0x4b, 0x16, 0x8d, 0x3a, 0x0b, 0x70, 0x37, 0x67,
0x19, 0x38, 0x45, 0x46, 0x0f, 0xa1, 0xec, 0xd0, 0x48, 0x78, 0xc7, 0x9e, 0x43, 0x04, 0xb5, 0x8a,
0x4a, 0x56, 0x33, 0x4b, 0xd6, 0xfe, 0x12, 0xa6, 0x0d, 0x4b, 0x33, 0xd1, 0x3b, 0x60, 0x46, 0xcc,
0xa7, 0x56, 0x69, 0xdb, 0xb8, 0x5b, 0x3b, 0xff, 0x6a, 0x30, 0xf3, 0x29, 0x56, 0x48, 0x79, 0xf4,
0x52, 0x11, 0x6e, 0xc1, 0xf6, 0xfa, 0x95, 0xcd, 0xc0, 0x69, 0x26, 0x6a, 0x41, 0xe5, 0xc9, 0x17,
0x1f, 0x77, 0x3e, 0xf9, 0xac, 0x77, 0x78, 0xc8, 0x22, 0x61, 0x95, 0xb7, 0x8d, 0xbb, 0x55, 0x7c,
0x6a, 0x6d, 0x6f, 0xf3, 0xd9, 0xf3, 0x16, 0x82, 0xdb, 0x45, 0xe3, 0xb6, 0xa1, 0xde, 0xa2, 0xf1,
0x8e, 0xf1, 0x85, 0xf1, 0x2b, 0xa3, 0xf5, 0x67, 0x13, 0x0a, 0x47, 0x34, 0x9a, 0x7a, 0xce, 0xeb,
0x7d, 0xa9, 0x0f, 0x4e, 0xbd, 0xd4, 0x4c, 0x87, 0xea, 0x63, 0x57, 0x1e, 0xeb, 0x2f, 0xa0, 0x22,
0x7f, 0xed, 0x24, 0xe2, 0xe1, 0xd2, 0x88, 0xc7, 0x65, 0x49, 0xd0, 0x13, 0xd4, 0x83, 0x6a, 0x18,
0xd1, 0xa9, 0xc7, 0x26, 0xdc, 0x56, 0x3a, 0xe4, 0xaf, 0xa4, 0x03, 0xae, 0x24, 0x2c, 0x39, 0x43,
0x8f, 0xe1, 0x5b, 0xa7, 0xa4, 0x2c, 0xd4, 0x29, 0x5f, 0xae, 0xce, 0x1b, 0x69, 0x49, 0x89, 0x5a,
0xbb, 0x50, 0xa4, 0x81, 0x1b, 0x32, 0x2f, 0x10, 0x3a, 0x00, 0x33, 0x1f, 0xc9, 0x81, 0xc6, 0xe0,
0x05, 0x1a, 0x1d, 0x40, 0x35, 0xce, 0x2b, 0xf6, 0xa9, 0xe8, 0xdb, 0xce, 0xa2, 0x7f, 0xa6, 0x80,
0x3a, 0x6c, 0x2a, 0x93, 0xd4, 0x0c, 0xbd, 0x05, 0xb5, 0x90, 0x06, 0xae, 0x17, 0x0c, 0x6d, 0x97,
0xfa, 0x54, 0x50, 0x15, 0x39, 0x45, 0x5c, 0xd5, 0xab, 0x3d, 0xb5, 0xb8, 0x87, 0x9e, 0x3d, 0x6f,
0xd5, 0xa0, 0x92, 0x7e, 0x29, 0xad, 0x3f, 0xe6, 0xa0, 0x98, 0x28, 0x86, 0xde, 0xd5, 0x57, 0x6b,
0x9c, 0xaf, 0x45, 0x82, 0x55, 0x7e, 0x8d, 0x6f, 0xf5, 0x5d, 0xb8, 0x15, 0xb2, 0x48, 0x70, 0x2b,
0xa7, 0xde, 0x79, 0x66, 0xea, 0x90, 0x2f, 0x75, 0x9f, 0x05, 0xc7, 0xde, 0x10, 0xc7, 0x60, 0xf4,
0x39, 0x94, 0xa7, 0x5e, 0x24, 0x26, 0xc4, 0xb7, 0xbd, 0x90, 0x5b, 0xeb, 0x8a, 0xfb, 0x83, 0x8b,
0x8e, 0x6c, 0x3f, 0x89, 0xf1, 0xfd, 0xc3, 0x6e, 0x6d, 0x7e, 0xd2, 0x84, 0xc5, 0x94, 0x63, 0xd0,
0xa2, 0xfa, 0x21, 0xaf, 0x3f, 0x82, 0xd2, 0x62, 0x07, 0xdd, 0x03, 0x08, 0xe2, 0x10, 0xb3, 0x17,
0x01, 0x50, 0x9d, 0x9f, 0x34, 0x4b, 0x3a, 0xf0, 0xfa, 0x3d, 0x5c, 0xd2, 0x80, 0xbe, 0x8b, 0x10,
0x98, 0xc4, 0x75, 0x23, 0x15, 0x0e, 0x25, 0xac, 0xc6, 0xad, 0xdf, 0x17, 0xc0, 0xfc, 0x94, 0xf0,
0xd1, 0x4d, 0x67, 0x7b, 0x79, 0xe6, 0xa5, 0x01, 0x54, 0xbb, 0x66, 0x00, 0xdd, 0x03, 0xe0, 0x71,
0x5c, 0x48, 0x77, 0x98, 0x4b, 0x77, 0xe8, 0x68, 0x91, 0xee, 0xd0, 0x80, 0xd8, 0x1d, 0xdc, 0x67,
0x42, 0x3d, 0x4a, 0x13, 0xab, 0x31, 0x7a, 0x13, 0x0a, 0x01, 0x73, 0x15, 0x3d, 0xaf, 0xe8, 0x30,
0x3f, 0x69, 0xe6, 0x65, 0xfe, 0xeb, 0xf7, 0x70, 0x5e, 0x6e, 0xf5, 0x5d, 0x95, 0xff, 0x82, 0x80,
0x09, 0x22, 0x6b, 0x0b, 0xd7, 0x69, 0x3c, 0x33, 0x4a, 0x3b, 0x4b, 0x58, 0x92, 0x7a, 0x53, 0x4c,
0xf4, 0x04, 0xde, 0x48, 0xf4, 0x4d, 0x0b, 0x2c, 0x5e, 0x47, 0x20, 0xd2, 0x12, 0x52, 0x3b, 0xa9,
0x72, 0x57, 0x3a, 0xbf, 0xdc, 0xa9, 0x1b, 0xc8, 0x2a, 0x77, 0x5d, 0xa8, 0xba, 0x94, 0x7b, 0x11,
0x75, 0x55, 0xd8, 0x52, 0x95, 0xc7, 0x6a, 0xf7, 0xbf, 0x7b, 0x91, 0x10, 0x8a, 0x2b, 0x9a, 0xa3,
0x66, 0xa8, 0x03, 0x45, 0xfd, 0xee, 0xb8, 0x55, 0xbe, 0x4e, 0x7d, 0x58, 0xd0, 0x4e, 0xa5, 0x9d,
0xca, 0xb5, 0xd2, 0xce, 0x03, 0x00, 0x9f, 0x0d, 0x6d, 0x37, 0xf2, 0xa6, 0x34, 0xb2, 0xaa, 0xba,
0xf9, 0xc9, 0xe0, 0xf6, 0x14, 0x02, 0x97, 0x7c, 0x36, 0x8c, 0x87, 0x88, 0x40, 0x9d, 0x70, 0xee,
0x0d, 0x03, 0xea, 0xda, 0x43, 0x1a, 0xd0, 0xc8, 0x73, 0xec, 0x88, 0x72, 0x36, 0x89, 0x1c, 0xca,
0xad, 0x6f, 0x28, 0x4b, 0x32, 0xdb, 0x8f, 0x87, 0x31, 0x18, 0x6b, 0x2c, 0xb6, 0x12, 0x31, 0x67,
0x36, 0xf8, 0x5e, 0xfd, 0xd9, 0xf3, 0xd6, 0x26, 0x6c, 0xa4, 0xd3, 0xd4, 0xae, 0xf1, 0x81, 0xf1,
0xa1, 0x71, 0x68, 0xb4, 0xfe, 0x9e, 0x83, 0x6f, 0xae, 0xf8, 0x04, 0xfd, 0x18, 0x0a, 0xda, 0x2b,
0x17, 0x35, 0x91, 0x9a, 0x87, 0x13, 0x2c, 0xda, 0x82, 0x92, 0x0c, 0x71, 0xca, 0x39, 0x8d, 0x93,
0x57, 0x09, 0x2f, 0x17, 0x90, 0x05, 0x05, 0xe2, 0x7b, 0x44, 0xee, 0xad, 0xab, 0xbd, 0x64, 0x8a,
0x26, 0xb0, 0x19, 0xbb, 0xce, 0x5e, 0xd6, 0x6a, 0x9b, 0x85, 0x82, 0x5b, 0xa6, 0xb2, 0xff, 0xfd,
0x2b, 0xdd, 0xa4, 0x76, 0xee, 0x72, 0xe1, 0x71, 0x28, 0xf8, 0x41, 0x20, 0xa2, 0x19, 0xde, 0x70,
0x33, 0xb6, 0xea, 0x0f, 0xe1, 0xce, 0xb9, 0x14, 0x74, 0x1b, 0xd6, 0x47, 0x74, 0x16, 0xa7, 0x27,
0x2c, 0x87, 0x68, 0x03, 0x6e, 0x4d, 0x89, 0x3f, 0xa1, 0x3a, 0x9b, 0xc5, 0x93, 0xbd, 0xdc, 0xae,
0xd1, 0xfa, 0x67, 0x0e, 0x0a, 0x5a, 0x9d, 0x9b, 0xee, 0x0c, 0xf4, 0xb1, 0x2b, 0x89, 0xed, 0x3d,
0xa8, 0x68, 0x97, 0xc6, 0x11, 0x65, 0x5e, 0xfa, 0x26, 0xcb, 0x31, 0x3e, 0x8e, 0xa6, 0xf7, 0xc0,
0xf4, 0x42, 0x32, 0xd6, 0xe5, 0x33, 0xf3, 0xe4, 0xfe, 0x61, 0xe7, 0xd1, 0xe3, 0x30, 0x4e, 0x0c,
0xc5, 0xf9, 0x49, 0xd3, 0x94, 0x0b, 0x58, 0xd1, 0x32, 0xea, 0x67, 0xfe, 0xaa, 0xf5, 0xf3, 0x1f,
0x79, 0x28, 0xec, 0xfb, 0x13, 0x2e, 0x68, 0x74, 0xd3, 0xbe, 0xd4, 0xc7, 0xae, 0xf8, 0x72, 0x1f,
0x0a, 0x11, 0x63, 0xc2, 0x76, 0xc8, 0x45, 0x6e, 0xc4, 0x8c, 0x89, 0xfd, 0x4e, 0xb7, 0x26, 0x89,
0x32, 0x85, 0xc7, 0x73, 0x9c, 0x97, 0xd4, 0x7d, 0x82, 0x3e, 0x87, 0xcd, 0xa4, 0x70, 0x0e, 0x18,
0x13, 0x5c, 0x44, 0x24, 0xb4, 0x47, 0x74, 0x26, 0x5b, 0x94, 0xf5, 0xf3, 0x5a, 0xfb, 0x83, 0xc0,
0x89, 0x66, 0xca, 0xc7, 0x1f, 0xd1, 0x19, 0xde, 0xd0, 0x02, 0xba, 0x09, 0xff, 0x23, 0x3a, 0xe3,
0xe8, 0x7d, 0xd8, 0xa2, 0x0b, 0x98, 0x94, 0x68, 0xfb, 0x64, 0x2c, 0x5b, 0x02, 0xdb, 0xf1, 0x99,
0x33, 0x52, 0x9e, 0x37, 0xf1, 0x1d, 0x9a, 0x16, 0xf5, 0x71, 0x8c, 0xd8, 0x97, 0x00, 0xc4, 0xc1,
0x1a, 0xf8, 0xc4, 0x19, 0xf9, 0x1e, 0x97, 0x5f, 0x6f, 0xa9, 0x4e, 0x5d, 0x16, 0x06, 0xa9, 0xdb,
0xee, 0x05, 0xde, 0x6a, 0x77, 0x97, 0xdc, 0x54, 0xdf, 0xaf, 0x03, 0xef, 0xdb, 0x83, 0xec, 0x5d,
0xd4, 0x85, 0xf2, 0x24, 0x90, 0xc7, 0xc7, 0x3e, 0x28, 0x5d, 0xd5, 0x07, 0x10, 0xb3, 0x94, 0xe5,
0x5b, 0x60, 0x1e, 0xcb, 0x56, 0x47, 0x56, 0x8b, 0x62, 0xfc, 0x06, 0x7f, 0xd9, 0x3f, 0x3c, 0xc2,
0x6a, 0x15, 0xb5, 0x01, 0xb9, 0xf4, 0x98, 0x4c, 0x7c, 0xd1, 0x89, 0x53, 0xd0, 0x21, 0x63, 0xbe,
0x2a, 0x0d, 0x25, 0x9c, 0xb1, 0x83, 0x1a, 0x00, 0x7c, 0x32, 0x08, 0xa8, 0x38, 0xf2, 0x7e, 0x4b,
0x55, 0xfe, 0xaf, 0xe2, 0xd4, 0xca, 0xca, 0xa7, 0x43, 0x75, 0xf5, 0xd3, 0xa1, 0x3e, 0x85, 0xad,
0x8b, 0xdc, 0x91, 0x91, 0x54, 0x3e, 0x48, 0x27, 0x95, 0xf2, 0xfd, 0xb7, 0xb3, 0x3c, 0x90, 0x2d,
0x32, 0x95, 0x80, 0x32, 0x03, 0xe9, 0x6f, 0x06, 0xe4, 0x8f, 0xa8, 0x13, 0x51, 0xf1, 0x5a, 0xe3,
0x68, 0xf7, 0x54, 0x1c, 0x35, 0xb2, 0xbf, 0x14, 0xe4, 0xa9, 0x2b, 0x61, 0x54, 0x87, 0xa2, 0x17,
0x08, 0x1a, 0x05, 0xc4, 0x57, 0x71, 0x54, 0xc4, 0x8b, 0x79, 0xa6, 0x01, 0x7f, 0x32, 0x20, 0x1f,
0xb7, 0xb8, 0x37, 0x6d, 0x40, 0x7c, 0xea, 0x59, 0x03, 0x32, 0x95, 0xfc, 0x8f, 0x01, 0xc5, 0xa4,
0xd2, 0xbe, 0x56, 0x35, 0xcf, 0xb4, 0x7c, 0xeb, 0xff, 0x73, 0xcb, 0x87, 0xc0, 0x1c, 0x79, 0x81,
0x6e, 0x4e, 0xb1, 0x1a, 0xa3, 0x36, 0x14, 0x42, 0x32, 0xf3, 0x19, 0x71, 0x75, 0x86, 0xdf, 0x58,
0xf9, 0xa7, 0xa6, 0x13, 0xcc, 0x70, 0x02, 0xda, 0xdb, 0x78, 0xf6, 0xbc, 0x75, 0x1b, 0x6a, 0x69,
0xcb, 0x9f, 0x1a, 0xad, 0x7f, 0x19, 0x50, 0x3a, 0xf8, 0x8d, 0xa0, 0x81, 0x6a, 0x85, 0xff, 0x2f,
0x8d, 0xdf, 0x5e, 0xfd, 0x37, 0xa7, 0x74, 0xea, 0x8f, 0x9a, 0xac, 0x4b, 0xed, 0x7e, 0xff, 0xc5,
0xcb, 0xc6, 0xda, 0xd7, 0x2f, 0x1b, 0x6b, 0xbf, 0x9b, 0x37, 0x8c, 0x17, 0xf3, 0x86, 0xf1, 0xd5,
0xbc, 0x61, 0xfc, 0x7b, 0xde, 0x30, 0xfe, 0xf0, 0xaa, 0xb1, 0xf6, 0xd5, 0xab, 0xc6, 0xda, 0xd7,
0xaf, 0x1a, 0x6b, 0x83, 0xbc, 0xf2, 0xd5, 0x8f, 0xfe, 0x1b, 0x00, 0x00, 0xff, 0xff, 0x53, 0x14,
0x4d, 0x41, 0xa0, 0x14, 0x00, 0x00,
// 1700 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xcc, 0x58, 0xcd, 0x73, 0x1b, 0x49,
0x15, 0xf7, 0xc8, 0x13, 0x49, 0xf3, 0xf4, 0x81, 0xe9, 0x35, 0x66, 0x62, 0x8c, 0x6c, 0xb4, 0x2c,
0x95, 0xda, 0x4a, 0xc9, 0x4b, 0x58, 0xc0, 0x31, 0xbb, 0x6c, 0x24, 0xdb, 0x64, 0xc5, 0x6e, 0x36,
0xae, 0xf6, 0x6e, 0x76, 0x6f, 0x43, 0x6b, 0xa6, 0xad, 0x4c, 0x34, 0x9a, 0x9e, 0x9a, 0x6e, 0x69,
0x11, 0x27, 0xce, 0x39, 0x71, 0xcb, 0x8d, 0x03, 0xc5, 0x3f, 0xc1, 0x85, 0x03, 0x07, 0x2a, 0x1c,
0xa8, 0xda, 0x13, 0x95, 0x93, 0x8b, 0x28, 0x7f, 0x05, 0x37, 0xaa, 0x7b, 0x7a, 0xa4, 0x71, 0x34,
0xb6, 0x1c, 0x2a, 0x95, 0xe2, 0xa4, 0xfe, 0xf8, 0xfd, 0x5e, 0xbf, 0xf7, 0xe6, 0x7d, 0x74, 0x0b,
0x6e, 0xf6, 0x7d, 0xf1, 0x70, 0xd4, 0x6b, 0xb9, 0x6c, 0xb8, 0xeb, 0x31, 0x77, 0x40, 0xe3, 0x5d,
0xfe, 0x35, 0x89, 0x87, 0x03, 0x5f, 0xec, 0x92, 0xc8, 0xdf, 0x65, 0xbd, 0x47, 0xd4, 0x15, 0xbc,
0x15, 0xc5, 0x4c, 0x30, 0x84, 0x12, 0x48, 0x2b, 0x85, 0xb4, 0xc6, 0x3f, 0xde, 0x7c, 0x77, 0x89,
0x04, 0x31, 0x89, 0xa8, 0xe6, 0x2f, 0xc5, 0xf2, 0x88, 0xba, 0x29, 0x76, 0xbb, 0xcf, 0x58, 0x3f,
0xa0, 0xbb, 0x6a, 0xd6, 0x1b, 0x9d, 0xee, 0x0a, 0x7f, 0x48, 0xb9, 0x20, 0xc3, 0x48, 0x03, 0xd6,
0xfb, 0xac, 0xcf, 0xd4, 0x70, 0x57, 0x8e, 0xf4, 0xea, 0xf5, 0x97, 0x69, 0x24, 0x9c, 0xe8, 0xad,
0x9f, 0x5f, 0x72, 0xfa, 0x0c, 0x1e, 0x05, 0xa3, 0xbe, 0x1f, 0xea, 0x9f, 0x84, 0xd8, 0xfc, 0x8b,
0x01, 0xe6, 0x3d, 0x2a, 0x08, 0xfa, 0x05, 0x94, 0xc6, 0x34, 0xe6, 0x3e, 0x0b, 0x6d, 0x63, 0xc7,
0xb8, 0x51, 0xb9, 0xf5, 0xbd, 0xd6, 0xa2, 0x47, 0x5a, 0x0f, 0x12, 0x48, 0xc7, 0x7c, 0x7a, 0xb6,
0xbd, 0x82, 0x53, 0x06, 0xba, 0x0d, 0xe0, 0xc6, 0x94, 0x08, 0xea, 0x39, 0x44, 0xd8, 0x05, 0xc5,
0xdf, 0x6c, 0x25, 0xea, 0xb6, 0xd2, 0xf3, 0x5b, 0x9f, 0xa7, 0x56, 0x62, 0x4b, 0xa3, 0xdb, 0x42,
0x52, 0x47, 0x91, 0x97, 0x52, 0x57, 0x97, 0x53, 0x35, 0xba, 0x2d, 0x9a, 0x7f, 0xbe, 0x06, 0xe6,
0x67, 0xcc, 0xa3, 0x68, 0x03, 0x0a, 0xbe, 0xa7, 0xd4, 0xb6, 0x3a, 0xc5, 0xe9, 0xd9, 0x76, 0xa1,
0x7b, 0x88, 0x0b, 0xbe, 0x87, 0x6e, 0x81, 0x39, 0xa4, 0x82, 0x68, 0x85, 0xec, 0x3c, 0x83, 0xa4,
0xed, 0xda, 0x1a, 0x85, 0x45, 0x3f, 0x03, 0x53, 0x7e, 0x2a, 0xad, 0xc9, 0x56, 0x1e, 0x47, 0x9e,
0x79, 0x12, 0x51, 0x37, 0xe5, 0x49, 0x3c, 0x3a, 0x82, 0x8a, 0x47, 0xb9, 0x1b, 0xfb, 0x91, 0x90,
0x3e, 0x34, 0x15, 0xfd, 0xed, 0x8b, 0xe8, 0x87, 0x73, 0x28, 0xce, 0xf2, 0xd0, 0x07, 0x50, 0xe4,
0x82, 0x88, 0x11, 0xb7, 0xaf, 0x29, 0x09, 0x8d, 0x0b, 0x15, 0x50, 0x28, 0xad, 0x82, 0xe6, 0xa0,
0x8f, 0xa1, 0x3e, 0x24, 0x21, 0xe9, 0xd3, 0xd8, 0xd1, 0x52, 0x8a, 0x4a, 0xca, 0x0f, 0x72, 0x4d,
0x4f, 0x90, 0x89, 0x20, 0x5c, 0x1b, 0x66, 0xa7, 0xa8, 0x0b, 0x40, 0x84, 0x20, 0xee, 0xc3, 0x21,
0x0d, 0x85, 0x5d, 0x52, 0x52, 0xde, 0xc9, 0xd5, 0x85, 0x8a, 0xaf, 0x59, 0x3c, 0x68, 0xcf, 0xc0,
0x9d, 0x82, 0x6d, 0xe0, 0x0c, 0x19, 0xdd, 0x85, 0x8a, 0x4b, 0x63, 0xe1, 0x9f, 0xfa, 0x2e, 0x11,
0xd4, 0x2e, 0x2b, 0x59, 0xdb, 0x79, 0xb2, 0x0e, 0xe6, 0x30, 0x6d, 0x58, 0x96, 0x89, 0xde, 0x03,
0x33, 0x66, 0x01, 0xb5, 0xad, 0x1d, 0xe3, 0x46, 0xfd, 0xe2, 0x4f, 0x83, 0x59, 0x40, 0xb1, 0x42,
0xca, 0xa3, 0xe7, 0x8a, 0x70, 0x1b, 0x76, 0x56, 0xaf, 0x6c, 0x06, 0xce, 0x32, 0x51, 0x13, 0xaa,
0x0f, 0xbe, 0xfa, 0xb4, 0xfd, 0xd9, 0x17, 0x87, 0xc7, 0xc7, 0x2c, 0x16, 0x76, 0x65, 0xc7, 0xb8,
0x51, 0xc3, 0xe7, 0xd6, 0xf6, 0x37, 0x1e, 0x3f, 0x69, 0x22, 0x58, 0x2b, 0x1b, 0x6b, 0x86, 0x8a,
0x45, 0xe3, 0x3d, 0xe3, 0x2b, 0xe3, 0x37, 0x46, 0xf3, 0xb9, 0x09, 0xa5, 0x13, 0x1a, 0x8f, 0x7d,
0xf7, 0xf5, 0x46, 0xea, 0xed, 0x73, 0x91, 0x9a, 0xeb, 0x50, 0x7d, 0xec, 0x42, 0xb0, 0xfe, 0x12,
0xaa, 0xf2, 0xd7, 0x49, 0x33, 0x1e, 0x96, 0x66, 0x3c, 0xae, 0x48, 0x82, 0x9e, 0xa0, 0x43, 0xa8,
0x45, 0x31, 0x1d, 0xfb, 0x6c, 0xc4, 0x1d, 0xa5, 0x43, 0xf1, 0x4a, 0x3a, 0xe0, 0x6a, 0xca, 0x92,
0x33, 0x74, 0x1f, 0xbe, 0x73, 0x4e, 0xca, 0x4c, 0x9d, 0xca, 0x72, 0x75, 0xde, 0xca, 0x4a, 0x4a,
0xd5, 0xda, 0x83, 0x32, 0x0d, 0xbd, 0x88, 0xf9, 0xa1, 0xd0, 0x09, 0x98, 0x1b, 0x24, 0x47, 0x1a,
0x83, 0x67, 0x68, 0x74, 0x04, 0xb5, 0xa4, 0xae, 0x38, 0xe7, 0xb2, 0x6f, 0x27, 0x8f, 0xfe, 0x85,
0x02, 0xea, 0xb4, 0xa9, 0x8e, 0x32, 0x33, 0xf4, 0x01, 0xc0, 0x23, 0xd6, 0x4b, 0x65, 0x54, 0x95,
0x8c, 0xef, 0xe7, 0xc9, 0xf8, 0x35, 0xeb, 0x69, 0x01, 0xd6, 0xa3, 0x74, 0x88, 0xde, 0x81, 0x7a,
0x44, 0x43, 0xcf, 0x0f, 0xfb, 0x8e, 0x47, 0x03, 0x2a, 0xa8, 0xca, 0xbb, 0x32, 0xae, 0xe9, 0xd5,
0x43, 0xb5, 0xb8, 0x8f, 0x1e, 0x3f, 0x69, 0xd6, 0xa1, 0x9a, 0x8d, 0xb3, 0xe6, 0x1f, 0x0b, 0x50,
0x4e, 0xcd, 0x42, 0xef, 0xeb, 0xc0, 0x30, 0x2e, 0xb6, 0x21, 0xc5, 0xaa, 0xaf, 0x92, 0xc4, 0xc4,
0xfb, 0x70, 0x2d, 0x62, 0xb1, 0xe0, 0x76, 0x41, 0x65, 0x49, 0x6e, 0xe1, 0x91, 0x71, 0x7e, 0xc0,
0xc2, 0x53, 0xbf, 0x8f, 0x13, 0x30, 0xfa, 0x12, 0x2a, 0x63, 0x3f, 0x16, 0x23, 0x12, 0x38, 0x7e,
0xc4, 0xed, 0x55, 0xc5, 0xfd, 0xd1, 0x65, 0x47, 0xb6, 0x1e, 0x24, 0xf8, 0xee, 0x71, 0xa7, 0x3e,
0x3d, 0xdb, 0x86, 0xd9, 0x94, 0x63, 0xd0, 0xa2, 0xba, 0x11, 0xdf, 0xbc, 0x07, 0xd6, 0x6c, 0x07,
0xdd, 0x04, 0x08, 0x93, 0x04, 0x75, 0x66, 0xe9, 0x53, 0x9b, 0x9e, 0x6d, 0x5b, 0x3a, 0x6d, 0xbb,
0x87, 0xd8, 0xd2, 0x80, 0xae, 0x87, 0x10, 0x98, 0xc4, 0xf3, 0x62, 0x95, 0x4c, 0x16, 0x56, 0xe3,
0xe6, 0x3f, 0x4b, 0x60, 0x7e, 0x4e, 0xf8, 0xe0, 0x4d, 0xf7, 0x0a, 0x79, 0xe6, 0xd2, 0xf4, 0xab,
0xbf, 0x62, 0xfa, 0xdd, 0x04, 0xe0, 0x49, 0x56, 0x49, 0x77, 0x98, 0x73, 0x77, 0xe8, 0x5c, 0x93,
0xee, 0xd0, 0x80, 0xc4, 0x1d, 0x3c, 0x60, 0x42, 0x85, 0xb4, 0x89, 0xd5, 0x18, 0xbd, 0x0d, 0xa5,
0x90, 0x79, 0x8a, 0x5e, 0x54, 0x74, 0x98, 0x9e, 0x6d, 0x17, 0x65, 0xf5, 0xec, 0x1e, 0xe2, 0xa2,
0xdc, 0xea, 0x7a, 0xaa, 0x7a, 0x86, 0x21, 0x13, 0x44, 0x76, 0x26, 0xae, 0x9b, 0x40, 0x6e, 0x8e,
0xb7, 0xe7, 0xb0, 0xb4, 0x70, 0x67, 0x98, 0xe8, 0x01, 0xbc, 0x95, 0xea, 0x9b, 0x15, 0x58, 0x7e,
0x15, 0x81, 0x48, 0x4b, 0xc8, 0xec, 0x64, 0x9a, 0xa5, 0x75, 0x71, 0xb3, 0x54, 0x5f, 0x20, 0xaf,
0x59, 0x76, 0xa0, 0xe6, 0x51, 0xee, 0xc7, 0xd4, 0x53, 0x09, 0x4b, 0x55, 0x15, 0xac, 0xe7, 0xe7,
0x6b, 0x2a, 0x84, 0xe2, 0xaa, 0xe6, 0xa8, 0x19, 0x6a, 0x43, 0x59, 0xc7, 0x1d, 0xb7, 0x2b, 0xaf,
0xd2, 0x5d, 0x66, 0xb4, 0x73, 0x45, 0xab, 0xfa, 0x4a, 0x45, 0xeb, 0x36, 0x40, 0xc0, 0xfa, 0x8e,
0x17, 0xfb, 0x63, 0x1a, 0xdb, 0x35, 0x7d, 0x75, 0xca, 0xe1, 0x1e, 0x2a, 0x04, 0xb6, 0x02, 0xd6,
0x4f, 0x86, 0x88, 0xc0, 0x26, 0xe1, 0xdc, 0xef, 0x87, 0xd4, 0x73, 0xfa, 0x34, 0xa4, 0xb1, 0xef,
0x3a, 0x31, 0xe5, 0x6c, 0x14, 0xbb, 0x94, 0xdb, 0xdf, 0x52, 0x96, 0xe4, 0x5e, 0x5e, 0xee, 0x26,
0x60, 0xac, 0xb1, 0xd8, 0x4e, 0xc5, 0xbc, 0xb4, 0xc1, 0xd1, 0x1d, 0xa8, 0xc9, 0x5a, 0xe8, 0x0b,
0x1a, 0xab, 0xcf, 0x65, 0xaf, 0x2d, 0x8f, 0xf2, 0xea, 0x23, 0xd6, 0xeb, 0xa6, 0x84, 0xfd, 0xcd,
0xc7, 0x4f, 0x9a, 0x1b, 0xb0, 0x9e, 0x2d, 0x74, 0x7b, 0xc6, 0x1d, 0xe3, 0x63, 0xe3, 0xd8, 0x68,
0xfe, 0xad, 0x00, 0xdf, 0x5e, 0xf0, 0x2a, 0xfa, 0x29, 0x94, 0xb4, 0x5f, 0x2f, 0xbb, 0xc4, 0x6a,
0x1e, 0x4e, 0xb1, 0x68, 0x0b, 0x2c, 0x59, 0x24, 0x28, 0xe7, 0x34, 0x29, 0x7f, 0x16, 0x9e, 0x2f,
0x20, 0x1b, 0x4a, 0x24, 0xf0, 0x89, 0xdc, 0x5b, 0x55, 0x7b, 0xe9, 0x14, 0x8d, 0x60, 0x23, 0x71,
0xbe, 0x33, 0xbf, 0x2b, 0x38, 0x2c, 0x12, 0xdc, 0x36, 0x95, 0x07, 0x3f, 0xba, 0x52, 0x2c, 0xe8,
0xcf, 0x33, 0x5f, 0xb8, 0x1f, 0x09, 0x7e, 0x14, 0x8a, 0x78, 0x82, 0xd7, 0xbd, 0x9c, 0xad, 0xcd,
0xbb, 0x70, 0xfd, 0x42, 0x0a, 0x5a, 0x83, 0xd5, 0x01, 0x9d, 0x24, 0x05, 0x0e, 0xcb, 0x21, 0x5a,
0x87, 0x6b, 0x63, 0x12, 0x8c, 0xa8, 0xae, 0x87, 0xc9, 0x64, 0xbf, 0xb0, 0x67, 0x34, 0xff, 0x51,
0x80, 0x92, 0x56, 0xe7, 0x4d, 0xdf, 0x4c, 0xf4, 0xb1, 0x0b, 0xa5, 0xf1, 0x43, 0xa8, 0x6a, 0x97,
0x26, 0x39, 0x69, 0x2e, 0x8d, 0xea, 0x4a, 0x82, 0x4f, 0xf2, 0xf1, 0x43, 0x30, 0xfd, 0x88, 0x0c,
0x75, 0xfb, 0xce, 0x3d, 0xb9, 0x7b, 0xdc, 0xbe, 0x77, 0x3f, 0x4a, 0x4a, 0x4b, 0x79, 0x7a, 0xb6,
0x6d, 0xca, 0x05, 0xac, 0x68, 0x39, 0x1d, 0xb8, 0x78, 0xd5, 0x0e, 0xfc, 0xf7, 0x22, 0x94, 0x0e,
0x82, 0x11, 0x17, 0x34, 0x7e, 0xd3, 0xbe, 0xd4, 0xc7, 0x2e, 0xf8, 0xf2, 0x00, 0x4a, 0x31, 0x63,
0xc2, 0x71, 0xc9, 0x65, 0x6e, 0xc4, 0x8c, 0x89, 0x83, 0x76, 0xa7, 0x2e, 0x89, 0xb2, 0x09, 0x24,
0x73, 0x5c, 0x94, 0xd4, 0x03, 0x82, 0xbe, 0x84, 0x8d, 0xb4, 0xf5, 0xf6, 0x18, 0x13, 0x5c, 0xc4,
0x24, 0x72, 0x06, 0x74, 0x22, 0xaf, 0x48, 0xab, 0x17, 0x3d, 0x2d, 0x8e, 0x42, 0x37, 0x9e, 0x28,
0x1f, 0x7f, 0x42, 0x27, 0x78, 0x5d, 0x0b, 0xe8, 0xa4, 0xfc, 0x4f, 0xe8, 0x84, 0xa3, 0x8f, 0x60,
0x8b, 0xce, 0x60, 0x52, 0xa2, 0x13, 0x90, 0xa1, 0xbc, 0x54, 0x38, 0x6e, 0xc0, 0xdc, 0x81, 0xf2,
0xbc, 0x89, 0xaf, 0xd3, 0xac, 0xa8, 0x4f, 0x13, 0xc4, 0x81, 0x04, 0x20, 0x0e, 0x76, 0x2f, 0x20,
0xee, 0x20, 0xf0, 0xb9, 0x7c, 0x3d, 0x66, 0x5e, 0x0a, 0xb2, 0xb5, 0x48, 0xdd, 0xf6, 0x2e, 0xf1,
0x56, 0xab, 0x33, 0xe7, 0x66, 0xde, 0x1d, 0x3a, 0xf1, 0xbe, 0xdb, 0xcb, 0xdf, 0x45, 0x1d, 0xa8,
0x8c, 0x42, 0x79, 0x7c, 0xe2, 0x03, 0xeb, 0xaa, 0x3e, 0x80, 0x84, 0xa5, 0x2c, 0xdf, 0x02, 0xf3,
0x54, 0x5e, 0x96, 0x64, 0xbf, 0x29, 0x27, 0x31, 0xf8, 0xab, 0xee, 0xf1, 0x09, 0x56, 0xab, 0xa8,
0x05, 0xc8, 0xa3, 0xa7, 0x64, 0x14, 0x88, 0x76, 0x52, 0x82, 0x8e, 0x19, 0x0b, 0x54, 0x73, 0xb1,
0x70, 0xce, 0x0e, 0x6a, 0x00, 0xf0, 0x51, 0x2f, 0xa4, 0xe2, 0xc4, 0xff, 0x1d, 0x55, 0x1d, 0xa4,
0x86, 0x33, 0x2b, 0x0b, 0x4f, 0x97, 0xda, 0xe2, 0xd3, 0x65, 0x73, 0x0c, 0x5b, 0x97, 0xb9, 0x23,
0xa7, 0xa8, 0xdc, 0xc9, 0x16, 0x95, 0xca, 0xad, 0x77, 0xf3, 0x3c, 0x90, 0x2f, 0x32, 0x53, 0x80,
0x72, 0x13, 0xe9, 0xaf, 0x06, 0x14, 0x4f, 0xa8, 0x1b, 0x53, 0xf1, 0x5a, 0xf3, 0x68, 0xef, 0x5c,
0x1e, 0x35, 0xf2, 0x5f, 0x2a, 0xf2, 0xd4, 0x85, 0x34, 0xda, 0x84, 0xb2, 0x1f, 0x0a, 0x1a, 0x87,
0x24, 0x50, 0x79, 0x54, 0xc6, 0xb3, 0x79, 0xae, 0x01, 0x7f, 0x32, 0xa0, 0x98, 0x5c, 0x92, 0xdf,
0xb4, 0x01, 0xc9, 0xa9, 0x2f, 0x1b, 0x90, 0xab, 0xe4, 0x7f, 0x0c, 0x28, 0xa7, 0xbd, 0xfa, 0xb5,
0xaa, 0xf9, 0xd2, 0xa5, 0x71, 0xf5, 0x7f, 0xbe, 0x34, 0x22, 0x30, 0x07, 0x7e, 0xa8, 0xaf, 0xb7,
0x58, 0x8d, 0x51, 0x0b, 0x4a, 0x11, 0x99, 0x04, 0x8c, 0x78, 0xba, 0xc2, 0xaf, 0x2f, 0xfc, 0x53,
0xd4, 0x0e, 0x27, 0x38, 0x05, 0xed, 0xaf, 0x3f, 0x7e, 0xd2, 0x5c, 0x83, 0x7a, 0xd6, 0xf2, 0x87,
0x46, 0xf3, 0x5f, 0x06, 0x58, 0x47, 0xbf, 0x15, 0x34, 0x54, 0x97, 0xe9, 0xff, 0x4b, 0xe3, 0x77,
0x16, 0xff, 0x4d, 0xb2, 0xce, 0xfd, 0x51, 0x94, 0xf7, 0x51, 0x3b, 0x3f, 0x7c, 0xfa, 0xbc, 0xb1,
0xf2, 0xec, 0x79, 0x63, 0xe5, 0xf7, 0xd3, 0x86, 0xf1, 0x74, 0xda, 0x30, 0xbe, 0x99, 0x36, 0x8c,
0x7f, 0x4f, 0x1b, 0xc6, 0x1f, 0x5e, 0x34, 0x56, 0xbe, 0x79, 0xd1, 0x58, 0x79, 0xf6, 0xa2, 0xb1,
0xd2, 0x2b, 0x2a, 0x5f, 0xfd, 0xe4, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x9e, 0xda, 0xee, 0xd3,
0x20, 0x15, 0x00, 0x00,
}
func (m *Meta) Copy() *Meta {
@ -972,6 +981,10 @@ func (m *Service) CopyFrom(src interface{}) {
m.UpdateStatus = &UpdateStatus{}
github_com_docker_swarmkit_api_deepcopy.Copy(m.UpdateStatus, o.UpdateStatus)
}
if o.JobStatus != nil {
m.JobStatus = &JobStatus{}
github_com_docker_swarmkit_api_deepcopy.Copy(m.JobStatus, o.JobStatus)
}
}
func (m *Endpoint) Copy() *Endpoint {
@ -1070,6 +1083,10 @@ func (m *Task) CopyFrom(src interface{}) {
}
}
if o.JobIteration != nil {
m.JobIteration = &Version{}
github_com_docker_swarmkit_api_deepcopy.Copy(m.JobIteration, o.JobIteration)
}
}
func (m *NetworkAttachment) Copy() *NetworkAttachment {
@ -1503,6 +1520,16 @@ func (m *Service) MarshalTo(dAtA []byte) (int, error) {
}
i += n17
}
if m.JobStatus != nil {
dAtA[i] = 0x62
i++
i = encodeVarintObjects(dAtA, i, uint64(m.JobStatus.Size()))
n18, err := m.JobStatus.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n18
}
return i, nil
}
@ -1525,11 +1552,11 @@ func (m *Endpoint) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Spec.Size()))
n18, err := m.Spec.MarshalTo(dAtA[i:])
n19, err := m.Spec.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n18
i += n19
}
if len(m.Ports) > 0 {
for _, msg := range m.Ports {
@ -1612,19 +1639,19 @@ func (m *Task) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Meta.Size()))
n19, err := m.Meta.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n19
dAtA[i] = 0x1a
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Spec.Size()))
n20, err := m.Spec.MarshalTo(dAtA[i:])
n20, err := m.Meta.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n20
dAtA[i] = 0x1a
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Spec.Size()))
n21, err := m.Spec.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n21
if len(m.ServiceID) > 0 {
dAtA[i] = 0x22
i++
@ -1645,27 +1672,27 @@ func (m *Task) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x3a
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Annotations.Size()))
n21, err := m.Annotations.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n21
dAtA[i] = 0x42
i++
i = encodeVarintObjects(dAtA, i, uint64(m.ServiceAnnotations.Size()))
n22, err := m.ServiceAnnotations.MarshalTo(dAtA[i:])
n22, err := m.Annotations.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n22
dAtA[i] = 0x4a
dAtA[i] = 0x42
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Status.Size()))
n23, err := m.Status.MarshalTo(dAtA[i:])
i = encodeVarintObjects(dAtA, i, uint64(m.ServiceAnnotations.Size()))
n23, err := m.ServiceAnnotations.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n23
dAtA[i] = 0x4a
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Status.Size()))
n24, err := m.Status.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n24
if m.DesiredState != 0 {
dAtA[i] = 0x50
i++
@ -1687,32 +1714,32 @@ func (m *Task) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x62
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Endpoint.Size()))
n24, err := m.Endpoint.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n24
}
if m.LogDriver != nil {
dAtA[i] = 0x6a
i++
i = encodeVarintObjects(dAtA, i, uint64(m.LogDriver.Size()))
n25, err := m.LogDriver.MarshalTo(dAtA[i:])
n25, err := m.Endpoint.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n25
}
if m.SpecVersion != nil {
dAtA[i] = 0x72
if m.LogDriver != nil {
dAtA[i] = 0x6a
i++
i = encodeVarintObjects(dAtA, i, uint64(m.SpecVersion.Size()))
n26, err := m.SpecVersion.MarshalTo(dAtA[i:])
i = encodeVarintObjects(dAtA, i, uint64(m.LogDriver.Size()))
n26, err := m.LogDriver.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n26
}
if m.SpecVersion != nil {
dAtA[i] = 0x72
i++
i = encodeVarintObjects(dAtA, i, uint64(m.SpecVersion.Size()))
n27, err := m.SpecVersion.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n27
}
if len(m.AssignedGenericResources) > 0 {
for _, msg := range m.AssignedGenericResources {
dAtA[i] = 0x7a
@ -1725,6 +1752,18 @@ func (m *Task) MarshalTo(dAtA []byte) (int, error) {
i += n
}
}
if m.JobIteration != nil {
dAtA[i] = 0x82
i++
dAtA[i] = 0x1
i++
i = encodeVarintObjects(dAtA, i, uint64(m.JobIteration.Size()))
n28, err := m.JobIteration.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n28
}
return i, nil
}
@ -1747,11 +1786,11 @@ func (m *NetworkAttachment) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0xa
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Network.Size()))
n27, err := m.Network.MarshalTo(dAtA[i:])
n29, err := m.Network.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n27
i += n29
}
if len(m.Addresses) > 0 {
for _, s := range m.Addresses {
@ -1827,38 +1866,38 @@ func (m *Network) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Meta.Size()))
n28, err := m.Meta.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n28
dAtA[i] = 0x1a
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Spec.Size()))
n29, err := m.Spec.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n29
if m.DriverState != nil {
dAtA[i] = 0x22
i++
i = encodeVarintObjects(dAtA, i, uint64(m.DriverState.Size()))
n30, err := m.DriverState.MarshalTo(dAtA[i:])
n30, err := m.Meta.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n30
dAtA[i] = 0x1a
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Spec.Size()))
n31, err := m.Spec.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n31
if m.DriverState != nil {
dAtA[i] = 0x22
i++
i = encodeVarintObjects(dAtA, i, uint64(m.DriverState.Size()))
n32, err := m.DriverState.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n32
}
if m.IPAM != nil {
dAtA[i] = 0x2a
i++
i = encodeVarintObjects(dAtA, i, uint64(m.IPAM.Size()))
n31, err := m.IPAM.MarshalTo(dAtA[i:])
n33, err := m.IPAM.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n31
i += n33
}
if m.PendingDelete {
dAtA[i] = 0x30
@ -1897,27 +1936,27 @@ func (m *Cluster) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Meta.Size()))
n32, err := m.Meta.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n32
dAtA[i] = 0x1a
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Spec.Size()))
n33, err := m.Spec.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n33
dAtA[i] = 0x22
i++
i = encodeVarintObjects(dAtA, i, uint64(m.RootCA.Size()))
n34, err := m.RootCA.MarshalTo(dAtA[i:])
n34, err := m.Meta.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n34
dAtA[i] = 0x1a
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Spec.Size()))
n35, err := m.Spec.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n35
dAtA[i] = 0x22
i++
i = encodeVarintObjects(dAtA, i, uint64(m.RootCA.Size()))
n36, err := m.RootCA.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n36
if len(m.NetworkBootstrapKeys) > 0 {
for _, msg := range m.NetworkBootstrapKeys {
dAtA[i] = 0x2a
@ -1955,11 +1994,11 @@ func (m *Cluster) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12
i++
i = encodeVarintObjects(dAtA, i, uint64(v.Size()))
n35, err := v.MarshalTo(dAtA[i:])
n37, err := v.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n35
i += n37
}
}
}
@ -2037,19 +2076,19 @@ func (m *Secret) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Meta.Size()))
n36, err := m.Meta.MarshalTo(dAtA[i:])
n38, err := m.Meta.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n36
i += n38
dAtA[i] = 0x1a
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Spec.Size()))
n37, err := m.Spec.MarshalTo(dAtA[i:])
n39, err := m.Spec.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n37
i += n39
if m.Internal {
dAtA[i] = 0x20
i++
@ -2087,19 +2126,19 @@ func (m *Config) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Meta.Size()))
n38, err := m.Meta.MarshalTo(dAtA[i:])
n40, err := m.Meta.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n38
i += n40
dAtA[i] = 0x1a
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Spec.Size()))
n39, err := m.Spec.MarshalTo(dAtA[i:])
n41, err := m.Spec.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n39
i += n41
return i, nil
}
@ -2127,19 +2166,19 @@ func (m *Resource) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Meta.Size()))
n40, err := m.Meta.MarshalTo(dAtA[i:])
n42, err := m.Meta.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n40
i += n42
dAtA[i] = 0x1a
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Annotations.Size()))
n41, err := m.Annotations.MarshalTo(dAtA[i:])
n43, err := m.Annotations.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n41
i += n43
if len(m.Kind) > 0 {
dAtA[i] = 0x22
i++
@ -2150,11 +2189,11 @@ func (m *Resource) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x2a
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Payload.Size()))
n42, err := m.Payload.MarshalTo(dAtA[i:])
n44, err := m.Payload.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n42
i += n44
}
return i, nil
}
@ -2183,19 +2222,19 @@ func (m *Extension) MarshalTo(dAtA []byte) (int, error) {
dAtA[i] = 0x12
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Meta.Size()))
n43, err := m.Meta.MarshalTo(dAtA[i:])
n45, err := m.Meta.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n43
i += n45
dAtA[i] = 0x1a
i++
i = encodeVarintObjects(dAtA, i, uint64(m.Annotations.Size()))
n44, err := m.Annotations.MarshalTo(dAtA[i:])
n46, err := m.Annotations.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n44
i += n46
if len(m.Description) > 0 {
dAtA[i] = 0x22
i++
@ -2315,6 +2354,10 @@ func (m *Service) Size() (n int) {
l = m.PreviousSpecVersion.Size()
n += 1 + l + sovObjects(uint64(l))
}
if m.JobStatus != nil {
l = m.JobStatus.Size()
n += 1 + l + sovObjects(uint64(l))
}
return n
}
@ -2418,6 +2461,10 @@ func (m *Task) Size() (n int) {
n += 1 + l + sovObjects(uint64(l))
}
}
if m.JobIteration != nil {
l = m.JobIteration.Size()
n += 2 + l + sovObjects(uint64(l))
}
return n
}
@ -5323,6 +5370,7 @@ func (this *Service) String() string {
`PendingDelete:` + fmt.Sprintf("%v", this.PendingDelete) + `,`,
`SpecVersion:` + strings.Replace(fmt.Sprintf("%v", this.SpecVersion), "Version", "Version", 1) + `,`,
`PreviousSpecVersion:` + strings.Replace(fmt.Sprintf("%v", this.PreviousSpecVersion), "Version", "Version", 1) + `,`,
`JobStatus:` + strings.Replace(fmt.Sprintf("%v", this.JobStatus), "JobStatus", "JobStatus", 1) + `,`,
`}`,
}, "")
return s
@ -5370,6 +5418,7 @@ func (this *Task) String() string {
`LogDriver:` + strings.Replace(fmt.Sprintf("%v", this.LogDriver), "Driver", "Driver", 1) + `,`,
`SpecVersion:` + strings.Replace(fmt.Sprintf("%v", this.SpecVersion), "Version", "Version", 1) + `,`,
`AssignedGenericResources:` + strings.Replace(fmt.Sprintf("%v", this.AssignedGenericResources), "GenericResource", "GenericResource", 1) + `,`,
`JobIteration:` + strings.Replace(fmt.Sprintf("%v", this.JobIteration), "Version", "Version", 1) + `,`,
`}`,
}, "")
return s
@ -6385,6 +6434,42 @@ func (m *Service) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 12:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field JobStatus", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowObjects
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthObjects
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthObjects
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.JobStatus == nil {
m.JobStatus = &JobStatus{}
}
if err := m.JobStatus.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipObjects(dAtA[iNdEx:])
@ -7187,6 +7272,42 @@ func (m *Task) Unmarshal(dAtA []byte) error {
return err
}
iNdEx = postIndex
case 16:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field JobIteration", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowObjects
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthObjects
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthObjects
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.JobIteration == nil {
m.JobIteration = &Version{}
}
if err := m.JobIteration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipObjects(dAtA[iNdEx:])

8
vendor/github.com/docker/swarmkit/api/objects.proto generated vendored
View file

@ -127,6 +127,10 @@ message Service {
// progress.
UpdateStatus update_status = 5;
// JobStatus contains the status of a Service that is in one of the Job
// modes. It is absent on Replicated and Global services.
JobStatus job_status = 12;
// PendingDelete indicates that this service's deletion has been requested.
// Services, as well as all service-level resources, can only be deleted
// after all of the service's containers have properly shut down.
@ -261,6 +265,10 @@ message Task {
Driver log_driver = 13;
repeated GenericResource assigned_generic_resources = 15;
// JobIteration is the iteration number of the Job-mode Service that this
// task belongs to.
Version job_iteration = 16;
}
// NetworkAttachment specifies the network parameters of attachment to

1063
vendor/github.com/docker/swarmkit/api/specs.pb.go generated vendored
View file

File diff suppressed because it is too large Load diff

22
vendor/github.com/docker/swarmkit/api/specs.proto generated vendored
View file

@ -69,6 +69,8 @@ message ServiceSpec {
oneof mode {
ReplicatedService replicated = 3;
GlobalService global = 4;
ReplicatedJob replicated_job = 10;
GlobalJob global_job = 11;
}
// Update contains settings which affect updates.
@ -99,6 +101,26 @@ message GlobalService {
// Empty message for now.
}
// ReplicatedJob is a certain type of one-off job which executes many Tasks in
// parallel until the specified number of Tasks have succeeded.
message ReplicatedJob {
// MaxConcurrent indicates the maximum number of Tasks that should be
// executing simultaneously at any given time.
uint64 max_concurrent = 1;
// TotalCompletions sets the total number of Tasks desired to run to
// completion. This is also the absolute maximum number of Tasks that will
// be executed in parallel. That is, if this number is smaller than
// MaxConcurrent, only this many replicas will run.
uint64 total_completions = 2;
}
// GlobalJob is a type of one-off job which executes one Task on every node
// matching the service's placement constraints.
message GlobalJob {
// Empty message for now.
}
message TaskSpec {
oneof runtime {
NetworkAttachmentSpec attachment = 8;

920
vendor/github.com/docker/swarmkit/api/types.pb.go generated vendored
View file

@ -4014,6 +4014,53 @@ func (m *Privileges_SELinuxContext) XXX_DiscardUnknown() {
var xxx_messageInfo_Privileges_SELinuxContext proto.InternalMessageInfo
// JobStatus indicates the status of a Service that is in one of the Job modes.
type JobStatus struct {
// JobIteration is the count of how many times the Job has been excecuted,
// successfully or otherwise. "Executed" refers to the job as a whole being
// started, not to the individual Tasks being launched. This is used to
// disambiguate which Tasks belong to which iteration of a Job.
JobIteration Version `protobuf:"bytes,1,opt,name=job_iteration,json=jobIteration,proto3" json:"job_iteration"`
// LastExecution is the time that the job was last executed. This is set by
// the orchestrator in the same transaction that JobIteration is incremented.
// While time is a fungible concept in distributed systems like Swarmkit,
// this value gives us a best-effort attempt to prevent weird behavior like
// newly added nodes executing long-forgotten jobs.
LastExecution *types.Timestamp `protobuf:"bytes,2,opt,name=last_execution,json=lastExecution,proto3" json:"last_execution,omitempty"`
}
func (m *JobStatus) Reset() { *m = JobStatus{} }
func (*JobStatus) ProtoMessage() {}
func (*JobStatus) Descriptor() ([]byte, []int) {
return fileDescriptor_0b5eafd0404ded3d, []int{56}
}
func (m *JobStatus) XXX_Unmarshal(b []byte) error {
return m.Unmarshal(b)
}
func (m *JobStatus) XXX_Marshal(b []byte, deterministic bool) ([]byte, error) {
if deterministic {
return xxx_messageInfo_JobStatus.Marshal(b, m, deterministic)
} else {
b = b[:cap(b)]
n, err := m.MarshalTo(b)
if err != nil {
return nil, err
}
return b[:n], nil
}
}
func (m *JobStatus) XXX_Merge(src proto.Message) {
xxx_messageInfo_JobStatus.Merge(m, src)
}
func (m *JobStatus) XXX_Size() int {
return m.Size()
}
func (m *JobStatus) XXX_DiscardUnknown() {
xxx_messageInfo_JobStatus.DiscardUnknown(m)
}
var xxx_messageInfo_JobStatus proto.InternalMessageInfo
func init() {
proto.RegisterEnum("docker.swarmkit.v1.ResourceType", ResourceType_name, ResourceType_value)
proto.RegisterEnum("docker.swarmkit.v1.TaskState", TaskState_name, TaskState_value)
@ -4104,6 +4151,7 @@ func init() {
proto.RegisterType((*Privileges)(nil), "docker.swarmkit.v1.Privileges")
proto.RegisterType((*Privileges_CredentialSpec)(nil), "docker.swarmkit.v1.Privileges.CredentialSpec")
proto.RegisterType((*Privileges_SELinuxContext)(nil), "docker.swarmkit.v1.Privileges.SELinuxContext")
proto.RegisterType((*JobStatus)(nil), "docker.swarmkit.v1.JobStatus")
}
func init() {
@ -4111,338 +4159,342 @@ func init() {
}
var fileDescriptor_0b5eafd0404ded3d = []byte{
// 5289 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x3a, 0x4d, 0x6c, 0x23, 0x59,
0x5a, 0xb1, 0x63, 0x3b, 0xf6, 0x67, 0x27, 0xa9, 0x7e, 0x9d, 0xed, 0x49, 0x7b, 0x7a, 0x12, 0x4f,
0xcd, 0xf4, 0xce, 0x6c, 0xef, 0xe0, 0xfe, 0x9b, 0x1d, 0xf5, 0xcc, 0x30, 0x3b, 0xe3, 0xbf, 0x74,
0xbc, 0x9d, 0xd8, 0xd6, 0xb3, 0xd3, 0xbd, 0x8b, 0x04, 0x45, 0xa5, 0xea, 0xc5, 0xa9, 0x49, 0xb9,
0x5e, 0x51, 0x55, 0x4e, 0xda, 0x2c, 0x88, 0x39, 0x01, 0xca, 0x09, 0x2e, 0xcb, 0xae, 0x50, 0x24,
0x24, 0xb8, 0x71, 0xe0, 0xc0, 0x81, 0x85, 0xd3, 0x20, 0x21, 0xb4, 0xe2, 0xc2, 0x2e, 0x48, 0xb0,
0x02, 0x14, 0x98, 0xac, 0xc4, 0x0d, 0xc1, 0x05, 0x71, 0xe1, 0x80, 0xde, 0x4f, 0x95, 0x2b, 0xee,
0x4a, 0x32, 0xb3, 0xcb, 0x25, 0xf1, 0xfb, 0xfe, 0xde, 0xf7, 0xbe, 0xf7, 0xbd, 0xef, 0x7d, 0xdf,
0xf7, 0x0a, 0xee, 0x0c, 0xad, 0x60, 0x7f, 0xbc, 0x5b, 0x35, 0xe8, 0xe8, 0xae, 0x49, 0x8d, 0x03,
0xe2, 0xdd, 0xf5, 0x8f, 0x74, 0x6f, 0x74, 0x60, 0x05, 0x77, 0x75, 0xd7, 0xba, 0x1b, 0x4c, 0x5c,
0xe2, 0x57, 0x5d, 0x8f, 0x06, 0x14, 0x21, 0x41, 0x50, 0x0d, 0x09, 0xaa, 0x87, 0xf7, 0xcb, 0xeb,
0x43, 0x4a, 0x87, 0x36, 0xb9, 0xcb, 0x29, 0x76, 0xc7, 0x7b, 0x77, 0x03, 0x6b, 0x44, 0xfc, 0x40,
0x1f, 0xb9, 0x82, 0xa9, 0xbc, 0x36, 0x4b, 0x60, 0x8e, 0x3d, 0x3d, 0xb0, 0xa8, 0x73, 0x11, 0xfe,
0xc8, 0xd3, 0x5d, 0x97, 0x78, 0x72, 0xd2, 0xf2, 0xca, 0x90, 0x0e, 0x29, 0xff, 0x79, 0x97, 0xfd,
0x12, 0x50, 0x75, 0x1d, 0x16, 0x9e, 0x12, 0xcf, 0xb7, 0xa8, 0x83, 0x56, 0x20, 0x6b, 0x39, 0x26,
0x79, 0xbe, 0x9a, 0xaa, 0xa4, 0xde, 0xcc, 0x60, 0x31, 0x50, 0xef, 0x01, 0xb4, 0xd9, 0x8f, 0x96,
0x13, 0x78, 0x13, 0xa4, 0xc0, 0xfc, 0x01, 0x99, 0x70, 0x8a, 0x02, 0x66, 0x3f, 0x19, 0xe4, 0x50,
0xb7, 0x57, 0xd3, 0x02, 0x72, 0xa8, 0xdb, 0xea, 0x67, 0x29, 0x28, 0xd6, 0x1c, 0x87, 0x06, 0x5c,
0x3b, 0x1f, 0x21, 0xc8, 0x38, 0xfa, 0x88, 0x48, 0x26, 0xfe, 0x1b, 0x35, 0x20, 0x67, 0xeb, 0xbb,
0xc4, 0xf6, 0x57, 0xd3, 0x95, 0xf9, 0x37, 0x8b, 0x0f, 0xbe, 0x5a, 0x7d, 0xd1, 0x24, 0xd5, 0x98,
0x90, 0xea, 0x16, 0xa7, 0xe6, 0x4a, 0x60, 0xc9, 0x8a, 0xbe, 0x0e, 0x0b, 0x96, 0x63, 0x5a, 0x06,
0xf1, 0x57, 0x33, 0x5c, 0xca, 0x5a, 0x92, 0x94, 0xa9, 0xf6, 0xf5, 0xcc, 0x0f, 0x4e, 0xd7, 0xe7,
0x70, 0xc8, 0x54, 0x7e, 0x17, 0x8a, 0x31, 0xb1, 0x09, 0x6b, 0x5b, 0x81, 0xec, 0xa1, 0x6e, 0x8f,
0x89, 0x5c, 0x9d, 0x18, 0xbc, 0x97, 0x7e, 0x94, 0x52, 0x3f, 0x82, 0x95, 0x8e, 0x3e, 0x22, 0xe6,
0x63, 0xe2, 0x10, 0xcf, 0x32, 0x30, 0xf1, 0xe9, 0xd8, 0x33, 0x08, 0x5b, 0xeb, 0x81, 0xe5, 0x98,
0xe1, 0x5a, 0xd9, 0xef, 0x64, 0x29, 0x6a, 0x03, 0x5e, 0x6a, 0x5a, 0xbe, 0xe1, 0x91, 0x80, 0x7c,
0x61, 0x21, 0xf3, 0xa1, 0x90, 0xd3, 0x14, 0x2c, 0xcf, 0x72, 0xff, 0x02, 0x5c, 0x67, 0x26, 0x36,
0x35, 0x4f, 0x42, 0x34, 0xdf, 0x25, 0x06, 0x17, 0x56, 0x7c, 0xf0, 0x66, 0x92, 0x85, 0x92, 0x56,
0xb2, 0x39, 0x87, 0xaf, 0x71, 0x31, 0x21, 0xa0, 0xef, 0x12, 0x03, 0x19, 0x70, 0xc3, 0x94, 0x4a,
0xcf, 0x88, 0x4f, 0x73, 0xf1, 0x89, 0xdb, 0x78, 0xc1, 0x32, 0x37, 0xe7, 0xf0, 0x4a, 0x28, 0x2c,
0x3e, 0x49, 0x1d, 0x20, 0x1f, 0xca, 0x56, 0xbf, 0x9b, 0x82, 0x42, 0x88, 0xf4, 0xd1, 0x57, 0xa0,
0xe0, 0xe8, 0x0e, 0xd5, 0x0c, 0x77, 0xec, 0xf3, 0x05, 0xcd, 0xd7, 0x4b, 0x67, 0xa7, 0xeb, 0xf9,
0x8e, 0xee, 0xd0, 0x46, 0x6f, 0xc7, 0xc7, 0x79, 0x86, 0x6e, 0xb8, 0x63, 0x1f, 0xbd, 0x0a, 0xa5,
0x11, 0x19, 0x51, 0x6f, 0xa2, 0xed, 0x4e, 0x02, 0xe2, 0x4b, 0xb3, 0x15, 0x05, 0xac, 0xce, 0x40,
0xe8, 0x03, 0x58, 0x18, 0x0a, 0x95, 0x56, 0xe7, 0xb9, 0xfb, 0xbc, 0x96, 0xa4, 0xfd, 0x8c, 0xd6,
0x38, 0xe4, 0x51, 0xbf, 0x93, 0x86, 0x95, 0x08, 0x4a, 0x7e, 0x65, 0x6c, 0x79, 0x64, 0x44, 0x9c,
0xc0, 0x47, 0x5f, 0x83, 0x9c, 0x6d, 0x8d, 0xac, 0xc0, 0x97, 0x36, 0x7f, 0x25, 0x49, 0x6c, 0xb4,
0x28, 0x2c, 0x89, 0x51, 0x0d, 0x4a, 0x1e, 0xf1, 0x89, 0x77, 0x28, 0x3c, 0x5e, 0x5a, 0xf4, 0x0a,
0xe6, 0x73, 0x2c, 0xe8, 0x3d, 0x00, 0xff, 0x48, 0x77, 0xe5, 0x92, 0xe7, 0xb9, 0x80, 0x97, 0xab,
0x22, 0x2e, 0x54, 0xc3, 0xb8, 0x50, 0x6d, 0x3b, 0xc1, 0x3b, 0x6f, 0x3f, 0x65, 0xfe, 0x83, 0x0b,
0x8c, 0x5c, 0x58, 0x63, 0x13, 0xae, 0x49, 0x83, 0x31, 0x98, 0x6b, 0x39, 0xc4, 0x67, 0xc7, 0xea,
0x4a, 0x11, 0x8a, 0xe0, 0xea, 0x47, 0x4c, 0xea, 0x06, 0xe4, 0x7b, 0xb6, 0x1e, 0xec, 0x51, 0x6f,
0x84, 0x54, 0x28, 0xe9, 0x9e, 0xb1, 0x6f, 0x05, 0xc4, 0x08, 0xc6, 0x5e, 0x18, 0x03, 0xce, 0xc1,
0xd0, 0x0d, 0x48, 0x53, 0xb1, 0xdc, 0x42, 0x3d, 0x77, 0x76, 0xba, 0x9e, 0xee, 0xf6, 0x71, 0x9a,
0xfa, 0xea, 0xfb, 0x70, 0xad, 0x67, 0x8f, 0x87, 0x96, 0xd3, 0x24, 0xbe, 0xe1, 0x59, 0x2e, 0x5b,
0x23, 0x3b, 0x1b, 0x2c, 0x92, 0x86, 0x67, 0x83, 0xfd, 0x8e, 0x02, 0x4c, 0x7a, 0x1a, 0x60, 0xd4,
0xdf, 0x4a, 0xc3, 0xb5, 0x96, 0x33, 0xb4, 0x1c, 0x12, 0xe7, 0xbe, 0x0d, 0x4b, 0x84, 0x03, 0xb5,
0x43, 0x11, 0xf4, 0xa4, 0x9c, 0x45, 0x01, 0x0d, 0x23, 0x61, 0x7b, 0x26, 0x3a, 0xdd, 0x4f, 0xda,
0x84, 0x17, 0xa4, 0x27, 0xc6, 0xa8, 0x16, 0x2c, 0xb8, 0x7c, 0x11, 0xbe, 0x74, 0xb2, 0xdb, 0x49,
0xb2, 0x5e, 0x58, 0x67, 0x18, 0xaa, 0x24, 0xef, 0xcf, 0x12, 0xaa, 0xfe, 0x26, 0x0d, 0xcb, 0x1d,
0x6a, 0x9e, 0xb3, 0x43, 0x19, 0xf2, 0xfb, 0xd4, 0x0f, 0x62, 0x61, 0x39, 0x1a, 0xa3, 0x47, 0x90,
0x77, 0xe5, 0xf6, 0x49, 0x1f, 0xbc, 0x95, 0xac, 0xb2, 0xa0, 0xc1, 0x11, 0x35, 0x7a, 0x1f, 0x0a,
0xe1, 0xc1, 0x0d, 0xbd, 0xef, 0x0a, 0xf7, 0x9d, 0xd2, 0xa3, 0x0f, 0x20, 0x27, 0x36, 0x41, 0x3a,
0xdd, 0xed, 0xcf, 0x65, 0x73, 0x2c, 0x99, 0xd0, 0x63, 0xc8, 0x07, 0xb6, 0xaf, 0x59, 0xce, 0x1e,
0x5d, 0xcd, 0x72, 0x01, 0xeb, 0x89, 0xa1, 0x8e, 0x9a, 0x64, 0xb0, 0xd5, 0x6f, 0x3b, 0x7b, 0xb4,
0x5e, 0x3c, 0x3b, 0x5d, 0x5f, 0x90, 0x03, 0xbc, 0x10, 0xd8, 0x3e, 0xfb, 0x81, 0x6e, 0x41, 0x66,
0xcf, 0x72, 0xfd, 0xd5, 0x5c, 0x25, 0xf5, 0x66, 0xbe, 0x9e, 0x3f, 0x3b, 0x5d, 0xcf, 0x6c, 0xb4,
0x7b, 0x7d, 0xcc, 0xa1, 0xea, 0xef, 0xa6, 0xa0, 0x18, 0x93, 0x81, 0x5e, 0x01, 0x08, 0xbc, 0xb1,
0x1f, 0x68, 0x1e, 0xa5, 0x01, 0x37, 0x65, 0x09, 0x17, 0x38, 0x04, 0x53, 0x1a, 0xa0, 0x2a, 0x5c,
0x37, 0x88, 0x17, 0x68, 0x96, 0xef, 0x8f, 0x89, 0xa7, 0xf9, 0xe3, 0xdd, 0x8f, 0x89, 0x11, 0x70,
0xb3, 0x96, 0xf0, 0x35, 0x86, 0x6a, 0x73, 0x4c, 0x5f, 0x20, 0xd0, 0x43, 0xb8, 0x11, 0xa7, 0x77,
0xc7, 0xbb, 0xb6, 0x65, 0x68, 0x6c, 0xab, 0xe7, 0x39, 0xcb, 0xf5, 0x29, 0x4b, 0x8f, 0xe3, 0x9e,
0x90, 0x89, 0xfa, 0xe3, 0x14, 0x28, 0x58, 0xdf, 0x0b, 0xb6, 0xc9, 0x68, 0x97, 0x78, 0xfd, 0x40,
0x0f, 0xc6, 0x3e, 0xba, 0x01, 0x39, 0x9b, 0xe8, 0x26, 0xf1, 0xb8, 0x52, 0x79, 0x2c, 0x47, 0x68,
0x87, 0x45, 0x19, 0xdd, 0xd8, 0xd7, 0x77, 0x2d, 0xdb, 0x0a, 0x26, 0x5c, 0x95, 0xa5, 0x64, 0x07,
0x9f, 0x95, 0x59, 0xc5, 0x31, 0x46, 0x7c, 0x4e, 0x0c, 0x5a, 0x85, 0x85, 0x11, 0xf1, 0x7d, 0x7d,
0x48, 0xb8, 0xa6, 0x05, 0x1c, 0x0e, 0xd5, 0xf7, 0xa1, 0x14, 0xe7, 0x43, 0x45, 0x58, 0xd8, 0xe9,
0x3c, 0xe9, 0x74, 0x9f, 0x75, 0x94, 0x39, 0xb4, 0x0c, 0xc5, 0x9d, 0x0e, 0x6e, 0xd5, 0x1a, 0x9b,
0xb5, 0xfa, 0x56, 0x4b, 0x49, 0xa1, 0x45, 0x28, 0x4c, 0x87, 0x69, 0xf5, 0x4f, 0x53, 0x00, 0xcc,
0xdc, 0x72, 0x51, 0xef, 0x41, 0xd6, 0x0f, 0xf4, 0x40, 0xf8, 0xec, 0xd2, 0x83, 0xd7, 0x2f, 0xda,
0x61, 0xa9, 0x2f, 0xfb, 0x47, 0xb0, 0x60, 0x89, 0x6b, 0x98, 0x3e, 0xa7, 0x21, 0x0b, 0x1f, 0xba,
0x69, 0x7a, 0x52, 0x71, 0xfe, 0x5b, 0x7d, 0x1f, 0xb2, 0x9c, 0xfb, 0xbc, 0xba, 0x79, 0xc8, 0x34,
0xd9, 0xaf, 0x14, 0x2a, 0x40, 0x16, 0xb7, 0x6a, 0xcd, 0x6f, 0x29, 0x69, 0xa4, 0x40, 0xa9, 0xd9,
0xee, 0x37, 0xba, 0x9d, 0x4e, 0xab, 0x31, 0x68, 0x35, 0x95, 0x79, 0xf5, 0x36, 0x64, 0xdb, 0x23,
0x26, 0xf9, 0x16, 0x3b, 0x10, 0x7b, 0xc4, 0x23, 0x8e, 0x11, 0x9e, 0xb3, 0x29, 0x40, 0xfd, 0xac,
0x04, 0xd9, 0x6d, 0x3a, 0x76, 0x02, 0xf4, 0x20, 0x16, 0xd4, 0x96, 0x92, 0xb3, 0x18, 0x4e, 0x58,
0x1d, 0x4c, 0x5c, 0x22, 0x83, 0xde, 0x0d, 0xc8, 0x89, 0xa3, 0x23, 0x97, 0x23, 0x47, 0x0c, 0x1e,
0xe8, 0xde, 0x90, 0x04, 0x72, 0x3d, 0x72, 0x84, 0xde, 0x64, 0xb7, 0xaa, 0x6e, 0x52, 0xc7, 0x9e,
0xf0, 0x13, 0x96, 0x17, 0x57, 0x27, 0x26, 0xba, 0xd9, 0x75, 0xec, 0x09, 0x8e, 0xb0, 0xe8, 0x31,
0x14, 0x0d, 0xea, 0xf8, 0x96, 0x1f, 0x10, 0xc7, 0x98, 0xac, 0xe6, 0xb9, 0x52, 0xb7, 0x2f, 0x56,
0xaa, 0x31, 0x25, 0xc6, 0x71, 0x4e, 0xb4, 0x09, 0xa5, 0x5d, 0xcb, 0x31, 0x35, 0xea, 0x8a, 0x1b,
0x2d, 0x7b, 0xf1, 0xc1, 0x16, 0x92, 0xea, 0x96, 0x63, 0x76, 0x05, 0x31, 0x2e, 0xee, 0x4e, 0x07,
0xa8, 0x03, 0x4b, 0x87, 0xd4, 0x1e, 0x8f, 0x48, 0x24, 0x2b, 0xc7, 0x65, 0xbd, 0x71, 0xb1, 0xac,
0xa7, 0x9c, 0x3e, 0x94, 0xb6, 0x78, 0x18, 0x1f, 0xa2, 0x27, 0xb0, 0x18, 0x8c, 0xdc, 0x3d, 0x3f,
0x12, 0xb7, 0xc0, 0xc5, 0x7d, 0xf9, 0x12, 0xcb, 0x33, 0xf2, 0x50, 0x5a, 0x29, 0x88, 0x8d, 0xca,
0xdf, 0x9f, 0x87, 0x62, 0x4c, 0x73, 0xd4, 0x87, 0xa2, 0xeb, 0x51, 0x57, 0x1f, 0xf2, 0x5b, 0x59,
0x6e, 0xea, 0xfd, 0xcf, 0xb5, 0xea, 0x6a, 0x6f, 0xca, 0x88, 0xe3, 0x52, 0xd0, 0xdb, 0x50, 0x72,
0xa8, 0xe3, 0x11, 0x63, 0xec, 0xf9, 0xd6, 0xa1, 0xd8, 0xf4, 0x7c, 0x5d, 0x39, 0x3b, 0x5d, 0x2f,
0x75, 0xa8, 0x83, 0x43, 0x38, 0x3e, 0x47, 0xa5, 0x9e, 0xa4, 0xa1, 0x18, 0x13, 0x89, 0xee, 0x40,
0x1e, 0xf7, 0x70, 0xfb, 0x69, 0x6d, 0xd0, 0x52, 0xe6, 0xca, 0xb7, 0x8e, 0x4f, 0x2a, 0xab, 0x5c,
0x87, 0xf8, 0xb4, 0x3d, 0xcf, 0x3a, 0x64, 0x9e, 0xff, 0x26, 0x2c, 0x84, 0xa4, 0xa9, 0xf2, 0xcb,
0xc7, 0x27, 0x95, 0x97, 0x66, 0x49, 0x63, 0x94, 0xb8, 0xbf, 0x59, 0xc3, 0xad, 0xa6, 0x92, 0x4e,
0xa6, 0xc4, 0xfd, 0x7d, 0xdd, 0x23, 0x26, 0xfa, 0x32, 0xe4, 0x24, 0xe1, 0x7c, 0xb9, 0x7c, 0x7c,
0x52, 0xb9, 0x31, 0x4b, 0x38, 0xa5, 0xc3, 0xfd, 0xad, 0xda, 0xd3, 0x96, 0x92, 0x49, 0xa6, 0xc3,
0x7d, 0x5b, 0x3f, 0x24, 0xe8, 0x75, 0xc8, 0x0a, 0xb2, 0x6c, 0xf9, 0xe6, 0xf1, 0x49, 0xe5, 0x4b,
0x2f, 0x88, 0x63, 0x54, 0xe5, 0xd5, 0xdf, 0xfe, 0xc3, 0xb5, 0xb9, 0xbf, 0xf8, 0xa3, 0x35, 0x65,
0x16, 0x5d, 0xfe, 0xdf, 0x14, 0x2c, 0x9e, 0x73, 0x14, 0xa4, 0x42, 0xce, 0xa1, 0x06, 0x75, 0xc5,
0xe5, 0x9a, 0xaf, 0xc3, 0xd9, 0xe9, 0x7a, 0xae, 0x43, 0x1b, 0xd4, 0x9d, 0x60, 0x89, 0x41, 0x4f,
0x66, 0xd2, 0x83, 0x87, 0x9f, 0xd3, 0x0b, 0x13, 0x13, 0x84, 0x0f, 0x61, 0xd1, 0xf4, 0xac, 0x43,
0xe2, 0x69, 0x06, 0x75, 0xf6, 0xac, 0xa1, 0xbc, 0x38, 0xcb, 0x89, 0x99, 0x34, 0x27, 0xc4, 0x25,
0xc1, 0xd0, 0xe0, 0xf4, 0x3f, 0x43, 0x6a, 0x50, 0x76, 0xa1, 0x14, 0xf7, 0x6b, 0x76, 0x9b, 0xf9,
0xd6, 0xaf, 0x12, 0x99, 0x3f, 0xf2, 0x04, 0x1b, 0x17, 0x18, 0x44, 0xa4, 0x88, 0x6f, 0x40, 0x66,
0x44, 0x4d, 0x21, 0x67, 0xb1, 0x7e, 0x9d, 0x65, 0x28, 0xff, 0x74, 0xba, 0x5e, 0xa4, 0x7e, 0x75,
0xc3, 0xb2, 0xc9, 0x36, 0x35, 0x09, 0xe6, 0x04, 0x2c, 0xd6, 0x86, 0x07, 0x4b, 0xde, 0x06, 0x72,
0xa8, 0x7e, 0x2f, 0x05, 0x19, 0x16, 0xc4, 0xd0, 0xcb, 0x90, 0xa9, 0xb7, 0x3b, 0x4d, 0x65, 0xae,
0x7c, 0xed, 0xf8, 0xa4, 0xb2, 0xc8, 0xad, 0xc5, 0x10, 0xec, 0x30, 0xa0, 0x75, 0xc8, 0x3d, 0xed,
0x6e, 0xed, 0x6c, 0x33, 0xcf, 0xbb, 0x7e, 0x7c, 0x52, 0x59, 0x8e, 0xd0, 0xc2, 0x9e, 0xe8, 0x15,
0xc8, 0x0e, 0xb6, 0x7b, 0x1b, 0x7d, 0x25, 0x5d, 0x46, 0xc7, 0x27, 0x95, 0xa5, 0x08, 0xcf, 0x97,
0x83, 0x5e, 0x85, 0x6c, 0xa7, 0xd7, 0xee, 0xb5, 0x94, 0xf9, 0xf2, 0x8d, 0xe3, 0x93, 0x0a, 0x8a,
0xd0, 0xbc, 0xd2, 0xe9, 0x59, 0x2e, 0x29, 0x5f, 0x93, 0x3e, 0x51, 0x88, 0x70, 0xea, 0x8f, 0x52,
0x50, 0x8c, 0xc5, 0x32, 0xe6, 0xd6, 0xcd, 0xd6, 0x46, 0x6d, 0x67, 0x6b, 0xa0, 0xcc, 0xc5, 0xdc,
0x3a, 0x46, 0xd2, 0x24, 0x7b, 0xfa, 0xd8, 0x66, 0xb1, 0x15, 0x1a, 0xdd, 0x4e, 0xbf, 0xdd, 0x1f,
0xb4, 0x3a, 0x03, 0x25, 0x55, 0x5e, 0x3d, 0x3e, 0xa9, 0xac, 0xcc, 0x12, 0x6f, 0x8c, 0x6d, 0x9b,
0x39, 0x76, 0xa3, 0xd6, 0xd8, 0xe4, 0x27, 0x65, 0xea, 0xd8, 0x31, 0xaa, 0x86, 0x6e, 0xec, 0x13,
0x13, 0xbd, 0x05, 0x85, 0x66, 0x6b, 0xab, 0xf5, 0xb8, 0xc6, 0x6f, 0x94, 0xf2, 0x2b, 0xc7, 0x27,
0x95, 0x9b, 0x2f, 0xce, 0x6e, 0x93, 0xa1, 0x1e, 0x10, 0x73, 0xc6, 0xc1, 0x63, 0x24, 0xea, 0x7f,
0xa7, 0x61, 0x11, 0x13, 0x3f, 0xd0, 0xbd, 0xa0, 0x47, 0x6d, 0xcb, 0x98, 0xa0, 0x1e, 0x14, 0x0c,
0xea, 0x98, 0x56, 0x2c, 0x36, 0x3d, 0xb8, 0x20, 0x49, 0x9b, 0x72, 0x85, 0xa3, 0x46, 0xc8, 0x89,
0xa7, 0x42, 0xd0, 0x5d, 0xc8, 0x9a, 0xc4, 0xd6, 0x27, 0x32, 0x5b, 0xbc, 0xf9, 0x42, 0xb5, 0xd0,
0x94, 0x8d, 0x0a, 0x2c, 0xe8, 0x78, 0x6d, 0xa6, 0x3f, 0xd7, 0xf4, 0x20, 0x20, 0x23, 0x37, 0x10,
0x3e, 0x92, 0xc1, 0xc5, 0x91, 0xfe, 0xbc, 0x26, 0x41, 0xe8, 0x3e, 0xe4, 0x8e, 0x2c, 0xc7, 0xa4,
0x47, 0x32, 0x1b, 0xbc, 0x44, 0xa8, 0x24, 0x54, 0x8f, 0x59, 0x1a, 0x34, 0xa3, 0x26, 0x73, 0xb3,
0x4e, 0xb7, 0xd3, 0x0a, 0xdd, 0x4c, 0xe2, 0xbb, 0x4e, 0x87, 0x3a, 0x2c, 0x7a, 0x40, 0xb7, 0xa3,
0x6d, 0xd4, 0xda, 0x5b, 0x3b, 0x98, 0xb9, 0xda, 0xca, 0xf1, 0x49, 0x45, 0x89, 0x48, 0x36, 0x74,
0xcb, 0x66, 0xe5, 0xc9, 0x4d, 0x98, 0xaf, 0x75, 0xbe, 0xa5, 0xa4, 0xcb, 0xca, 0xf1, 0x49, 0xa5,
0x14, 0xa1, 0x6b, 0xce, 0x64, 0x6a, 0xf7, 0xd9, 0x79, 0xd5, 0xbf, 0x9d, 0x87, 0xd2, 0x8e, 0x6b,
0xea, 0x01, 0x11, 0xa7, 0x14, 0x55, 0xa0, 0xe8, 0xea, 0x9e, 0x6e, 0xdb, 0xc4, 0xb6, 0xfc, 0x91,
0x6c, 0xb1, 0xc4, 0x41, 0xe8, 0xdd, 0xcf, 0x6b, 0xc6, 0x7a, 0x9e, 0x9d, 0xbc, 0xef, 0xfe, 0xeb,
0x7a, 0x2a, 0x34, 0xe8, 0x0e, 0x2c, 0xed, 0x09, 0x6d, 0x35, 0xdd, 0xe0, 0x1b, 0x3b, 0xcf, 0x37,
0xb6, 0x9a, 0xb4, 0xb1, 0x71, 0xb5, 0xaa, 0x72, 0x91, 0x35, 0xce, 0x85, 0x17, 0xf7, 0xe2, 0x43,
0xf4, 0x10, 0x16, 0x46, 0xd4, 0xb1, 0x02, 0xea, 0x5d, 0xbd, 0x0b, 0x21, 0x25, 0xba, 0x03, 0xd7,
0xd8, 0xe6, 0x86, 0xfa, 0x70, 0x34, 0xbf, 0xf9, 0xd3, 0x78, 0x79, 0xa4, 0x3f, 0x97, 0x13, 0x62,
0x06, 0x46, 0x75, 0xc8, 0x52, 0x8f, 0xe5, 0xa8, 0x39, 0xae, 0xee, 0x5b, 0x57, 0xaa, 0x2b, 0x06,
0x5d, 0xc6, 0x83, 0x05, 0xab, 0xfa, 0x0e, 0x2c, 0x9e, 0x5b, 0x04, 0x4b, 0xcd, 0x7a, 0xb5, 0x9d,
0x7e, 0x4b, 0x99, 0x43, 0x25, 0xc8, 0x37, 0xba, 0x9d, 0x41, 0xbb, 0xb3, 0xc3, 0x72, 0xcb, 0x12,
0xe4, 0x71, 0x77, 0x6b, 0xab, 0x5e, 0x6b, 0x3c, 0x51, 0xd2, 0x6a, 0x15, 0x8a, 0x31, 0x69, 0x68,
0x09, 0xa0, 0x3f, 0xe8, 0xf6, 0xb4, 0x8d, 0x36, 0xee, 0x0f, 0x44, 0x66, 0xda, 0x1f, 0xd4, 0xf0,
0x40, 0x02, 0x52, 0xea, 0x7f, 0xa6, 0xc3, 0x1d, 0x95, 0xc9, 0x68, 0xfd, 0x7c, 0x32, 0x7a, 0x89,
0xf2, 0x32, 0x1d, 0x9d, 0x0e, 0xa2, 0xa4, 0xf4, 0x5d, 0x00, 0xee, 0x38, 0xc4, 0xd4, 0xf4, 0x40,
0x6e, 0x7c, 0xf9, 0x05, 0x23, 0x0f, 0xc2, 0x4e, 0x20, 0x2e, 0x48, 0xea, 0x5a, 0x80, 0x3e, 0x80,
0x92, 0x41, 0x47, 0xae, 0x4d, 0x24, 0xf3, 0xfc, 0x95, 0xcc, 0xc5, 0x88, 0xbe, 0x16, 0xc4, 0xd3,
0xe1, 0xcc, 0xf9, 0x84, 0xfd, 0x37, 0x53, 0xa1, 0x65, 0x12, 0x32, 0xe0, 0x12, 0xe4, 0x77, 0x7a,
0xcd, 0xda, 0xa0, 0xdd, 0x79, 0xac, 0xa4, 0x10, 0x40, 0x8e, 0x9b, 0xba, 0xa9, 0xa4, 0x59, 0xe6,
0xde, 0xe8, 0x6e, 0xf7, 0xb6, 0x5a, 0x3c, 0x62, 0xa1, 0x15, 0x50, 0x42, 0x63, 0x6b, 0xdc, 0x90,
0xad, 0xa6, 0x92, 0x41, 0xd7, 0x61, 0x39, 0x82, 0x4a, 0xce, 0x2c, 0xba, 0x01, 0x28, 0x02, 0x4e,
0x45, 0xe4, 0xd4, 0x5f, 0x87, 0xe5, 0x06, 0x75, 0x02, 0xdd, 0x72, 0xa2, 0xaa, 0xe6, 0x01, 0x5b,
0xb4, 0x04, 0x69, 0x96, 0xec, 0x90, 0xd5, 0x97, 0xcf, 0x4e, 0xd7, 0x8b, 0x11, 0x69, 0xbb, 0xc9,
0xb3, 0x50, 0x39, 0x30, 0xd9, 0xf9, 0x75, 0x2d, 0x93, 0x1b, 0x37, 0x5b, 0x5f, 0x38, 0x3b, 0x5d,
0x9f, 0xef, 0xb5, 0x9b, 0x98, 0xc1, 0xd0, 0xcb, 0x50, 0x20, 0xcf, 0xad, 0x40, 0x33, 0xd8, 0xad,
0xc6, 0x0c, 0x98, 0xc5, 0x79, 0x06, 0x68, 0x50, 0x93, 0xa8, 0x75, 0x80, 0x1e, 0xf5, 0x02, 0x39,
0xf3, 0xdb, 0x90, 0x75, 0xa9, 0xc7, 0x7b, 0x3a, 0x17, 0x76, 0x1a, 0x19, 0xb9, 0x70, 0x54, 0x2c,
0x88, 0xd5, 0xef, 0xcd, 0x03, 0x0c, 0x74, 0xff, 0x40, 0x0a, 0x79, 0x04, 0x85, 0xa8, 0xab, 0x2b,
0x9b, 0x43, 0x97, 0xee, 0x76, 0x44, 0x8c, 0x1e, 0x86, 0xce, 0x26, 0xea, 0xb5, 0xc4, 0xb2, 0x3a,
0x9c, 0x28, 0xa9, 0xe4, 0x39, 0x5f, 0x94, 0xb1, 0x24, 0x81, 0x78, 0x9e, 0xdc, 0x79, 0xf6, 0x13,
0x35, 0xf8, 0xb5, 0x20, 0x8c, 0x26, 0x13, 0xf5, 0xc4, 0x76, 0xd8, 0xcc, 0x8e, 0x6c, 0xce, 0xe1,
0x29, 0x1f, 0xfa, 0x10, 0x8a, 0x6c, 0xdd, 0x9a, 0xcf, 0x71, 0x32, 0x47, 0xbf, 0xd0, 0x54, 0x42,
0x02, 0x06, 0x77, 0x6a, 0xe5, 0x57, 0x00, 0x74, 0xd7, 0xb5, 0x2d, 0x62, 0x6a, 0xbb, 0x13, 0x9e,
0x94, 0x17, 0x70, 0x41, 0x42, 0xea, 0x13, 0x76, 0x5c, 0x42, 0xb4, 0x1e, 0xf0, 0xc2, 0xe4, 0x0a,
0x03, 0x4a, 0xea, 0x5a, 0x50, 0x57, 0x60, 0xc9, 0x1b, 0x3b, 0xcc, 0xa0, 0x52, 0x3b, 0xf5, 0x4f,
0xd2, 0xf0, 0x52, 0x87, 0x04, 0x47, 0xd4, 0x3b, 0xa8, 0x05, 0x81, 0x6e, 0xec, 0x8f, 0x88, 0x23,
0xb7, 0x2f, 0x56, 0x44, 0xa5, 0xce, 0x15, 0x51, 0xab, 0xb0, 0xa0, 0xdb, 0x96, 0xee, 0x13, 0x91,
0xfa, 0x15, 0x70, 0x38, 0x64, 0xa5, 0x1e, 0x2b, 0x1c, 0x89, 0xef, 0x13, 0xd1, 0xe9, 0x61, 0x8a,
0x87, 0x00, 0xf4, 0x6d, 0xb8, 0x21, 0x93, 0x3c, 0x3d, 0x9a, 0x8a, 0xd5, 0x1e, 0x61, 0xe3, 0xba,
0x95, 0x58, 0xc9, 0x26, 0x2b, 0x27, 0xb3, 0xc0, 0x29, 0xb8, 0xeb, 0x06, 0x32, 0xa7, 0x5c, 0x31,
0x13, 0x50, 0xe5, 0xc7, 0x70, 0xf3, 0x42, 0x96, 0x2f, 0xd4, 0x49, 0xfa, 0xfb, 0x34, 0x40, 0xbb,
0x57, 0xdb, 0x96, 0x46, 0x6a, 0x42, 0x6e, 0x4f, 0x1f, 0x59, 0xf6, 0xe4, 0xb2, 0x08, 0x38, 0xa5,
0xaf, 0xd6, 0x84, 0x39, 0x36, 0x38, 0x0f, 0x96, 0xbc, 0xbc, 0x8e, 0x1d, 0xef, 0x3a, 0x24, 0x88,
0xea, 0x58, 0x3e, 0x62, 0x6a, 0x78, 0xba, 0x13, 0xb9, 0xae, 0x18, 0xb0, 0x0d, 0x60, 0x29, 0xcf,
0x91, 0x3e, 0x09, 0xc3, 0x96, 0x1c, 0xa2, 0x4d, 0xde, 0x35, 0x26, 0xde, 0x21, 0x31, 0x57, 0xb3,
0xdc, 0xa8, 0x57, 0xe9, 0x83, 0x25, 0xb9, 0xb0, 0x5d, 0xc4, 0x5d, 0x7e, 0x9f, 0xa7, 0x4c, 0x53,
0xd4, 0x17, 0xb2, 0xd1, 0x3d, 0x58, 0x3c, 0xb7, 0xce, 0x17, 0x1a, 0x08, 0xed, 0xde, 0xd3, 0xb7,
0x95, 0x8c, 0xfc, 0xf5, 0x8e, 0x92, 0x53, 0xff, 0x7a, 0x5e, 0x04, 0x1a, 0x69, 0xd5, 0xe4, 0xd7,
0x92, 0x3c, 0xf7, 0x6e, 0x83, 0xda, 0x32, 0x00, 0xbc, 0x71, 0x79, 0xfc, 0x61, 0x75, 0x24, 0x27,
0xc7, 0x11, 0x23, 0x5a, 0x87, 0xa2, 0xf0, 0x62, 0x8d, 0x1d, 0x38, 0x6e, 0xd6, 0x45, 0x0c, 0x02,
0xc4, 0x38, 0xd1, 0x6d, 0x58, 0xe2, 0x0d, 0x27, 0x7f, 0x9f, 0x98, 0x82, 0x26, 0xc3, 0x69, 0x16,
0x23, 0x28, 0x27, 0xdb, 0x86, 0x92, 0x04, 0x68, 0xbc, 0x1a, 0xc8, 0x72, 0x85, 0xee, 0x5c, 0xa5,
0x90, 0x60, 0xe1, 0x45, 0x42, 0xd1, 0x9d, 0x0e, 0xd4, 0x5f, 0x86, 0x7c, 0xa8, 0x2c, 0x5a, 0x85,
0xf9, 0x41, 0xa3, 0xa7, 0xcc, 0x95, 0x97, 0x8f, 0x4f, 0x2a, 0xc5, 0x10, 0x3c, 0x68, 0xf4, 0x18,
0x66, 0xa7, 0xd9, 0x53, 0x52, 0xe7, 0x31, 0x3b, 0xcd, 0x1e, 0x2a, 0x43, 0xa6, 0xdf, 0x18, 0xf4,
0xc2, 0xfc, 0x2c, 0x44, 0x31, 0x58, 0x39, 0xc3, 0xf2, 0x33, 0x75, 0x0f, 0x8a, 0xb1, 0xd9, 0xd1,
0x6b, 0xb0, 0xd0, 0xee, 0x3c, 0xc6, 0xad, 0x7e, 0x5f, 0x99, 0x13, 0xe5, 0x41, 0x0c, 0xdb, 0x76,
0x86, 0x6c, 0xef, 0xd0, 0x2b, 0x90, 0xd9, 0xec, 0xb2, 0x7b, 0x5f, 0xd4, 0x1f, 0x31, 0x8a, 0x4d,
0xea, 0x07, 0xe5, 0xeb, 0x32, 0xf1, 0x8b, 0x0b, 0x56, 0x7f, 0x3f, 0x05, 0x39, 0x71, 0xd0, 0x12,
0x37, 0xb1, 0x36, 0x2d, 0x8a, 0x44, 0xd9, 0xf8, 0xc6, 0xc5, 0x25, 0x5e, 0x55, 0x56, 0x64, 0xc2,
0x35, 0x43, 0xbe, 0xf2, 0x7b, 0x50, 0x8a, 0x23, 0xbe, 0x90, 0x63, 0x7e, 0x1b, 0x8a, 0xcc, 0xf7,
0xc3, 0x52, 0xef, 0x01, 0xe4, 0x44, 0xb0, 0x88, 0xee, 0xa1, 0x8b, 0xeb, 0x4d, 0x49, 0x89, 0x1e,
0xc1, 0x82, 0xa8, 0x51, 0xc3, 0x5e, 0xf6, 0xda, 0xe5, 0x27, 0x0c, 0x87, 0xe4, 0xea, 0x87, 0x90,
0xe9, 0x11, 0xe2, 0x31, 0xdb, 0x3b, 0xd4, 0x24, 0xd3, 0xab, 0x5b, 0x96, 0xd7, 0x26, 0x69, 0x37,
0x59, 0x79, 0x6d, 0x92, 0xb6, 0x19, 0xf5, 0xe3, 0xd2, 0xb1, 0x7e, 0xdc, 0x00, 0x4a, 0xcf, 0x88,
0x35, 0xdc, 0x0f, 0x88, 0xc9, 0x05, 0xbd, 0x05, 0x19, 0x97, 0x44, 0xca, 0xaf, 0x26, 0x3a, 0x1f,
0x21, 0x1e, 0xe6, 0x54, 0x2c, 0xc6, 0x1c, 0x71, 0x6e, 0xf9, 0x0c, 0x24, 0x47, 0xea, 0xdf, 0xa5,
0x61, 0xa9, 0xed, 0xfb, 0x63, 0xdd, 0x31, 0xc2, 0xac, 0xee, 0xeb, 0xe7, 0xb3, 0xba, 0xc4, 0xf7,
0xb2, 0xf3, 0x2c, 0xe7, 0xdb, 0x8c, 0xf2, 0x66, 0x4d, 0x47, 0x37, 0xab, 0xfa, 0x1f, 0xa9, 0xb0,
0x97, 0x78, 0x3b, 0x16, 0x0a, 0x44, 0x8d, 0x18, 0x97, 0x44, 0x76, 0x9c, 0x03, 0x87, 0x1e, 0x39,
0xac, 0x7a, 0xc5, 0xad, 0x4e, 0xeb, 0x99, 0x92, 0x12, 0xee, 0x79, 0x8e, 0x08, 0x13, 0x87, 0x1c,
0x31, 0x49, 0xbd, 0x56, 0xa7, 0xc9, 0xb2, 0xb0, 0x74, 0x82, 0xa4, 0x1e, 0x71, 0x4c, 0xcb, 0x19,
0xa2, 0xd7, 0x20, 0xd7, 0xee, 0xf7, 0x77, 0x78, 0x09, 0xf9, 0xd2, 0xf1, 0x49, 0xe5, 0xfa, 0x39,
0x2a, 0xde, 0x47, 0x36, 0x19, 0x11, 0x2b, 0x81, 0x58, 0x7e, 0x96, 0x40, 0xc4, 0x72, 0x6b, 0x41,
0x84, 0xbb, 0x83, 0xda, 0xa0, 0xa5, 0x64, 0x13, 0x88, 0x30, 0x65, 0x7f, 0xe5, 0x71, 0xfb, 0xe7,
0x34, 0x28, 0x35, 0xc3, 0x20, 0x6e, 0xc0, 0xf0, 0xb2, 0xea, 0x1c, 0x40, 0xde, 0x65, 0xbf, 0x2c,
0x12, 0x66, 0x50, 0x8f, 0x12, 0x5f, 0x7c, 0x67, 0xf8, 0xaa, 0x98, 0xda, 0xa4, 0x66, 0x8e, 0x2c,
0xdf, 0xb7, 0xa8, 0x23, 0x60, 0x38, 0x92, 0x54, 0xfe, 0xaf, 0x14, 0x5c, 0x4f, 0xa0, 0x40, 0xf7,
0x20, 0xe3, 0x51, 0x3b, 0xdc, 0xc3, 0x5b, 0x17, 0xb5, 0x89, 0x19, 0x2b, 0xe6, 0x94, 0x68, 0x0d,
0x40, 0x1f, 0x07, 0x54, 0xe7, 0xf3, 0x8b, 0xe6, 0x1a, 0x8e, 0x41, 0xd0, 0x33, 0xc8, 0xf9, 0xc4,
0xf0, 0x48, 0x98, 0x67, 0x7f, 0xf8, 0xd3, 0x6a, 0x5f, 0xed, 0x73, 0x31, 0x58, 0x8a, 0x2b, 0x57,
0x21, 0x27, 0x20, 0xcc, 0xed, 0x4d, 0x3d, 0xd0, 0xe5, 0x23, 0x02, 0xff, 0xcd, 0xbc, 0x49, 0xb7,
0x87, 0xa1, 0x37, 0xe9, 0xf6, 0x50, 0xfd, 0xab, 0x34, 0x40, 0xeb, 0x79, 0x40, 0x3c, 0x47, 0xb7,
0x1b, 0x35, 0xd4, 0x8a, 0xdd, 0x0c, 0x62, 0xb5, 0x5f, 0x49, 0x7c, 0x37, 0x89, 0x38, 0xaa, 0x8d,
0x5a, 0xc2, 0xdd, 0x70, 0x13, 0xe6, 0xc7, 0x9e, 0x7c, 0xc4, 0x17, 0x39, 0xf2, 0x0e, 0xde, 0xc2,
0x0c, 0x86, 0x5a, 0xf1, 0x5e, 0xce, 0x85, 0x4f, 0xf5, 0xb1, 0x09, 0x12, 0x43, 0x17, 0x3b, 0xf9,
0x86, 0xae, 0x19, 0x44, 0xde, 0x2a, 0x25, 0x71, 0xf2, 0x1b, 0xb5, 0x06, 0xf1, 0x02, 0x9c, 0x33,
0x74, 0xf6, 0xff, 0x67, 0x8a, 0x6f, 0x6f, 0x01, 0x4c, 0x97, 0x86, 0xd6, 0x20, 0xdb, 0xd8, 0xe8,
0xf7, 0xb7, 0x94, 0x39, 0x11, 0xc0, 0xa7, 0x28, 0x0e, 0x56, 0xff, 0x3c, 0x0d, 0xf9, 0x46, 0x4d,
0x5e, 0xb9, 0x0d, 0x50, 0x78, 0x54, 0xe2, 0x4f, 0x2f, 0xe4, 0xb9, 0x6b, 0x79, 0x13, 0x19, 0x58,
0x2e, 0x29, 0x78, 0x97, 0x18, 0x0b, 0xd3, 0xba, 0xc5, 0x19, 0x10, 0x86, 0x12, 0x91, 0x46, 0xd0,
0x0c, 0x3d, 0x8c, 0xf1, 0x6b, 0x97, 0x1b, 0x4b, 0x94, 0x2e, 0xd3, 0xb1, 0x8f, 0x8b, 0xa1, 0x90,
0x86, 0xee, 0xa3, 0x77, 0x61, 0xd9, 0xb7, 0x86, 0x8e, 0xe5, 0x0c, 0xb5, 0xd0, 0x78, 0xfc, 0x1d,
0xa8, 0x7e, 0xed, 0xec, 0x74, 0x7d, 0xb1, 0x2f, 0x50, 0xd2, 0x86, 0x8b, 0x92, 0xb2, 0xc1, 0x4d,
0x89, 0xde, 0x81, 0xa5, 0x18, 0x2b, 0xb3, 0xa2, 0x30, 0x3b, 0xef, 0x18, 0x47, 0x9c, 0x4f, 0xc8,
0x04, 0x97, 0x22, 0xc6, 0x27, 0x84, 0xf7, 0x66, 0xf6, 0xa8, 0x67, 0x10, 0xcd, 0xe3, 0x67, 0x9a,
0xdf, 0xee, 0x19, 0x5c, 0xe4, 0x30, 0x71, 0xcc, 0xd5, 0xa7, 0x70, 0xbd, 0xeb, 0x19, 0xfb, 0xc4,
0x0f, 0x84, 0x29, 0xa4, 0x15, 0x3f, 0x84, 0x5b, 0x81, 0xee, 0x1f, 0x68, 0xfb, 0x96, 0x1f, 0x50,
0x6f, 0xa2, 0x79, 0x24, 0x20, 0x0e, 0xc3, 0x6b, 0xfc, 0x81, 0x5b, 0xb6, 0x13, 0x6f, 0x32, 0x9a,
0x4d, 0x41, 0x82, 0x43, 0x8a, 0x2d, 0x46, 0xa0, 0xb6, 0xa1, 0xc4, 0x4a, 0x18, 0xd9, 0x54, 0x63,
0xab, 0x07, 0x9b, 0x0e, 0xb5, 0xcf, 0x7d, 0x4d, 0x15, 0x6c, 0x3a, 0x14, 0x3f, 0xd5, 0x6f, 0x82,
0xd2, 0xb4, 0x7c, 0x57, 0x0f, 0x8c, 0xfd, 0xb0, 0x4f, 0x8a, 0x9a, 0xa0, 0xec, 0x13, 0xdd, 0x0b,
0x76, 0x89, 0x1e, 0x68, 0x2e, 0xf1, 0x2c, 0x6a, 0x5e, 0xbd, 0xcb, 0xcb, 0x11, 0x4b, 0x8f, 0x73,
0xa8, 0xff, 0x93, 0x02, 0xc0, 0xfa, 0x5e, 0x98, 0xad, 0x7d, 0x15, 0xae, 0xf9, 0x8e, 0xee, 0xfa,
0xfb, 0x34, 0xd0, 0x2c, 0x27, 0x20, 0xde, 0xa1, 0x6e, 0xcb, 0xe6, 0x8e, 0x12, 0x22, 0xda, 0x12,
0x8e, 0xde, 0x02, 0x74, 0x40, 0x88, 0xab, 0x51, 0xdb, 0xd4, 0x42, 0xa4, 0x78, 0xf8, 0xce, 0x60,
0x85, 0x61, 0xba, 0xb6, 0xd9, 0x0f, 0xe1, 0xa8, 0x0e, 0x6b, 0x6c, 0xf9, 0xc4, 0x09, 0x3c, 0x8b,
0xf8, 0xda, 0x1e, 0xf5, 0x34, 0xdf, 0xa6, 0x47, 0xda, 0x1e, 0xb5, 0x6d, 0x7a, 0x44, 0xbc, 0xb0,
0x6f, 0x56, 0xb6, 0xe9, 0xb0, 0x25, 0x88, 0x36, 0xa8, 0xd7, 0xb7, 0xe9, 0xd1, 0x46, 0x48, 0xc1,
0x52, 0xba, 0xe9, 0x9a, 0x03, 0xcb, 0x38, 0x08, 0x53, 0xba, 0x08, 0x3a, 0xb0, 0x8c, 0x03, 0xf4,
0x1a, 0x2c, 0x12, 0x9b, 0xf0, 0xf6, 0x89, 0xa0, 0xca, 0x72, 0xaa, 0x52, 0x08, 0x64, 0x44, 0xea,
0x47, 0xa0, 0xb4, 0x1c, 0xc3, 0x9b, 0xb8, 0xb1, 0x3d, 0x7f, 0x0b, 0x10, 0x0b, 0x92, 0x9a, 0x4d,
0x8d, 0x03, 0x6d, 0xa4, 0x3b, 0xfa, 0x90, 0xe9, 0x25, 0x5e, 0x1c, 0x15, 0x86, 0xd9, 0xa2, 0xc6,
0xc1, 0xb6, 0x84, 0xab, 0xef, 0x02, 0xf4, 0x5d, 0x8f, 0xe8, 0x66, 0x97, 0x65, 0x13, 0xcc, 0x74,
0x7c, 0xa4, 0x99, 0xf2, 0x3d, 0x97, 0x7a, 0xf2, 0xa8, 0x2b, 0x02, 0xd1, 0x8c, 0xe0, 0xea, 0x2f,
0xc2, 0xf5, 0x9e, 0xad, 0x1b, 0xfc, 0x0b, 0x8b, 0x5e, 0xf4, 0x84, 0x86, 0x1e, 0x41, 0x4e, 0x90,
0xca, 0x9d, 0x4c, 0x3c, 0x6e, 0xd3, 0x39, 0x37, 0xe7, 0xb0, 0xa4, 0xaf, 0x97, 0x00, 0xa6, 0x72,
0xd4, 0x7f, 0x4c, 0x41, 0x21, 0x92, 0x8f, 0x2a, 0xe2, 0x01, 0x2c, 0xf0, 0x74, 0xcb, 0x91, 0x15,
0x7f, 0x01, 0xc7, 0x41, 0xa8, 0x0d, 0x45, 0x37, 0xe2, 0xbe, 0x34, 0x9f, 0x4b, 0xd0, 0x1a, 0xc7,
0x79, 0xd1, 0x7b, 0x50, 0x08, 0x1f, 0xd0, 0xc3, 0x08, 0x7b, 0xf9, 0x7b, 0xfb, 0x94, 0x3c, 0x6c,
0xa4, 0x7a, 0xc4, 0xb5, 0x2d, 0x16, 0x73, 0x32, 0x51, 0x23, 0x15, 0x4b, 0x90, 0xfa, 0x75, 0x80,
0x6f, 0x50, 0xcb, 0x19, 0xd0, 0x03, 0xe2, 0xf0, 0x57, 0x61, 0x56, 0x52, 0x92, 0xd0, 0xd0, 0x72,
0xc4, 0x3b, 0x05, 0x62, 0x97, 0xa2, 0xc7, 0x51, 0x31, 0x54, 0xff, 0x32, 0x0d, 0x39, 0x4c, 0x69,
0xd0, 0xa8, 0xa1, 0x0a, 0xe4, 0x64, 0x28, 0xe1, 0x57, 0x54, 0xbd, 0x70, 0x76, 0xba, 0x9e, 0x15,
0x31, 0x24, 0x6b, 0xf0, 0xe0, 0x11, 0x0b, 0xf2, 0xe9, 0x8b, 0x82, 0x3c, 0xba, 0x07, 0x25, 0x49,
0xa4, 0xed, 0xeb, 0xfe, 0xbe, 0xa8, 0xef, 0xea, 0x4b, 0x67, 0xa7, 0xeb, 0x20, 0x28, 0x37, 0x75,
0x7f, 0x1f, 0x83, 0xa0, 0x66, 0xbf, 0x51, 0x0b, 0x8a, 0x1f, 0x53, 0xcb, 0xd1, 0x02, 0xbe, 0x08,
0xd9, 0x8b, 0x4c, 0xdc, 0xea, 0xe9, 0x52, 0xe5, 0x07, 0x14, 0xf0, 0xf1, 0x74, 0xf1, 0x2d, 0x58,
0xf4, 0x28, 0x0d, 0x44, 0x64, 0xb3, 0xa8, 0x23, 0xdb, 0x1c, 0x95, 0xc4, 0xee, 0x37, 0xa5, 0x01,
0x96, 0x74, 0xb8, 0xe4, 0xc5, 0x46, 0xe8, 0x1e, 0xac, 0xd8, 0xba, 0x1f, 0x68, 0x3c, 0x24, 0x9a,
0x53, 0x69, 0x39, 0x6e, 0x7c, 0xc4, 0x70, 0x1b, 0x1c, 0x15, 0x72, 0xa8, 0xff, 0x90, 0x82, 0x22,
0x5b, 0x8c, 0xb5, 0x67, 0x19, 0x2c, 0x0f, 0xfc, 0xe2, 0xe9, 0xc9, 0x4d, 0x98, 0x37, 0x7c, 0x4f,
0x1a, 0x95, 0xdf, 0xcf, 0x8d, 0x3e, 0xc6, 0x0c, 0x86, 0x3e, 0x82, 0x9c, 0x6c, 0xb7, 0x88, 0xcc,
0x44, 0xbd, 0x3a, 0x63, 0x95, 0xb6, 0x91, 0x7c, 0xdc, 0xdd, 0xa7, 0xda, 0x89, 0x7b, 0x02, 0xc7,
0x41, 0xe8, 0x06, 0xa4, 0x0d, 0x61, 0x2e, 0xf9, 0x85, 0x4e, 0xa3, 0x83, 0xd3, 0x86, 0xa3, 0xfe,
0x28, 0x05, 0x8b, 0xd3, 0x98, 0xc0, 0x3c, 0xe0, 0x16, 0x14, 0xfc, 0xf1, 0xae, 0x3f, 0xf1, 0x03,
0x32, 0x0a, 0x5f, 0xbc, 0x23, 0x00, 0x6a, 0x43, 0x41, 0xb7, 0x87, 0xd4, 0xb3, 0x82, 0xfd, 0x91,
0x2c, 0x64, 0x93, 0xb3, 0x89, 0xb8, 0xcc, 0x6a, 0x2d, 0x64, 0xc1, 0x53, 0xee, 0x30, 0x35, 0x10,
0x9f, 0x45, 0xf0, 0xd4, 0xe0, 0x55, 0x28, 0xd9, 0xfa, 0x88, 0xf7, 0x9f, 0x02, 0x6b, 0x44, 0xc2,
0xc3, 0x20, 0x61, 0x03, 0x6b, 0x44, 0x54, 0x15, 0x0a, 0x91, 0x30, 0xb4, 0x0c, 0xc5, 0x5a, 0xab,
0xaf, 0xdd, 0x7f, 0xf0, 0x48, 0x7b, 0xdc, 0xd8, 0x56, 0xe6, 0x64, 0xfa, 0xfa, 0x67, 0x29, 0x58,
0x94, 0x11, 0x4b, 0x96, 0x04, 0xaf, 0xc1, 0x82, 0xa7, 0xef, 0x05, 0x61, 0xd1, 0x92, 0x11, 0x5e,
0xcd, 0x2e, 0x01, 0x56, 0xb4, 0x30, 0x54, 0x72, 0xd1, 0x12, 0xfb, 0x06, 0x63, 0xfe, 0xd2, 0x6f,
0x30, 0x32, 0xff, 0x2f, 0xdf, 0x60, 0xa8, 0xbf, 0x01, 0xb0, 0x61, 0xd9, 0x64, 0x20, 0x5a, 0x55,
0x49, 0x25, 0x28, 0x4b, 0xf3, 0x64, 0x2b, 0x34, 0x4c, 0xf3, 0xda, 0x4d, 0xcc, 0x60, 0x0c, 0x35,
0xb4, 0x4c, 0x79, 0x18, 0x39, 0xea, 0x31, 0x43, 0x0d, 0x2d, 0x33, 0x7a, 0xf6, 0xcb, 0x5c, 0xf1,
0xec, 0xa7, 0x2e, 0xc3, 0x22, 0x16, 0x3d, 0x36, 0xa1, 0x83, 0x7a, 0x92, 0x82, 0x65, 0x99, 0xef,
0x46, 0x21, 0xfb, 0x2b, 0x50, 0x10, 0xa9, 0xef, 0xb4, 0x08, 0xe4, 0x1f, 0x22, 0x08, 0xba, 0x76,
0x13, 0xe7, 0x05, 0xba, 0x6d, 0xa2, 0x75, 0x28, 0x4a, 0xd2, 0xd8, 0xe7, 0x5d, 0x20, 0x40, 0x1d,
0xb6, 0x9e, 0xb7, 0x21, 0xb3, 0x67, 0xd9, 0x44, 0x7a, 0x7e, 0x62, 0x44, 0x98, 0x5a, 0x64, 0x73,
0x0e, 0x73, 0xea, 0x7a, 0x3e, 0x6c, 0xee, 0xa9, 0xff, 0x92, 0xe2, 0x2d, 0x66, 0x56, 0xaa, 0xc6,
0xf5, 0x13, 0x55, 0xeb, 0x8c, 0x7e, 0x82, 0x8e, 0xe9, 0x27, 0xd0, 0x42, 0x3f, 0x49, 0x1a, 0xd7,
0x4f, 0x80, 0x7e, 0x7a, 0xfd, 0xd0, 0x07, 0xb0, 0x20, 0x5b, 0x95, 0x32, 0xd4, 0xbd, 0x9a, 0xe8,
0x19, 0x71, 0x4b, 0x6f, 0xce, 0xe1, 0x90, 0x27, 0xb6, 0xbc, 0x2d, 0xb8, 0x51, 0xb7, 0x75, 0xe3,
0xc0, 0xb6, 0xfc, 0x80, 0x98, 0xf1, 0x08, 0xf4, 0x00, 0x72, 0xe7, 0xf2, 0xdc, 0xcb, 0x9a, 0xa8,
0x92, 0x52, 0xfd, 0xf7, 0x14, 0x94, 0x36, 0x89, 0x6e, 0x07, 0xfb, 0xd3, 0x4e, 0x55, 0x40, 0xfc,
0x40, 0xde, 0x8f, 0xfc, 0x37, 0xfa, 0x1a, 0xe4, 0xa3, 0x34, 0xe8, 0xca, 0xe7, 0xc0, 0x88, 0x14,
0x3d, 0x84, 0x05, 0xa6, 0x3b, 0x1d, 0x87, 0xf5, 0xd5, 0x65, 0x2f, 0x4d, 0x92, 0x92, 0x5d, 0x5a,
0x1e, 0xe1, 0x79, 0x0f, 0xb7, 0x53, 0x16, 0x87, 0x43, 0xf4, 0xf3, 0x50, 0xe2, 0x0f, 0x25, 0x61,
0x9a, 0x97, 0xbd, 0x4a, 0x66, 0x51, 0xbc, 0x75, 0x8a, 0x14, 0xef, 0x8f, 0xd3, 0xb0, 0xb2, 0xad,
0x4f, 0x76, 0x89, 0x0c, 0x43, 0xc4, 0xc4, 0xc4, 0xa0, 0x9e, 0x89, 0x7a, 0xf1, 0xf0, 0x75, 0xc9,
0xd3, 0x69, 0x12, 0x73, 0x72, 0x14, 0x0b, 0x6b, 0xbe, 0x74, 0xac, 0xe6, 0x5b, 0x81, 0xac, 0x43,
0x1d, 0x83, 0xc8, 0xd8, 0x26, 0x06, 0xea, 0x77, 0x52, 0xf1, 0xd8, 0x55, 0x8e, 0x9e, 0x35, 0x79,
0xd3, 0xab, 0x43, 0x83, 0x68, 0x3a, 0xf4, 0x11, 0x94, 0xfb, 0xad, 0x06, 0x6e, 0x0d, 0xea, 0xdd,
0x6f, 0x6a, 0xfd, 0xda, 0x56, 0xbf, 0xf6, 0xe0, 0x9e, 0xd6, 0xeb, 0x6e, 0x7d, 0xeb, 0xfe, 0xc3,
0x7b, 0x5f, 0x53, 0x52, 0xe5, 0xca, 0xf1, 0x49, 0xe5, 0x56, 0xa7, 0xd6, 0xd8, 0x12, 0x27, 0x6e,
0x97, 0x3e, 0xef, 0xeb, 0xb6, 0xaf, 0x3f, 0xb8, 0xd7, 0xa3, 0xf6, 0x84, 0xd1, 0xa0, 0xaf, 0x02,
0xda, 0x68, 0xe1, 0x4e, 0x6b, 0xa0, 0x85, 0x01, 0xb2, 0x51, 0x6f, 0x28, 0x69, 0x51, 0x49, 0x6d,
0x10, 0xcf, 0x21, 0x41, 0xad, 0xd5, 0xbf, 0xff, 0xe0, 0x51, 0xa3, 0xde, 0x60, 0x67, 0xbc, 0x14,
0xbf, 0x2d, 0xe3, 0x49, 0x40, 0xea, 0xc2, 0x24, 0x60, 0x9a, 0x4b, 0xa4, 0x2f, 0xc8, 0x25, 0x36,
0x60, 0xc5, 0xf0, 0xa8, 0xef, 0x6b, 0xac, 0x3c, 0x21, 0xe6, 0x4c, 0x01, 0xf4, 0xa5, 0xb3, 0xd3,
0xf5, 0x6b, 0x0d, 0x86, 0xef, 0x73, 0xb4, 0x14, 0x7f, 0xcd, 0x88, 0x81, 0xf8, 0x4c, 0xea, 0xf7,
0xe7, 0x59, 0xa6, 0x67, 0x1d, 0x5a, 0x36, 0x19, 0x12, 0x1f, 0x3d, 0x85, 0x65, 0xc3, 0x23, 0x26,
0xab, 0x3b, 0x74, 0x3b, 0xfe, 0x65, 0xf4, 0xcf, 0x25, 0x26, 0x5d, 0x11, 0x63, 0xb5, 0x11, 0x71,
0xf5, 0x5d, 0x62, 0xe0, 0x25, 0xe3, 0xdc, 0x18, 0x7d, 0x0c, 0xcb, 0x3e, 0xb1, 0x2d, 0x67, 0xfc,
0x5c, 0x33, 0xa8, 0x13, 0x90, 0xe7, 0xe1, 0x73, 0xde, 0x55, 0x72, 0xfb, 0xad, 0x2d, 0xc6, 0xd5,
0x10, 0x4c, 0x75, 0x74, 0x76, 0xba, 0xbe, 0x74, 0x1e, 0x86, 0x97, 0xa4, 0x64, 0x39, 0x2e, 0xef,
0xc3, 0xd2, 0x79, 0x6d, 0xd0, 0x8a, 0x0c, 0x34, 0x3c, 0x5e, 0x45, 0x81, 0xe4, 0x16, 0xe4, 0x3d,
0x32, 0xb4, 0xfc, 0xc0, 0x13, 0x66, 0x66, 0x98, 0x08, 0x82, 0x56, 0x21, 0x17, 0xfb, 0xe2, 0x84,
0xe1, 0xe4, 0x98, 0x45, 0x10, 0xf1, 0x31, 0x59, 0xf9, 0xd7, 0x60, 0x46, 0x17, 0x76, 0xe8, 0x4c,
0xcb, 0xd7, 0x77, 0xe5, 0x64, 0x79, 0x1c, 0x0e, 0x99, 0x2f, 0x8f, 0xfd, 0x28, 0x81, 0xe4, 0xbf,
0x19, 0x8c, 0x67, 0x3a, 0xf2, 0xd3, 0x3a, 0x9e, 0xcb, 0x84, 0x5f, 0xf0, 0x66, 0x62, 0x5f, 0xf0,
0xae, 0x40, 0xd6, 0x26, 0x87, 0xc4, 0x16, 0x39, 0x06, 0x16, 0x83, 0x3b, 0xf7, 0xa0, 0x14, 0x7e,
0x2a, 0xca, 0xbf, 0x19, 0xc9, 0x43, 0x66, 0x50, 0xeb, 0x3f, 0x51, 0xe6, 0x10, 0x40, 0x4e, 0xf8,
0xb8, 0x78, 0x84, 0x6c, 0x74, 0x3b, 0x1b, 0xed, 0xc7, 0x4a, 0xfa, 0xce, 0xef, 0x65, 0xa0, 0x10,
0x3d, 0x83, 0xb1, 0x3b, 0xad, 0xd3, 0x7a, 0x16, 0x1e, 0x92, 0x08, 0xde, 0x21, 0x47, 0xe8, 0xd5,
0x69, 0x03, 0xed, 0x23, 0xf1, 0xee, 0x1f, 0xa1, 0xc3, 0xe6, 0xd9, 0xeb, 0x90, 0xaf, 0xf5, 0xfb,
0xed, 0xc7, 0x9d, 0x56, 0x53, 0xf9, 0x34, 0x55, 0xfe, 0xd2, 0xf1, 0x49, 0xe5, 0x5a, 0x44, 0x54,
0xf3, 0x85, 0x5b, 0x72, 0xaa, 0x46, 0xa3, 0xd5, 0x1b, 0xb4, 0x9a, 0xca, 0x27, 0xe9, 0x59, 0x2a,
0xde, 0x10, 0xe2, 0xdf, 0x33, 0x15, 0x7a, 0xb8, 0xd5, 0xab, 0x61, 0x36, 0xe1, 0xa7, 0x69, 0xd1,
0xd7, 0x9b, 0xce, 0xe8, 0x11, 0x57, 0xf7, 0xd8, 0x9c, 0x6b, 0xe1, 0x67, 0x85, 0x9f, 0xcc, 0x8b,
0x0f, 0x5b, 0xa6, 0x6f, 0x7a, 0x44, 0x37, 0x27, 0x6c, 0x36, 0xfe, 0x98, 0xca, 0xc5, 0xcc, 0xcf,
0xcc, 0xd6, 0x67, 0x31, 0x8c, 0x49, 0x51, 0x61, 0x01, 0xef, 0x74, 0x3a, 0x8c, 0xe8, 0x93, 0xcc,
0xcc, 0xea, 0xf0, 0xd8, 0x61, 0xc5, 0x3e, 0xba, 0x0d, 0xf9, 0xf0, 0xad, 0x55, 0xf9, 0x34, 0x33,
0xa3, 0x50, 0x23, 0x7c, 0x28, 0xe6, 0x13, 0x6e, 0xee, 0x0c, 0xf8, 0x57, 0x8f, 0x9f, 0x64, 0x67,
0x27, 0xdc, 0x1f, 0x07, 0x26, 0x3d, 0x72, 0xd8, 0x69, 0x96, 0x2d, 0xc4, 0x4f, 0xb3, 0x22, 0x4a,
0x44, 0x34, 0xb2, 0x7f, 0xf8, 0x3a, 0xe4, 0x71, 0xeb, 0x1b, 0xe2, 0x03, 0xc9, 0x4f, 0x72, 0x33,
0x72, 0x30, 0xf9, 0x98, 0x18, 0x6c, 0xb6, 0x0a, 0xe4, 0x70, 0x6b, 0xbb, 0xfb, 0xb4, 0xa5, 0xfc,
0x41, 0x6e, 0x46, 0x0e, 0x26, 0x23, 0xca, 0x3f, 0xf8, 0xca, 0x77, 0x71, 0x6f, 0xb3, 0xc6, 0x37,
0x65, 0x56, 0x4e, 0xd7, 0x73, 0xf7, 0x75, 0x87, 0x98, 0xd3, 0x8f, 0x7b, 0x22, 0xd4, 0x9d, 0x5f,
0x82, 0x7c, 0x98, 0x53, 0xa3, 0x35, 0xc8, 0x3d, 0xeb, 0xe2, 0x27, 0x2d, 0xac, 0xcc, 0x09, 0x2b,
0x87, 0x98, 0x67, 0xa2, 0x1a, 0xaa, 0xc0, 0xc2, 0x76, 0xad, 0x53, 0x7b, 0xdc, 0xc2, 0x61, 0xff,
0x3f, 0x24, 0x90, 0x89, 0x61, 0x59, 0x91, 0x13, 0x44, 0x32, 0xeb, 0xaf, 0xff, 0xe0, 0xb3, 0xb5,
0xb9, 0x1f, 0x7f, 0xb6, 0x36, 0xf7, 0xc9, 0xd9, 0x5a, 0xea, 0x07, 0x67, 0x6b, 0xa9, 0x1f, 0x9e,
0xad, 0xa5, 0xfe, 0xed, 0x6c, 0x2d, 0xf5, 0x3b, 0x3f, 0x59, 0x9b, 0xfb, 0xe1, 0x4f, 0xd6, 0xe6,
0x7e, 0xfc, 0x93, 0xb5, 0xb9, 0xdd, 0x1c, 0xbf, 0x7a, 0x1e, 0xfe, 0x5f, 0x00, 0x00, 0x00, 0xff,
0xff, 0x4e, 0x60, 0x1a, 0x9d, 0x2d, 0x34, 0x00, 0x00,
// 5345 bytes of a gzipped FileDescriptorProto
0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xac, 0x3a, 0x4b, 0x6c, 0x24, 0x49,
0x56, 0xae, 0x72, 0x55, 0xb9, 0xea, 0x55, 0xd9, 0xce, 0x8e, 0xf6, 0xf6, 0xb8, 0x6b, 0x7a, 0x6c,
0x4f, 0xce, 0xf4, 0xce, 0xec, 0xec, 0xe0, 0xfe, 0xcd, 0x8e, 0x7a, 0x66, 0x98, 0x9d, 0xa9, 0x4f,
0xba, 0x5d, 0xdb, 0x76, 0x55, 0x29, 0xaa, 0xdc, 0xbd, 0x8b, 0x04, 0x49, 0x3a, 0x33, 0x5c, 0xce,
0x76, 0x56, 0x46, 0x92, 0x99, 0x65, 0x77, 0xb1, 0x20, 0xe6, 0x04, 0xc8, 0x27, 0xb8, 0x2c, 0xbb,
0x42, 0x96, 0x90, 0xe0, 0xc6, 0x81, 0x03, 0x07, 0x16, 0x4e, 0x83, 0x84, 0xd0, 0x8a, 0x0b, 0xbb,
0x20, 0xc1, 0x0a, 0x90, 0x61, 0xbc, 0x12, 0x37, 0x04, 0x17, 0xc4, 0x85, 0x03, 0x8a, 0x4f, 0x66,
0xa5, 0xab, 0xd3, 0xf6, 0xcc, 0x2e, 0x17, 0xbb, 0xe2, 0xfd, 0xf2, 0xc5, 0x8b, 0x17, 0x2f, 0xde,
0x7b, 0x11, 0xf0, 0xd6, 0xc0, 0x0e, 0xf7, 0x47, 0xbb, 0xeb, 0x26, 0x1d, 0xde, 0xb1, 0xa8, 0x79,
0x40, 0xfc, 0x3b, 0xc1, 0x91, 0xe1, 0x0f, 0x0f, 0xec, 0xf0, 0x8e, 0xe1, 0xd9, 0x77, 0xc2, 0xb1,
0x47, 0x82, 0x75, 0xcf, 0xa7, 0x21, 0x45, 0x48, 0x10, 0xac, 0x47, 0x04, 0xeb, 0x87, 0xf7, 0xaa,
0xab, 0x03, 0x4a, 0x07, 0x0e, 0xb9, 0xc3, 0x29, 0x76, 0x47, 0x7b, 0x77, 0x42, 0x7b, 0x48, 0x82,
0xd0, 0x18, 0x7a, 0x82, 0xa9, 0xba, 0x32, 0x4d, 0x60, 0x8d, 0x7c, 0x23, 0xb4, 0xa9, 0x7b, 0x11,
0xfe, 0xc8, 0x37, 0x3c, 0x8f, 0xf8, 0xf2, 0xa3, 0xd5, 0xa5, 0x01, 0x1d, 0x50, 0xfe, 0xf3, 0x0e,
0xfb, 0x25, 0xa0, 0xea, 0x2a, 0xcc, 0x3d, 0x21, 0x7e, 0x60, 0x53, 0x17, 0x2d, 0x41, 0xde, 0x76,
0x2d, 0xf2, 0x7c, 0x39, 0xb3, 0x96, 0x79, 0x33, 0x87, 0xc5, 0x40, 0xbd, 0x0b, 0xd0, 0x62, 0x3f,
0x34, 0x37, 0xf4, 0xc7, 0x48, 0x81, 0xd9, 0x03, 0x32, 0xe6, 0x14, 0x25, 0xcc, 0x7e, 0x32, 0xc8,
0xa1, 0xe1, 0x2c, 0x67, 0x05, 0xe4, 0xd0, 0x70, 0xd4, 0xcf, 0x32, 0x50, 0xae, 0xb9, 0x2e, 0x0d,
0xb9, 0x76, 0x01, 0x42, 0x90, 0x73, 0x8d, 0x21, 0x91, 0x4c, 0xfc, 0x37, 0x6a, 0x40, 0xc1, 0x31,
0x76, 0x89, 0x13, 0x2c, 0x67, 0xd7, 0x66, 0xdf, 0x2c, 0xdf, 0xff, 0xea, 0xfa, 0x8b, 0x26, 0x59,
0x4f, 0x08, 0x59, 0xdf, 0xe2, 0xd4, 0x5c, 0x09, 0x2c, 0x59, 0xd1, 0xd7, 0x61, 0xce, 0x76, 0x2d,
0xdb, 0x24, 0xc1, 0x72, 0x8e, 0x4b, 0x59, 0x49, 0x93, 0x32, 0xd1, 0xbe, 0x9e, 0xfb, 0xc1, 0xe9,
0xea, 0x0c, 0x8e, 0x98, 0xaa, 0xef, 0x41, 0x39, 0x21, 0x36, 0x65, 0x6e, 0x4b, 0x90, 0x3f, 0x34,
0x9c, 0x11, 0x91, 0xb3, 0x13, 0x83, 0xf7, 0xb3, 0x0f, 0x33, 0xea, 0xc7, 0xb0, 0xd4, 0x36, 0x86,
0xc4, 0x7a, 0x44, 0x5c, 0xe2, 0xdb, 0x26, 0x26, 0x01, 0x1d, 0xf9, 0x26, 0x61, 0x73, 0x3d, 0xb0,
0x5d, 0x2b, 0x9a, 0x2b, 0xfb, 0x9d, 0x2e, 0x45, 0x6d, 0xc0, 0x4b, 0x4d, 0x3b, 0x30, 0x7d, 0x12,
0x92, 0x2f, 0x2c, 0x64, 0x36, 0x12, 0x72, 0x9a, 0x81, 0xc5, 0x69, 0xee, 0x5f, 0x80, 0xeb, 0xcc,
0xc4, 0x96, 0xee, 0x4b, 0x88, 0x1e, 0x78, 0xc4, 0xe4, 0xc2, 0xca, 0xf7, 0xdf, 0x4c, 0xb3, 0x50,
0xda, 0x4c, 0x36, 0x67, 0xf0, 0x35, 0x2e, 0x26, 0x02, 0xf4, 0x3c, 0x62, 0x22, 0x13, 0x6e, 0x58,
0x52, 0xe9, 0x29, 0xf1, 0x59, 0x2e, 0x3e, 0x75, 0x19, 0x2f, 0x98, 0xe6, 0xe6, 0x0c, 0x5e, 0x8a,
0x84, 0x25, 0x3f, 0x52, 0x07, 0x28, 0x46, 0xb2, 0xd5, 0xef, 0x66, 0xa0, 0x14, 0x21, 0x03, 0xf4,
0x15, 0x28, 0xb9, 0x86, 0x4b, 0x75, 0xd3, 0x1b, 0x05, 0x7c, 0x42, 0xb3, 0xf5, 0xca, 0xd9, 0xe9,
0x6a, 0xb1, 0x6d, 0xb8, 0xb4, 0xd1, 0xdd, 0x09, 0x70, 0x91, 0xa1, 0x1b, 0xde, 0x28, 0x40, 0xaf,
0x42, 0x65, 0x48, 0x86, 0xd4, 0x1f, 0xeb, 0xbb, 0xe3, 0x90, 0x04, 0xd2, 0x6c, 0x65, 0x01, 0xab,
0x33, 0x10, 0xfa, 0x10, 0xe6, 0x06, 0x42, 0xa5, 0xe5, 0x59, 0xee, 0x3e, 0xaf, 0xa5, 0x69, 0x3f,
0xa5, 0x35, 0x8e, 0x78, 0xd4, 0xef, 0x64, 0x61, 0x29, 0x86, 0x92, 0x5f, 0x19, 0xd9, 0x3e, 0x19,
0x12, 0x37, 0x0c, 0xd0, 0xd7, 0xa0, 0xe0, 0xd8, 0x43, 0x3b, 0x0c, 0xa4, 0xcd, 0x5f, 0x49, 0x13,
0x1b, 0x4f, 0x0a, 0x4b, 0x62, 0x54, 0x83, 0x8a, 0x4f, 0x02, 0xe2, 0x1f, 0x0a, 0x8f, 0x97, 0x16,
0xbd, 0x82, 0xf9, 0x1c, 0x0b, 0x7a, 0x1f, 0x20, 0x38, 0x32, 0x3c, 0x39, 0xe5, 0x59, 0x2e, 0xe0,
0xe5, 0x75, 0x11, 0x17, 0xd6, 0xa3, 0xb8, 0xb0, 0xde, 0x72, 0xc3, 0x77, 0xdf, 0x79, 0xc2, 0xfc,
0x07, 0x97, 0x18, 0xb9, 0xb0, 0xc6, 0x26, 0x5c, 0x93, 0x06, 0x63, 0x30, 0xcf, 0x76, 0x49, 0xc0,
0xb6, 0xd5, 0x95, 0x22, 0x14, 0xc1, 0xd5, 0x8b, 0x99, 0xd4, 0x0d, 0x28, 0x76, 0x1d, 0x23, 0xdc,
0xa3, 0xfe, 0x10, 0xa9, 0x50, 0x31, 0x7c, 0x73, 0xdf, 0x0e, 0x89, 0x19, 0x8e, 0xfc, 0x28, 0x06,
0x9c, 0x83, 0xa1, 0x1b, 0x90, 0xa5, 0x62, 0xba, 0xa5, 0x7a, 0xe1, 0xec, 0x74, 0x35, 0xdb, 0xe9,
0xe1, 0x2c, 0x0d, 0xd4, 0x0f, 0xe0, 0x5a, 0xd7, 0x19, 0x0d, 0x6c, 0xb7, 0x49, 0x02, 0xd3, 0xb7,
0x3d, 0x36, 0x47, 0xb6, 0x37, 0x58, 0x24, 0x8d, 0xf6, 0x06, 0xfb, 0x1d, 0x07, 0x98, 0xec, 0x24,
0xc0, 0xa8, 0xbf, 0x95, 0x85, 0x6b, 0x9a, 0x3b, 0xb0, 0x5d, 0x92, 0xe4, 0xbe, 0x0d, 0x0b, 0x84,
0x03, 0xf5, 0x43, 0x11, 0xf4, 0xa4, 0x9c, 0x79, 0x01, 0x8d, 0x22, 0x61, 0x6b, 0x2a, 0x3a, 0xdd,
0x4b, 0x5b, 0x84, 0x17, 0xa4, 0xa7, 0xc6, 0x28, 0x0d, 0xe6, 0x3c, 0x3e, 0x89, 0x40, 0x3a, 0xd9,
0xed, 0x34, 0x59, 0x2f, 0xcc, 0x33, 0x0a, 0x55, 0x92, 0xf7, 0x67, 0x09, 0x55, 0x7f, 0x93, 0x85,
0xc5, 0x36, 0xb5, 0xce, 0xd9, 0xa1, 0x0a, 0xc5, 0x7d, 0x1a, 0x84, 0x89, 0xb0, 0x1c, 0x8f, 0xd1,
0x43, 0x28, 0x7a, 0x72, 0xf9, 0xa4, 0x0f, 0xde, 0x4a, 0x57, 0x59, 0xd0, 0xe0, 0x98, 0x1a, 0x7d,
0x00, 0xa5, 0x68, 0xe3, 0x46, 0xde, 0x77, 0x85, 0xfb, 0x4e, 0xe8, 0xd1, 0x87, 0x50, 0x10, 0x8b,
0x20, 0x9d, 0xee, 0xf6, 0xe7, 0xb2, 0x39, 0x96, 0x4c, 0xe8, 0x11, 0x14, 0x43, 0x27, 0xd0, 0x6d,
0x77, 0x8f, 0x2e, 0xe7, 0xb9, 0x80, 0xd5, 0xd4, 0x50, 0x47, 0x2d, 0xd2, 0xdf, 0xea, 0xb5, 0xdc,
0x3d, 0x5a, 0x2f, 0x9f, 0x9d, 0xae, 0xce, 0xc9, 0x01, 0x9e, 0x0b, 0x9d, 0x80, 0xfd, 0x40, 0xb7,
0x20, 0xb7, 0x67, 0x7b, 0xc1, 0x72, 0x61, 0x2d, 0xf3, 0x66, 0xb1, 0x5e, 0x3c, 0x3b, 0x5d, 0xcd,
0x6d, 0xb4, 0xba, 0x3d, 0xcc, 0xa1, 0xea, 0xef, 0x66, 0xa0, 0x9c, 0x90, 0x81, 0x5e, 0x01, 0x08,
0xfd, 0x51, 0x10, 0xea, 0x3e, 0xa5, 0x21, 0x37, 0x65, 0x05, 0x97, 0x38, 0x04, 0x53, 0x1a, 0xa2,
0x75, 0xb8, 0x6e, 0x12, 0x3f, 0xd4, 0xed, 0x20, 0x18, 0x11, 0x5f, 0x0f, 0x46, 0xbb, 0xcf, 0x88,
0x19, 0x72, 0xb3, 0x56, 0xf0, 0x35, 0x86, 0x6a, 0x71, 0x4c, 0x4f, 0x20, 0xd0, 0x03, 0xb8, 0x91,
0xa4, 0xf7, 0x46, 0xbb, 0x8e, 0x6d, 0xea, 0x6c, 0xa9, 0x67, 0x39, 0xcb, 0xf5, 0x09, 0x4b, 0x97,
0xe3, 0x1e, 0x93, 0xb1, 0xfa, 0xe3, 0x0c, 0x28, 0xd8, 0xd8, 0x0b, 0xb7, 0xc9, 0x70, 0x97, 0xf8,
0xbd, 0xd0, 0x08, 0x47, 0x01, 0xba, 0x01, 0x05, 0x87, 0x18, 0x16, 0xf1, 0xb9, 0x52, 0x45, 0x2c,
0x47, 0x68, 0x87, 0x45, 0x19, 0xc3, 0xdc, 0x37, 0x76, 0x6d, 0xc7, 0x0e, 0xc7, 0x5c, 0x95, 0x85,
0x74, 0x07, 0x9f, 0x96, 0xb9, 0x8e, 0x13, 0x8c, 0xf8, 0x9c, 0x18, 0xb4, 0x0c, 0x73, 0x43, 0x12,
0x04, 0xc6, 0x80, 0x70, 0x4d, 0x4b, 0x38, 0x1a, 0xaa, 0x1f, 0x40, 0x25, 0xc9, 0x87, 0xca, 0x30,
0xb7, 0xd3, 0x7e, 0xdc, 0xee, 0x3c, 0x6d, 0x2b, 0x33, 0x68, 0x11, 0xca, 0x3b, 0x6d, 0xac, 0xd5,
0x1a, 0x9b, 0xb5, 0xfa, 0x96, 0xa6, 0x64, 0xd0, 0x3c, 0x94, 0x26, 0xc3, 0xac, 0xfa, 0xa7, 0x19,
0x00, 0x66, 0x6e, 0x39, 0xa9, 0xf7, 0x21, 0x1f, 0x84, 0x46, 0x28, 0x7c, 0x76, 0xe1, 0xfe, 0xeb,
0x17, 0xad, 0xb0, 0xd4, 0x97, 0xfd, 0x23, 0x58, 0xb0, 0x24, 0x35, 0xcc, 0x9e, 0xd3, 0x90, 0x85,
0x0f, 0xc3, 0xb2, 0x7c, 0xa9, 0x38, 0xff, 0xad, 0x7e, 0x00, 0x79, 0xce, 0x7d, 0x5e, 0xdd, 0x22,
0xe4, 0x9a, 0xec, 0x57, 0x06, 0x95, 0x20, 0x8f, 0xb5, 0x5a, 0xf3, 0x5b, 0x4a, 0x16, 0x29, 0x50,
0x69, 0xb6, 0x7a, 0x8d, 0x4e, 0xbb, 0xad, 0x35, 0xfa, 0x5a, 0x53, 0x99, 0x55, 0x6f, 0x43, 0xbe,
0x35, 0x64, 0x92, 0x6f, 0xb1, 0x0d, 0xb1, 0x47, 0x7c, 0xe2, 0x9a, 0xd1, 0x3e, 0x9b, 0x00, 0xd4,
0xcf, 0x2a, 0x90, 0xdf, 0xa6, 0x23, 0x37, 0x44, 0xf7, 0x13, 0x41, 0x6d, 0x21, 0x3d, 0x8b, 0xe1,
0x84, 0xeb, 0xfd, 0xb1, 0x47, 0x64, 0xd0, 0xbb, 0x01, 0x05, 0xb1, 0x75, 0xe4, 0x74, 0xe4, 0x88,
0xc1, 0x43, 0xc3, 0x1f, 0x90, 0x50, 0xce, 0x47, 0x8e, 0xd0, 0x9b, 0xec, 0x54, 0x35, 0x2c, 0xea,
0x3a, 0x63, 0xbe, 0xc3, 0x8a, 0xe2, 0xe8, 0xc4, 0xc4, 0xb0, 0x3a, 0xae, 0x33, 0xc6, 0x31, 0x16,
0x3d, 0x82, 0xb2, 0x49, 0xdd, 0xc0, 0x0e, 0x42, 0xe2, 0x9a, 0xe3, 0xe5, 0x22, 0x57, 0xea, 0xf6,
0xc5, 0x4a, 0x35, 0x26, 0xc4, 0x38, 0xc9, 0x89, 0x36, 0xa1, 0xb2, 0x6b, 0xbb, 0x96, 0x4e, 0x3d,
0x71, 0xa2, 0xe5, 0x2f, 0xde, 0xd8, 0x42, 0x52, 0xdd, 0x76, 0xad, 0x8e, 0x20, 0xc6, 0xe5, 0xdd,
0xc9, 0x00, 0xb5, 0x61, 0xe1, 0x90, 0x3a, 0xa3, 0x21, 0x89, 0x65, 0x15, 0xb8, 0xac, 0x37, 0x2e,
0x96, 0xf5, 0x84, 0xd3, 0x47, 0xd2, 0xe6, 0x0f, 0x93, 0x43, 0xf4, 0x18, 0xe6, 0xc3, 0xa1, 0xb7,
0x17, 0xc4, 0xe2, 0xe6, 0xb8, 0xb8, 0x2f, 0x5f, 0x62, 0x79, 0x46, 0x1e, 0x49, 0xab, 0x84, 0x89,
0x51, 0xf5, 0xfb, 0xb3, 0x50, 0x4e, 0x68, 0x8e, 0x7a, 0x50, 0xf6, 0x7c, 0xea, 0x19, 0x03, 0x7e,
0x2a, 0xcb, 0x45, 0xbd, 0xf7, 0xb9, 0x66, 0xbd, 0xde, 0x9d, 0x30, 0xe2, 0xa4, 0x14, 0xf4, 0x0e,
0x54, 0x5c, 0xea, 0xfa, 0xc4, 0x1c, 0xf9, 0x81, 0x7d, 0x28, 0x16, 0xbd, 0x58, 0x57, 0xce, 0x4e,
0x57, 0x2b, 0x6d, 0xea, 0xe2, 0x08, 0x8e, 0xcf, 0x51, 0xa9, 0x27, 0x59, 0x28, 0x27, 0x44, 0xa2,
0xb7, 0xa0, 0x88, 0xbb, 0xb8, 0xf5, 0xa4, 0xd6, 0xd7, 0x94, 0x99, 0xea, 0xad, 0xe3, 0x93, 0xb5,
0x65, 0xae, 0x43, 0xf2, 0xb3, 0x5d, 0xdf, 0x3e, 0x64, 0x9e, 0xff, 0x26, 0xcc, 0x45, 0xa4, 0x99,
0xea, 0xcb, 0xc7, 0x27, 0x6b, 0x2f, 0x4d, 0x93, 0x26, 0x28, 0x71, 0x6f, 0xb3, 0x86, 0xb5, 0xa6,
0x92, 0x4d, 0xa7, 0xc4, 0xbd, 0x7d, 0xc3, 0x27, 0x16, 0xfa, 0x32, 0x14, 0x24, 0xe1, 0x6c, 0xb5,
0x7a, 0x7c, 0xb2, 0x76, 0x63, 0x9a, 0x70, 0x42, 0x87, 0x7b, 0x5b, 0xb5, 0x27, 0x9a, 0x92, 0x4b,
0xa7, 0xc3, 0x3d, 0xc7, 0x38, 0x24, 0xe8, 0x75, 0xc8, 0x0b, 0xb2, 0x7c, 0xf5, 0xe6, 0xf1, 0xc9,
0xda, 0x97, 0x5e, 0x10, 0xc7, 0xa8, 0xaa, 0xcb, 0xbf, 0xfd, 0x87, 0x2b, 0x33, 0x7f, 0xf1, 0x47,
0x2b, 0xca, 0x34, 0xba, 0xfa, 0xbf, 0x19, 0x98, 0x3f, 0xe7, 0x28, 0x48, 0x85, 0x82, 0x4b, 0x4d,
0xea, 0x89, 0xc3, 0xb5, 0x58, 0x87, 0xb3, 0xd3, 0xd5, 0x42, 0x9b, 0x36, 0xa8, 0x37, 0xc6, 0x12,
0x83, 0x1e, 0x4f, 0xa5, 0x07, 0x0f, 0x3e, 0xa7, 0x17, 0xa6, 0x26, 0x08, 0x1f, 0xc1, 0xbc, 0xe5,
0xdb, 0x87, 0xc4, 0xd7, 0x4d, 0xea, 0xee, 0xd9, 0x03, 0x79, 0x70, 0x56, 0x53, 0x33, 0x69, 0x4e,
0x88, 0x2b, 0x82, 0xa1, 0xc1, 0xe9, 0x7f, 0x86, 0xd4, 0xa0, 0xea, 0x41, 0x25, 0xe9, 0xd7, 0xec,
0x34, 0x0b, 0xec, 0x5f, 0x25, 0x32, 0x7f, 0xe4, 0x09, 0x36, 0x2e, 0x31, 0x88, 0x48, 0x11, 0xdf,
0x80, 0xdc, 0x90, 0x5a, 0x42, 0xce, 0x7c, 0xfd, 0x3a, 0xcb, 0x50, 0xfe, 0xe9, 0x74, 0xb5, 0x4c,
0x83, 0xf5, 0x0d, 0xdb, 0x21, 0xdb, 0xd4, 0x22, 0x98, 0x13, 0xb0, 0x58, 0x1b, 0x6d, 0x2c, 0x79,
0x1a, 0xc8, 0xa1, 0xfa, 0xbd, 0x0c, 0xe4, 0x58, 0x10, 0x43, 0x2f, 0x43, 0xae, 0xde, 0x6a, 0x37,
0x95, 0x99, 0xea, 0xb5, 0xe3, 0x93, 0xb5, 0x79, 0x6e, 0x2d, 0x86, 0x60, 0x9b, 0x01, 0xad, 0x42,
0xe1, 0x49, 0x67, 0x6b, 0x67, 0x9b, 0x79, 0xde, 0xf5, 0xe3, 0x93, 0xb5, 0xc5, 0x18, 0x2d, 0xec,
0x89, 0x5e, 0x81, 0x7c, 0x7f, 0xbb, 0xbb, 0xd1, 0x53, 0xb2, 0x55, 0x74, 0x7c, 0xb2, 0xb6, 0x10,
0xe3, 0xf9, 0x74, 0xd0, 0xab, 0x90, 0x6f, 0x77, 0x5b, 0x5d, 0x4d, 0x99, 0xad, 0xde, 0x38, 0x3e,
0x59, 0x43, 0x31, 0x9a, 0x57, 0x3a, 0x5d, 0xdb, 0x23, 0xd5, 0x6b, 0xd2, 0x27, 0x4a, 0x31, 0x4e,
0xfd, 0x51, 0x06, 0xca, 0x89, 0x58, 0xc6, 0xdc, 0xba, 0xa9, 0x6d, 0xd4, 0x76, 0xb6, 0xfa, 0xca,
0x4c, 0xc2, 0xad, 0x13, 0x24, 0x4d, 0xb2, 0x67, 0x8c, 0x1c, 0x16, 0x5b, 0xa1, 0xd1, 0x69, 0xf7,
0x5a, 0xbd, 0xbe, 0xd6, 0xee, 0x2b, 0x99, 0xea, 0xf2, 0xf1, 0xc9, 0xda, 0xd2, 0x34, 0xf1, 0xc6,
0xc8, 0x71, 0x98, 0x63, 0x37, 0x6a, 0x8d, 0x4d, 0xbe, 0x53, 0x26, 0x8e, 0x9d, 0xa0, 0x6a, 0x18,
0xe6, 0x3e, 0xb1, 0xd0, 0xdb, 0x50, 0x6a, 0x6a, 0x5b, 0xda, 0xa3, 0x1a, 0x3f, 0x51, 0xaa, 0xaf,
0x1c, 0x9f, 0xac, 0xdd, 0x7c, 0xf1, 0xeb, 0x0e, 0x19, 0x18, 0x21, 0xb1, 0xa6, 0x1c, 0x3c, 0x41,
0xa2, 0xfe, 0x77, 0x16, 0xe6, 0x31, 0x09, 0x42, 0xc3, 0x0f, 0xbb, 0xd4, 0xb1, 0xcd, 0x31, 0xea,
0x42, 0xc9, 0xa4, 0xae, 0x65, 0x27, 0x62, 0xd3, 0xfd, 0x0b, 0x92, 0xb4, 0x09, 0x57, 0x34, 0x6a,
0x44, 0x9c, 0x78, 0x22, 0x04, 0xdd, 0x81, 0xbc, 0x45, 0x1c, 0x63, 0x2c, 0xb3, 0xc5, 0x9b, 0x2f,
0x54, 0x0b, 0x4d, 0xd9, 0xa8, 0xc0, 0x82, 0x8e, 0xd7, 0x66, 0xc6, 0x73, 0xdd, 0x08, 0x43, 0x32,
0xf4, 0x42, 0xe1, 0x23, 0x39, 0x5c, 0x1e, 0x1a, 0xcf, 0x6b, 0x12, 0x84, 0xee, 0x41, 0xe1, 0xc8,
0x76, 0x2d, 0x7a, 0x24, 0xb3, 0xc1, 0x4b, 0x84, 0x4a, 0x42, 0xf5, 0x98, 0xa5, 0x41, 0x53, 0x6a,
0x32, 0x37, 0x6b, 0x77, 0xda, 0x5a, 0xe4, 0x66, 0x12, 0xdf, 0x71, 0xdb, 0xd4, 0x65, 0xd1, 0x03,
0x3a, 0x6d, 0x7d, 0xa3, 0xd6, 0xda, 0xda, 0xc1, 0xcc, 0xd5, 0x96, 0x8e, 0x4f, 0xd6, 0x94, 0x98,
0x64, 0xc3, 0xb0, 0x1d, 0x56, 0x9e, 0xdc, 0x84, 0xd9, 0x5a, 0xfb, 0x5b, 0x4a, 0xb6, 0xaa, 0x1c,
0x9f, 0xac, 0x55, 0x62, 0x74, 0xcd, 0x1d, 0x4f, 0xec, 0x3e, 0xfd, 0x5d, 0xf5, 0x6f, 0x67, 0xa1,
0xb2, 0xe3, 0x59, 0x46, 0x48, 0xc4, 0x2e, 0x45, 0x6b, 0x50, 0xf6, 0x0c, 0xdf, 0x70, 0x1c, 0xe2,
0xd8, 0xc1, 0x50, 0xb6, 0x58, 0x92, 0x20, 0xf4, 0xde, 0xe7, 0x35, 0x63, 0xbd, 0xc8, 0x76, 0xde,
0x77, 0xff, 0x75, 0x35, 0x13, 0x19, 0x74, 0x07, 0x16, 0xf6, 0x84, 0xb6, 0xba, 0x61, 0xf2, 0x85,
0x9d, 0xe5, 0x0b, 0xbb, 0x9e, 0xb6, 0xb0, 0x49, 0xb5, 0xd6, 0xe5, 0x24, 0x6b, 0x9c, 0x0b, 0xcf,
0xef, 0x25, 0x87, 0xe8, 0x01, 0xcc, 0x0d, 0xa9, 0x6b, 0x87, 0xd4, 0xbf, 0x7a, 0x15, 0x22, 0x4a,
0xf4, 0x16, 0x5c, 0x63, 0x8b, 0x1b, 0xe9, 0xc3, 0xd1, 0xfc, 0xe4, 0xcf, 0xe2, 0xc5, 0xa1, 0xf1,
0x5c, 0x7e, 0x10, 0x33, 0x30, 0xaa, 0x43, 0x9e, 0xfa, 0x2c, 0x47, 0x2d, 0x70, 0x75, 0xdf, 0xbe,
0x52, 0x5d, 0x31, 0xe8, 0x30, 0x1e, 0x2c, 0x58, 0xd5, 0x77, 0x61, 0xfe, 0xdc, 0x24, 0x58, 0x6a,
0xd6, 0xad, 0xed, 0xf4, 0x34, 0x65, 0x06, 0x55, 0xa0, 0xd8, 0xe8, 0xb4, 0xfb, 0xad, 0xf6, 0x0e,
0xcb, 0x2d, 0x2b, 0x50, 0xc4, 0x9d, 0xad, 0xad, 0x7a, 0xad, 0xf1, 0x58, 0xc9, 0xaa, 0xeb, 0x50,
0x4e, 0x48, 0x43, 0x0b, 0x00, 0xbd, 0x7e, 0xa7, 0xab, 0x6f, 0xb4, 0x70, 0xaf, 0x2f, 0x32, 0xd3,
0x5e, 0xbf, 0x86, 0xfb, 0x12, 0x90, 0x51, 0xff, 0x33, 0x1b, 0xad, 0xa8, 0x4c, 0x46, 0xeb, 0xe7,
0x93, 0xd1, 0x4b, 0x94, 0x97, 0xe9, 0xe8, 0x64, 0x10, 0x27, 0xa5, 0xef, 0x01, 0x70, 0xc7, 0x21,
0x96, 0x6e, 0x84, 0x72, 0xe1, 0xab, 0x2f, 0x18, 0xb9, 0x1f, 0x75, 0x02, 0x71, 0x49, 0x52, 0xd7,
0x42, 0xf4, 0x21, 0x54, 0x4c, 0x3a, 0xf4, 0x1c, 0x22, 0x99, 0x67, 0xaf, 0x64, 0x2e, 0xc7, 0xf4,
0xb5, 0x30, 0x99, 0x0e, 0xe7, 0xce, 0x27, 0xec, 0xbf, 0x99, 0x89, 0x2c, 0x93, 0x92, 0x01, 0x57,
0xa0, 0xb8, 0xd3, 0x6d, 0xd6, 0xfa, 0xad, 0xf6, 0x23, 0x25, 0x83, 0x00, 0x0a, 0xdc, 0xd4, 0x4d,
0x25, 0xcb, 0x32, 0xf7, 0x46, 0x67, 0xbb, 0xbb, 0xa5, 0xf1, 0x88, 0x85, 0x96, 0x40, 0x89, 0x8c,
0xad, 0x73, 0x43, 0x6a, 0x4d, 0x25, 0x87, 0xae, 0xc3, 0x62, 0x0c, 0x95, 0x9c, 0x79, 0x74, 0x03,
0x50, 0x0c, 0x9c, 0x88, 0x28, 0xa8, 0xbf, 0x0e, 0x8b, 0x0d, 0xea, 0x86, 0x86, 0xed, 0xc6, 0x55,
0xcd, 0x7d, 0x36, 0x69, 0x09, 0xd2, 0x6d, 0xd9, 0x21, 0xab, 0x2f, 0x9e, 0x9d, 0xae, 0x96, 0x63,
0xd2, 0x56, 0x93, 0x67, 0xa1, 0x72, 0x60, 0xb1, 0xfd, 0xeb, 0xd9, 0x16, 0x37, 0x6e, 0xbe, 0x3e,
0x77, 0x76, 0xba, 0x3a, 0xdb, 0x6d, 0x35, 0x31, 0x83, 0xa1, 0x97, 0xa1, 0x44, 0x9e, 0xdb, 0xa1,
0x6e, 0xb2, 0x53, 0x8d, 0x19, 0x30, 0x8f, 0x8b, 0x0c, 0xd0, 0xa0, 0x16, 0x51, 0xeb, 0x00, 0x5d,
0xea, 0x87, 0xf2, 0xcb, 0xef, 0x40, 0xde, 0xa3, 0x3e, 0xef, 0xe9, 0x5c, 0xd8, 0x69, 0x64, 0xe4,
0xc2, 0x51, 0xb1, 0x20, 0x56, 0xbf, 0x37, 0x0b, 0xd0, 0x37, 0x82, 0x03, 0x29, 0xe4, 0x21, 0x94,
0xe2, 0xae, 0xae, 0x6c, 0x0e, 0x5d, 0xba, 0xda, 0x31, 0x31, 0x7a, 0x10, 0x39, 0x9b, 0xa8, 0xd7,
0x52, 0xcb, 0xea, 0xe8, 0x43, 0x69, 0x25, 0xcf, 0xf9, 0xa2, 0x8c, 0x25, 0x09, 0xc4, 0xf7, 0xe5,
0xca, 0xb3, 0x9f, 0xa8, 0xc1, 0x8f, 0x05, 0x61, 0x34, 0x99, 0xa8, 0xa7, 0xb6, 0xc3, 0xa6, 0x56,
0x64, 0x73, 0x06, 0x4f, 0xf8, 0xd0, 0x47, 0x50, 0x66, 0xf3, 0xd6, 0x03, 0x8e, 0x93, 0x39, 0xfa,
0x85, 0xa6, 0x12, 0x12, 0x30, 0x78, 0x13, 0x2b, 0xbf, 0x02, 0x60, 0x78, 0x9e, 0x63, 0x13, 0x4b,
0xdf, 0x1d, 0xf3, 0xa4, 0xbc, 0x84, 0x4b, 0x12, 0x52, 0x1f, 0xb3, 0xed, 0x12, 0xa1, 0x8d, 0x90,
0x17, 0x26, 0x57, 0x18, 0x50, 0x52, 0xd7, 0xc2, 0xba, 0x02, 0x0b, 0xfe, 0xc8, 0x65, 0x06, 0x95,
0xda, 0xa9, 0x7f, 0x92, 0x85, 0x97, 0xda, 0x24, 0x3c, 0xa2, 0xfe, 0x41, 0x2d, 0x0c, 0x0d, 0x73,
0x7f, 0x48, 0x5c, 0xb9, 0x7c, 0x89, 0x22, 0x2a, 0x73, 0xae, 0x88, 0x5a, 0x86, 0x39, 0xc3, 0xb1,
0x8d, 0x80, 0x88, 0xd4, 0xaf, 0x84, 0xa3, 0x21, 0x2b, 0xf5, 0x58, 0xe1, 0x48, 0x82, 0x80, 0x88,
0x4e, 0x0f, 0x53, 0x3c, 0x02, 0xa0, 0x6f, 0xc3, 0x0d, 0x99, 0xe4, 0x19, 0xf1, 0xa7, 0x58, 0xed,
0x11, 0x35, 0xae, 0xb5, 0xd4, 0x4a, 0x36, 0x5d, 0x39, 0x99, 0x05, 0x4e, 0xc0, 0x1d, 0x2f, 0x94,
0x39, 0xe5, 0x92, 0x95, 0x82, 0xaa, 0x3e, 0x82, 0x9b, 0x17, 0xb2, 0x7c, 0xa1, 0x4e, 0xd2, 0xdf,
0x67, 0x01, 0x5a, 0xdd, 0xda, 0xb6, 0x34, 0x52, 0x13, 0x0a, 0x7b, 0xc6, 0xd0, 0x76, 0xc6, 0x97,
0x45, 0xc0, 0x09, 0xfd, 0x7a, 0x4d, 0x98, 0x63, 0x83, 0xf3, 0x60, 0xc9, 0xcb, 0xeb, 0xd8, 0xd1,
0xae, 0x4b, 0xc2, 0xb8, 0x8e, 0xe5, 0x23, 0xa6, 0x86, 0x6f, 0xb8, 0xb1, 0xeb, 0x8a, 0x01, 0x5b,
0x00, 0x96, 0xf2, 0x1c, 0x19, 0xe3, 0x28, 0x6c, 0xc9, 0x21, 0xda, 0xe4, 0x5d, 0x63, 0xe2, 0x1f,
0x12, 0x6b, 0x39, 0xcf, 0x8d, 0x7a, 0x95, 0x3e, 0x58, 0x92, 0x0b, 0xdb, 0xc5, 0xdc, 0xd5, 0x0f,
0x78, 0xca, 0x34, 0x41, 0x7d, 0x21, 0x1b, 0xdd, 0x85, 0xf9, 0x73, 0xf3, 0x7c, 0xa1, 0x81, 0xd0,
0xea, 0x3e, 0x79, 0x47, 0xc9, 0xc9, 0x5f, 0xef, 0x2a, 0x05, 0xf5, 0xaf, 0x67, 0x45, 0xa0, 0x91,
0x56, 0x4d, 0xbf, 0x2d, 0x29, 0x72, 0xef, 0x36, 0xa9, 0x23, 0x03, 0xc0, 0x1b, 0x97, 0xc7, 0x1f,
0x56, 0x47, 0x72, 0x72, 0x1c, 0x33, 0xa2, 0x55, 0x28, 0x0b, 0x2f, 0xd6, 0xd9, 0x86, 0xe3, 0x66,
0x9d, 0xc7, 0x20, 0x40, 0x8c, 0x13, 0xdd, 0x86, 0x05, 0xde, 0x70, 0x0a, 0xf6, 0x89, 0x25, 0x68,
0x72, 0x9c, 0x66, 0x3e, 0x86, 0x72, 0xb2, 0x6d, 0xa8, 0x48, 0x80, 0xce, 0xab, 0x81, 0x3c, 0x57,
0xe8, 0xad, 0xab, 0x14, 0x12, 0x2c, 0xbc, 0x48, 0x28, 0x7b, 0x93, 0x81, 0xfa, 0xcb, 0x50, 0x8c,
0x94, 0x45, 0xcb, 0x30, 0xdb, 0x6f, 0x74, 0x95, 0x99, 0xea, 0xe2, 0xf1, 0xc9, 0x5a, 0x39, 0x02,
0xf7, 0x1b, 0x5d, 0x86, 0xd9, 0x69, 0x76, 0x95, 0xcc, 0x79, 0xcc, 0x4e, 0xb3, 0x8b, 0xaa, 0x90,
0xeb, 0x35, 0xfa, 0xdd, 0x28, 0x3f, 0x8b, 0x50, 0x0c, 0x56, 0xcd, 0xb1, 0xfc, 0x4c, 0xdd, 0x83,
0x72, 0xe2, 0xeb, 0xe8, 0x35, 0x98, 0x6b, 0xb5, 0x1f, 0x61, 0xad, 0xd7, 0x53, 0x66, 0x44, 0x79,
0x90, 0xc0, 0xb6, 0xdc, 0x01, 0x5b, 0x3b, 0xf4, 0x0a, 0xe4, 0x36, 0x3b, 0xec, 0xdc, 0x17, 0xf5,
0x47, 0x82, 0x62, 0x93, 0x06, 0x61, 0xf5, 0xba, 0x4c, 0xfc, 0x92, 0x82, 0xd5, 0xdf, 0xcf, 0x40,
0x41, 0x6c, 0xb4, 0xd4, 0x45, 0xac, 0x4d, 0x8a, 0x22, 0x51, 0x36, 0xbe, 0x71, 0x71, 0x89, 0xb7,
0x2e, 0x2b, 0x32, 0xe1, 0x9a, 0x11, 0x5f, 0xf5, 0x7d, 0xa8, 0x24, 0x11, 0x5f, 0xc8, 0x31, 0xbf,
0x0d, 0x65, 0xe6, 0xfb, 0x51, 0xa9, 0x77, 0x1f, 0x0a, 0x22, 0x58, 0xc4, 0xe7, 0xd0, 0xc5, 0xf5,
0xa6, 0xa4, 0x44, 0x0f, 0x61, 0x4e, 0xd4, 0xa8, 0x51, 0x2f, 0x7b, 0xe5, 0xf2, 0x1d, 0x86, 0x23,
0x72, 0xf5, 0x23, 0xc8, 0x75, 0x09, 0xf1, 0x99, 0xed, 0x5d, 0x6a, 0x91, 0xc9, 0xd1, 0x2d, 0xcb,
0x6b, 0x8b, 0xb4, 0x9a, 0xac, 0xbc, 0xb6, 0x48, 0xcb, 0x8a, 0xfb, 0x71, 0xd9, 0x44, 0x3f, 0xae,
0x0f, 0x95, 0xa7, 0xc4, 0x1e, 0xec, 0x87, 0xc4, 0xe2, 0x82, 0xde, 0x86, 0x9c, 0x47, 0x62, 0xe5,
0x97, 0x53, 0x9d, 0x8f, 0x10, 0x1f, 0x73, 0x2a, 0x16, 0x63, 0x8e, 0x38, 0xb7, 0xbc, 0x06, 0x92,
0x23, 0xf5, 0xef, 0xb2, 0xb0, 0xd0, 0x0a, 0x82, 0x91, 0xe1, 0x9a, 0x51, 0x56, 0xf7, 0xf5, 0xf3,
0x59, 0x5d, 0xea, 0x7d, 0xd9, 0x79, 0x96, 0xf3, 0x6d, 0x46, 0x79, 0xb2, 0x66, 0xe3, 0x93, 0x55,
0xfd, 0x8f, 0x4c, 0xd4, 0x4b, 0xbc, 0x9d, 0x08, 0x05, 0xa2, 0x46, 0x4c, 0x4a, 0x22, 0x3b, 0xee,
0x81, 0x4b, 0x8f, 0x5c, 0x56, 0xbd, 0x62, 0xad, 0xad, 0x3d, 0x55, 0x32, 0xc2, 0x3d, 0xcf, 0x11,
0x61, 0xe2, 0x92, 0x23, 0x26, 0xa9, 0xab, 0xb5, 0x9b, 0x2c, 0x0b, 0xcb, 0xa6, 0x48, 0xea, 0x12,
0xd7, 0xb2, 0xdd, 0x01, 0x7a, 0x0d, 0x0a, 0xad, 0x5e, 0x6f, 0x87, 0x97, 0x90, 0x2f, 0x1d, 0x9f,
0xac, 0x5d, 0x3f, 0x47, 0xc5, 0xfb, 0xc8, 0x16, 0x23, 0x62, 0x25, 0x10, 0xcb, 0xcf, 0x52, 0x88,
0x58, 0x6e, 0x2d, 0x88, 0x70, 0xa7, 0x5f, 0xeb, 0x6b, 0x4a, 0x3e, 0x85, 0x08, 0x53, 0xf6, 0x57,
0x6e, 0xb7, 0x7f, 0xce, 0x82, 0x52, 0x33, 0x4d, 0xe2, 0x85, 0x0c, 0x2f, 0xab, 0xce, 0x3e, 0x14,
0x3d, 0xf6, 0xcb, 0x26, 0x51, 0x06, 0xf5, 0x30, 0xf5, 0xc6, 0x77, 0x8a, 0x6f, 0x1d, 0x53, 0x87,
0xd4, 0xac, 0xa1, 0x1d, 0x04, 0x36, 0x75, 0x05, 0x0c, 0xc7, 0x92, 0xaa, 0xff, 0x95, 0x81, 0xeb,
0x29, 0x14, 0xe8, 0x2e, 0xe4, 0x7c, 0xea, 0x44, 0x6b, 0x78, 0xeb, 0xa2, 0x36, 0x31, 0x63, 0xc5,
0x9c, 0x12, 0xad, 0x00, 0x18, 0xa3, 0x90, 0x1a, 0xfc, 0xfb, 0xa2, 0xb9, 0x86, 0x13, 0x10, 0xf4,
0x14, 0x0a, 0x01, 0x31, 0x7d, 0x12, 0xe5, 0xd9, 0x1f, 0xfd, 0xb4, 0xda, 0xaf, 0xf7, 0xb8, 0x18,
0x2c, 0xc5, 0x55, 0xd7, 0xa1, 0x20, 0x20, 0xcc, 0xed, 0x2d, 0x23, 0x34, 0xe4, 0x25, 0x02, 0xff,
0xcd, 0xbc, 0xc9, 0x70, 0x06, 0x91, 0x37, 0x19, 0xce, 0x40, 0xfd, 0xab, 0x2c, 0x80, 0xf6, 0x3c,
0x24, 0xbe, 0x6b, 0x38, 0x8d, 0x1a, 0xd2, 0x12, 0x27, 0x83, 0x98, 0xed, 0x57, 0x52, 0xef, 0x4d,
0x62, 0x8e, 0xf5, 0x46, 0x2d, 0xe5, 0x6c, 0xb8, 0x09, 0xb3, 0x23, 0x5f, 0x5e, 0xe2, 0x8b, 0x1c,
0x79, 0x07, 0x6f, 0x61, 0x06, 0x43, 0x5a, 0xb2, 0x97, 0x73, 0xe1, 0x55, 0x7d, 0xe2, 0x03, 0xa9,
0xa1, 0x8b, 0xed, 0x7c, 0xd3, 0xd0, 0x4d, 0x22, 0x4f, 0x95, 0x8a, 0xd8, 0xf9, 0x8d, 0x5a, 0x83,
0xf8, 0x21, 0x2e, 0x98, 0x06, 0xfb, 0xff, 0x33, 0xc5, 0xb7, 0xb7, 0x01, 0x26, 0x53, 0x43, 0x2b,
0x90, 0x6f, 0x6c, 0xf4, 0x7a, 0x5b, 0xca, 0x8c, 0x08, 0xe0, 0x13, 0x14, 0x07, 0xab, 0x7f, 0x9e,
0x85, 0x62, 0xa3, 0x26, 0x8f, 0xdc, 0x06, 0x28, 0x3c, 0x2a, 0xf1, 0xab, 0x17, 0xf2, 0xdc, 0xb3,
0xfd, 0xb1, 0x0c, 0x2c, 0x97, 0x14, 0xbc, 0x0b, 0x8c, 0x85, 0x69, 0xad, 0x71, 0x06, 0x84, 0xa1,
0x42, 0xa4, 0x11, 0x74, 0xd3, 0x88, 0x62, 0xfc, 0xca, 0xe5, 0xc6, 0x12, 0xa5, 0xcb, 0x64, 0x1c,
0xe0, 0x72, 0x24, 0xa4, 0x61, 0x04, 0xe8, 0x3d, 0x58, 0x0c, 0xec, 0x81, 0x6b, 0xbb, 0x03, 0x3d,
0x32, 0x1e, 0xbf, 0x07, 0xaa, 0x5f, 0x3b, 0x3b, 0x5d, 0x9d, 0xef, 0x09, 0x94, 0xb4, 0xe1, 0xbc,
0xa4, 0x6c, 0x70, 0x53, 0xa2, 0x77, 0x61, 0x21, 0xc1, 0xca, 0xac, 0x28, 0xcc, 0xce, 0x3b, 0xc6,
0x31, 0xe7, 0x63, 0x32, 0xc6, 0x95, 0x98, 0xf1, 0x31, 0xe1, 0xbd, 0x99, 0x3d, 0xea, 0x9b, 0x44,
0xf7, 0xf9, 0x9e, 0xe6, 0xa7, 0x7b, 0x0e, 0x97, 0x39, 0x4c, 0x6c, 0x73, 0xf5, 0x09, 0x5c, 0xef,
0xf8, 0xe6, 0x3e, 0x09, 0x42, 0x61, 0x0a, 0x69, 0xc5, 0x8f, 0xe0, 0x56, 0x68, 0x04, 0x07, 0xfa,
0xbe, 0x1d, 0x84, 0xd4, 0x1f, 0xeb, 0x3e, 0x09, 0x89, 0xcb, 0xf0, 0x3a, 0xbf, 0xe0, 0x96, 0xed,
0xc4, 0x9b, 0x8c, 0x66, 0x53, 0x90, 0xe0, 0x88, 0x62, 0x8b, 0x11, 0xa8, 0x2d, 0xa8, 0xb0, 0x12,
0x46, 0x36, 0xd5, 0xd8, 0xec, 0xc1, 0xa1, 0x03, 0xfd, 0x73, 0x1f, 0x53, 0x25, 0x87, 0x0e, 0xc4,
0x4f, 0xf5, 0x9b, 0xa0, 0x34, 0xed, 0xc0, 0x33, 0x42, 0x73, 0x3f, 0xea, 0x93, 0xa2, 0x26, 0x28,
0xfb, 0xc4, 0xf0, 0xc3, 0x5d, 0x62, 0x84, 0xba, 0x47, 0x7c, 0x9b, 0x5a, 0x57, 0xaf, 0xf2, 0x62,
0xcc, 0xd2, 0xe5, 0x1c, 0xea, 0xff, 0x64, 0x00, 0xb0, 0xb1, 0x17, 0x65, 0x6b, 0x5f, 0x85, 0x6b,
0x81, 0x6b, 0x78, 0xc1, 0x3e, 0x0d, 0x75, 0xdb, 0x0d, 0x89, 0x7f, 0x68, 0x38, 0xb2, 0xb9, 0xa3,
0x44, 0x88, 0x96, 0x84, 0xa3, 0xb7, 0x01, 0x1d, 0x10, 0xe2, 0xe9, 0xd4, 0xb1, 0xf4, 0x08, 0x29,
0x2e, 0xbe, 0x73, 0x58, 0x61, 0x98, 0x8e, 0x63, 0xf5, 0x22, 0x38, 0xaa, 0xc3, 0x0a, 0x9b, 0x3e,
0x71, 0x43, 0xdf, 0x26, 0x81, 0xbe, 0x47, 0x7d, 0x3d, 0x70, 0xe8, 0x91, 0xbe, 0x47, 0x1d, 0x87,
0x1e, 0x11, 0x3f, 0xea, 0x9b, 0x55, 0x1d, 0x3a, 0xd0, 0x04, 0xd1, 0x06, 0xf5, 0x7b, 0x0e, 0x3d,
0xda, 0x88, 0x28, 0x58, 0x4a, 0x37, 0x99, 0x73, 0x68, 0x9b, 0x07, 0x51, 0x4a, 0x17, 0x43, 0xfb,
0xb6, 0x79, 0x80, 0x5e, 0x83, 0x79, 0xe2, 0x10, 0xde, 0x3e, 0x11, 0x54, 0x79, 0x4e, 0x55, 0x89,
0x80, 0x8c, 0x48, 0xfd, 0x18, 0x14, 0xcd, 0x35, 0xfd, 0xb1, 0x97, 0x58, 0xf3, 0xb7, 0x01, 0xb1,
0x20, 0xa9, 0x3b, 0xd4, 0x3c, 0xd0, 0x87, 0x86, 0x6b, 0x0c, 0x98, 0x5e, 0xe2, 0xc6, 0x51, 0x61,
0x98, 0x2d, 0x6a, 0x1e, 0x6c, 0x4b, 0xb8, 0xfa, 0x1e, 0x40, 0xcf, 0xf3, 0x89, 0x61, 0x75, 0x58,
0x36, 0xc1, 0x4c, 0xc7, 0x47, 0xba, 0x25, 0xef, 0x73, 0xa9, 0x2f, 0xb7, 0xba, 0x22, 0x10, 0xcd,
0x18, 0xae, 0xfe, 0x22, 0x5c, 0xef, 0x3a, 0x86, 0xc9, 0x5f, 0x58, 0x74, 0xe3, 0x2b, 0x34, 0xf4,
0x10, 0x0a, 0x82, 0x54, 0xae, 0x64, 0xea, 0x76, 0x9b, 0x7c, 0x73, 0x73, 0x06, 0x4b, 0xfa, 0x7a,
0x05, 0x60, 0x22, 0x47, 0xfd, 0xc7, 0x0c, 0x94, 0x62, 0xf9, 0x68, 0x4d, 0x5c, 0x80, 0x85, 0xbe,
0x61, 0xbb, 0xb2, 0xe2, 0x2f, 0xe1, 0x24, 0x08, 0xb5, 0xa0, 0xec, 0xc5, 0xdc, 0x97, 0xe6, 0x73,
0x29, 0x5a, 0xe3, 0x24, 0x2f, 0x7a, 0x1f, 0x4a, 0xd1, 0x05, 0x7a, 0x14, 0x61, 0x2f, 0xbf, 0x6f,
0x9f, 0x90, 0x47, 0x8d, 0x54, 0x9f, 0x78, 0x8e, 0xcd, 0x62, 0x4e, 0x2e, 0x6e, 0xa4, 0x62, 0x09,
0x52, 0xbf, 0x0e, 0xf0, 0x0d, 0x6a, 0xbb, 0x7d, 0x7a, 0x40, 0x5c, 0x7e, 0x2b, 0xcc, 0x4a, 0x4a,
0x12, 0x19, 0x5a, 0x8e, 0x78, 0xa7, 0x40, 0xac, 0x52, 0x7c, 0x39, 0x2a, 0x86, 0xea, 0x5f, 0x66,
0xa1, 0x80, 0x29, 0x0d, 0x1b, 0x35, 0xb4, 0x06, 0x05, 0x19, 0x4a, 0xf8, 0x11, 0x55, 0x2f, 0x9d,
0x9d, 0xae, 0xe6, 0x45, 0x0c, 0xc9, 0x9b, 0x3c, 0x78, 0x24, 0x82, 0x7c, 0xf6, 0xa2, 0x20, 0x8f,
0xee, 0x42, 0x45, 0x12, 0xe9, 0xfb, 0x46, 0xb0, 0x2f, 0xea, 0xbb, 0xfa, 0xc2, 0xd9, 0xe9, 0x2a,
0x08, 0xca, 0x4d, 0x23, 0xd8, 0xc7, 0x20, 0xa8, 0xd9, 0x6f, 0xa4, 0x41, 0xf9, 0x19, 0xb5, 0x5d,
0x3d, 0xe4, 0x93, 0x90, 0xbd, 0xc8, 0xd4, 0xa5, 0x9e, 0x4c, 0x55, 0x3e, 0xa0, 0x80, 0x67, 0x93,
0xc9, 0x6b, 0x30, 0xef, 0x53, 0x1a, 0x8a, 0xc8, 0x66, 0x53, 0x57, 0xb6, 0x39, 0xd6, 0x52, 0xbb,
0xdf, 0x94, 0x86, 0x58, 0xd2, 0xe1, 0x8a, 0x9f, 0x18, 0xa1, 0xbb, 0xb0, 0xe4, 0x18, 0x41, 0xa8,
0xf3, 0x90, 0x68, 0x4d, 0xa4, 0x15, 0xb8, 0xf1, 0x11, 0xc3, 0x6d, 0x70, 0x54, 0xc4, 0xa1, 0xfe,
0x43, 0x06, 0xca, 0x6c, 0x32, 0xf6, 0x9e, 0x6d, 0xb2, 0x3c, 0xf0, 0x8b, 0xa7, 0x27, 0x37, 0x61,
0xd6, 0x0c, 0x7c, 0x69, 0x54, 0x7e, 0x3e, 0x37, 0x7a, 0x18, 0x33, 0x18, 0xfa, 0x18, 0x0a, 0xb2,
0xdd, 0x22, 0x32, 0x13, 0xf5, 0xea, 0x8c, 0x55, 0xda, 0x46, 0xf2, 0x71, 0x77, 0x9f, 0x68, 0x27,
0xce, 0x09, 0x9c, 0x04, 0xa1, 0x1b, 0x90, 0x35, 0x85, 0xb9, 0xe4, 0x0b, 0x9d, 0x46, 0x1b, 0x67,
0x4d, 0x57, 0xfd, 0x51, 0x06, 0xe6, 0x27, 0x31, 0x81, 0x79, 0xc0, 0x2d, 0x28, 0x05, 0xa3, 0xdd,
0x60, 0x1c, 0x84, 0x64, 0x18, 0xdd, 0x78, 0xc7, 0x00, 0xd4, 0x82, 0x92, 0xe1, 0x0c, 0xa8, 0x6f,
0x87, 0xfb, 0x43, 0x59, 0xc8, 0xa6, 0x67, 0x13, 0x49, 0x99, 0xeb, 0xb5, 0x88, 0x05, 0x4f, 0xb8,
0xa3, 0xd4, 0x40, 0x3c, 0x8b, 0xe0, 0xa9, 0xc1, 0xab, 0x50, 0x71, 0x8c, 0x21, 0xef, 0x3f, 0x85,
0xf6, 0x90, 0x44, 0x9b, 0x41, 0xc2, 0xfa, 0xf6, 0x90, 0xa8, 0x2a, 0x94, 0x62, 0x61, 0x68, 0x11,
0xca, 0x35, 0xad, 0xa7, 0xdf, 0xbb, 0xff, 0x50, 0x7f, 0xd4, 0xd8, 0x56, 0x66, 0x64, 0xfa, 0xfa,
0x67, 0x19, 0x98, 0x97, 0x11, 0x4b, 0x96, 0x04, 0xaf, 0xc1, 0x9c, 0x6f, 0xec, 0x85, 0x51, 0xd1,
0x92, 0x13, 0x5e, 0xcd, 0x0e, 0x01, 0x56, 0xb4, 0x30, 0x54, 0x7a, 0xd1, 0x92, 0x78, 0x83, 0x31,
0x7b, 0xe9, 0x1b, 0x8c, 0xdc, 0xff, 0xcb, 0x1b, 0x0c, 0xf5, 0x37, 0x00, 0x36, 0x6c, 0x87, 0xf4,
0x45, 0xab, 0x2a, 0xad, 0x04, 0x65, 0x69, 0x9e, 0x6c, 0x85, 0x46, 0x69, 0x5e, 0xab, 0x89, 0x19,
0x8c, 0xa1, 0x06, 0xb6, 0x25, 0x37, 0x23, 0x47, 0x3d, 0x62, 0xa8, 0x81, 0x6d, 0xc5, 0xd7, 0x7e,
0xb9, 0x2b, 0xae, 0xfd, 0xd4, 0x45, 0x98, 0xc7, 0xa2, 0xc7, 0x26, 0x74, 0x50, 0x4f, 0x32, 0xb0,
0x28, 0xf3, 0xdd, 0x38, 0x64, 0x7f, 0x05, 0x4a, 0x22, 0xf5, 0x9d, 0x14, 0x81, 0xfc, 0x21, 0x82,
0xa0, 0x6b, 0x35, 0x71, 0x51, 0xa0, 0x5b, 0x16, 0x5a, 0x85, 0xb2, 0x24, 0x4d, 0x3c, 0xef, 0x02,
0x01, 0x6a, 0xb3, 0xf9, 0xbc, 0x03, 0xb9, 0x3d, 0xdb, 0x21, 0xd2, 0xf3, 0x53, 0x23, 0xc2, 0xc4,
0x22, 0x9b, 0x33, 0x98, 0x53, 0xd7, 0x8b, 0x51, 0x73, 0x4f, 0xfd, 0x97, 0x0c, 0x6f, 0x31, 0xb3,
0x52, 0x35, 0xa9, 0x9f, 0xa8, 0x5a, 0xa7, 0xf4, 0x13, 0x74, 0x4c, 0x3f, 0x81, 0x16, 0xfa, 0x49,
0xd2, 0xa4, 0x7e, 0x02, 0xf4, 0xd3, 0xeb, 0x87, 0x3e, 0x84, 0x39, 0xd9, 0xaa, 0x94, 0xa1, 0xee,
0xd5, 0x54, 0xcf, 0x48, 0x5a, 0x7a, 0x73, 0x06, 0x47, 0x3c, 0x89, 0xe9, 0x6d, 0xc1, 0x8d, 0xba,
0x63, 0x98, 0x07, 0x8e, 0x1d, 0x84, 0xc4, 0x4a, 0x46, 0xa0, 0xfb, 0x50, 0x38, 0x97, 0xe7, 0x5e,
0xd6, 0x44, 0x95, 0x94, 0xea, 0xbf, 0x67, 0xa0, 0xb2, 0x49, 0x0c, 0x27, 0xdc, 0x9f, 0x74, 0xaa,
0x42, 0x12, 0x84, 0xf2, 0x7c, 0xe4, 0xbf, 0xd1, 0xd7, 0xa0, 0x18, 0xa7, 0x41, 0x57, 0x5e, 0x07,
0xc6, 0xa4, 0xe8, 0x01, 0xcc, 0x31, 0xdd, 0xe9, 0x28, 0xaa, 0xaf, 0x2e, 0xbb, 0x69, 0x92, 0x94,
0xec, 0xd0, 0xf2, 0x09, 0xcf, 0x7b, 0xb8, 0x9d, 0xf2, 0x38, 0x1a, 0xa2, 0x9f, 0x87, 0x0a, 0xbf,
0x28, 0x89, 0xd2, 0xbc, 0xfc, 0x55, 0x32, 0xcb, 0xe2, 0xae, 0x53, 0xa4, 0x78, 0x7f, 0x9c, 0x85,
0xa5, 0x6d, 0x63, 0xbc, 0x4b, 0x64, 0x18, 0x22, 0x16, 0x26, 0x26, 0xf5, 0x2d, 0xd4, 0x4d, 0x86,
0xaf, 0x4b, 0xae, 0x4e, 0xd3, 0x98, 0xd3, 0xa3, 0x58, 0x54, 0xf3, 0x65, 0x13, 0x35, 0xdf, 0x12,
0xe4, 0x5d, 0xea, 0x9a, 0x44, 0xc6, 0x36, 0x31, 0x50, 0xbf, 0x93, 0x49, 0xc6, 0xae, 0x6a, 0x7c,
0xad, 0xc9, 0x9b, 0x5e, 0x6d, 0x1a, 0xc6, 0x9f, 0x43, 0x1f, 0x43, 0xb5, 0xa7, 0x35, 0xb0, 0xd6,
0xaf, 0x77, 0xbe, 0xa9, 0xf7, 0x6a, 0x5b, 0xbd, 0xda, 0xfd, 0xbb, 0x7a, 0xb7, 0xb3, 0xf5, 0xad,
0x7b, 0x0f, 0xee, 0x7e, 0x4d, 0xc9, 0x54, 0xd7, 0x8e, 0x4f, 0xd6, 0x6e, 0xb5, 0x6b, 0x8d, 0x2d,
0xb1, 0xe3, 0x76, 0xe9, 0xf3, 0x9e, 0xe1, 0x04, 0xc6, 0xfd, 0xbb, 0x5d, 0xea, 0x8c, 0x19, 0x0d,
0xfa, 0x2a, 0xa0, 0x0d, 0x0d, 0xb7, 0xb5, 0xbe, 0x1e, 0x05, 0xc8, 0x46, 0xbd, 0xa1, 0x64, 0x45,
0x25, 0xb5, 0x41, 0x7c, 0x97, 0x84, 0x35, 0xad, 0x77, 0xef, 0xfe, 0xc3, 0x46, 0xbd, 0xc1, 0xf6,
0x78, 0x25, 0x79, 0x5a, 0x26, 0x93, 0x80, 0xcc, 0x85, 0x49, 0xc0, 0x24, 0x97, 0xc8, 0x5e, 0x90,
0x4b, 0x6c, 0xc0, 0x92, 0xe9, 0xd3, 0x20, 0xd0, 0x59, 0x79, 0x42, 0xac, 0xa9, 0x02, 0xe8, 0x4b,
0x67, 0xa7, 0xab, 0xd7, 0x1a, 0x0c, 0xdf, 0xe3, 0x68, 0x29, 0xfe, 0x9a, 0x99, 0x00, 0xf1, 0x2f,
0xa9, 0xdf, 0x9f, 0x65, 0x99, 0x9e, 0x7d, 0x68, 0x3b, 0x64, 0x40, 0x02, 0xf4, 0x04, 0x16, 0x4d,
0x9f, 0x58, 0xac, 0xee, 0x30, 0x9c, 0xe4, 0xcb, 0xe8, 0x9f, 0x4b, 0x4d, 0xba, 0x62, 0xc6, 0xf5,
0x46, 0xcc, 0xd5, 0xf3, 0x88, 0x89, 0x17, 0xcc, 0x73, 0x63, 0xf4, 0x0c, 0x16, 0x03, 0xe2, 0xd8,
0xee, 0xe8, 0xb9, 0x6e, 0x52, 0x37, 0x24, 0xcf, 0xa3, 0xeb, 0xbc, 0xab, 0xe4, 0xf6, 0xb4, 0x2d,
0xc6, 0xd5, 0x10, 0x4c, 0x75, 0x74, 0x76, 0xba, 0xba, 0x70, 0x1e, 0x86, 0x17, 0xa4, 0x64, 0x39,
0xae, 0xee, 0xc3, 0xc2, 0x79, 0x6d, 0xd0, 0x92, 0x0c, 0x34, 0x3c, 0x5e, 0xc5, 0x81, 0xe4, 0x16,
0x14, 0x7d, 0x32, 0xb0, 0x83, 0xd0, 0x17, 0x66, 0x66, 0x98, 0x18, 0x82, 0x96, 0xa1, 0x90, 0x78,
0x71, 0xc2, 0x70, 0x72, 0xcc, 0x22, 0x88, 0x78, 0x4c, 0x56, 0xfd, 0x35, 0x98, 0xd2, 0x85, 0x6d,
0x3a, 0xcb, 0x0e, 0x8c, 0x5d, 0xf9, 0xb1, 0x22, 0x8e, 0x86, 0xcc, 0x97, 0x47, 0x41, 0x9c, 0x40,
0xf2, 0xdf, 0x0c, 0xc6, 0x33, 0x1d, 0xf9, 0xb4, 0x8e, 0xe7, 0x32, 0xd1, 0x0b, 0xde, 0x5c, 0xe2,
0x05, 0xef, 0x12, 0xe4, 0x1d, 0x72, 0x48, 0x1c, 0x91, 0x63, 0x60, 0x31, 0xe0, 0x3e, 0xff, 0x0d,
0xba, 0x2b, 0x8f, 0xe1, 0x0d, 0x98, 0x7f, 0x46, 0x77, 0x75, 0x3b, 0x24, 0xfe, 0xe4, 0x61, 0x55,
0xf9, 0xfe, 0xcb, 0x69, 0xf6, 0x95, 0x0f, 0x79, 0x65, 0xa2, 0x53, 0x79, 0x46, 0x77, 0x5b, 0x11,
0x1b, 0xaa, 0xc1, 0x02, 0xcf, 0xdf, 0xc8, 0x73, 0x62, 0x8e, 0xb8, 0xa0, 0xab, 0xef, 0x5d, 0xe7,
0x19, 0x87, 0x16, 0x31, 0xbc, 0x75, 0x17, 0x2a, 0xd1, 0x1b, 0x56, 0xfe, 0x98, 0xa5, 0x08, 0xb9,
0x7e, 0xad, 0xf7, 0x58, 0x99, 0x41, 0x00, 0x05, 0xb1, 0xf9, 0xc4, 0xed, 0x68, 0xa3, 0xd3, 0xde,
0x68, 0x3d, 0x52, 0xb2, 0x6f, 0xfd, 0x5e, 0x0e, 0x4a, 0xf1, 0xfd, 0x1c, 0x3b, 0x6c, 0xdb, 0xda,
0xd3, 0x68, 0xf7, 0xc6, 0xf0, 0x36, 0x39, 0x42, 0xaf, 0x4e, 0x3a, 0x7b, 0x1f, 0x8b, 0x07, 0x09,
0x31, 0x3a, 0xea, 0xea, 0xbd, 0x0e, 0xc5, 0x5a, 0xaf, 0xd7, 0x7a, 0xd4, 0xd6, 0x9a, 0xca, 0xa7,
0x99, 0xea, 0x97, 0x8e, 0x4f, 0xd6, 0xae, 0xc5, 0x44, 0xb5, 0x40, 0xec, 0x17, 0x4e, 0xd5, 0x68,
0x68, 0xdd, 0xbe, 0xd6, 0x54, 0x3e, 0xc9, 0x4e, 0x53, 0xf1, 0x4e, 0x15, 0x7f, 0x68, 0x55, 0xea,
0x62, 0xad, 0x5b, 0xc3, 0xec, 0x83, 0x9f, 0x66, 0x45, 0xc3, 0x71, 0xf2, 0x45, 0x9f, 0x78, 0x86,
0xcf, 0xbe, 0xb9, 0x12, 0xbd, 0x77, 0xfc, 0x64, 0x56, 0xbc, 0xb8, 0x99, 0x5c, 0x36, 0x12, 0xc3,
0x1a, 0xb3, 0xaf, 0xf1, 0x5b, 0x5e, 0x2e, 0x66, 0x76, 0xea, 0x6b, 0x3d, 0x16, 0x5c, 0x99, 0x14,
0x15, 0xe6, 0xf0, 0x4e, 0xbb, 0xcd, 0x88, 0x3e, 0xc9, 0x4d, 0xcd, 0x0e, 0x8f, 0x5c, 0x97, 0xd1,
0xdc, 0x86, 0x62, 0x74, 0x09, 0xac, 0x7c, 0x9a, 0x9b, 0x52, 0xa8, 0x11, 0xdd, 0x60, 0xf3, 0x0f,
0x6e, 0xee, 0xf4, 0xf9, 0x73, 0xcc, 0x4f, 0xf2, 0xd3, 0x1f, 0xdc, 0x1f, 0x85, 0x16, 0x3d, 0x72,
0x59, 0x98, 0x91, 0xbd, 0xcd, 0x4f, 0xf3, 0x22, 0x7c, 0xc5, 0x34, 0xb2, 0xb1, 0xf9, 0x3a, 0x14,
0xb1, 0xf6, 0x0d, 0xf1, 0x72, 0xf3, 0x93, 0xc2, 0x94, 0x1c, 0x4c, 0x9e, 0x11, 0x93, 0x7d, 0x6d,
0x0d, 0x0a, 0x58, 0xdb, 0xee, 0x3c, 0xd1, 0x94, 0x3f, 0x28, 0x4c, 0xc9, 0xc1, 0x64, 0x48, 0xf9,
0x4b, 0xb4, 0x62, 0x07, 0x77, 0x37, 0x6b, 0x7c, 0x51, 0xa6, 0xe5, 0x74, 0x7c, 0x6f, 0xdf, 0x70,
0x89, 0x35, 0x79, 0x75, 0x14, 0xa3, 0xde, 0xfa, 0x25, 0x28, 0x46, 0xc9, 0x3e, 0x5a, 0x81, 0xc2,
0xd3, 0x0e, 0x7e, 0xac, 0x61, 0x65, 0x46, 0x58, 0x39, 0xc2, 0x3c, 0x15, 0x65, 0xda, 0x1a, 0xcc,
0x6d, 0xd7, 0xda, 0xb5, 0x47, 0x1a, 0x8e, 0x2e, 0x26, 0x22, 0x02, 0x99, 0xb1, 0x56, 0x15, 0xf9,
0x81, 0x58, 0x66, 0xfd, 0xf5, 0x1f, 0x7c, 0xb6, 0x32, 0xf3, 0xe3, 0xcf, 0x56, 0x66, 0x3e, 0x39,
0x5b, 0xc9, 0xfc, 0xe0, 0x6c, 0x25, 0xf3, 0xc3, 0xb3, 0x95, 0xcc, 0xbf, 0x9d, 0xad, 0x64, 0x7e,
0xe7, 0x27, 0x2b, 0x33, 0x3f, 0xfc, 0xc9, 0xca, 0xcc, 0x8f, 0x7f, 0xb2, 0x32, 0xb3, 0x5b, 0xe0,
0x4e, 0xff, 0xe0, 0xff, 0x02, 0x00, 0x00, 0xff, 0xff, 0xde, 0x15, 0x00, 0xb1, 0xc6, 0x34, 0x00,
0x00,
}
func (m *Version) Copy() *Version {
@ -5814,6 +5866,26 @@ func (m *Privileges_SELinuxContext) CopyFrom(src interface{}) {
*m = *o
}
func (m *JobStatus) Copy() *JobStatus {
if m == nil {
return nil
}
o := &JobStatus{}
o.CopyFrom(m)
return o
}
func (m *JobStatus) CopyFrom(src interface{}) {
o := src.(*JobStatus)
*m = *o
github_com_docker_swarmkit_api_deepcopy.Copy(&m.JobIteration, &o.JobIteration)
if o.LastExecution != nil {
m.LastExecution = &types.Timestamp{}
github_com_docker_swarmkit_api_deepcopy.Copy(m.LastExecution, o.LastExecution)
}
}
func (m *Version) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
@ -8499,6 +8571,42 @@ func (m *Privileges_SELinuxContext) MarshalTo(dAtA []byte) (int, error) {
return i, nil
}
func (m *JobStatus) Marshal() (dAtA []byte, err error) {
size := m.Size()
dAtA = make([]byte, size)
n, err := m.MarshalTo(dAtA)
if err != nil {
return nil, err
}
return dAtA[:n], nil
}
func (m *JobStatus) MarshalTo(dAtA []byte) (int, error) {
var i int
_ = i
var l int
_ = l
dAtA[i] = 0xa
i++
i = encodeVarintTypes(dAtA, i, uint64(m.JobIteration.Size()))
n50, err := m.JobIteration.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n50
if m.LastExecution != nil {
dAtA[i] = 0x12
i++
i = encodeVarintTypes(dAtA, i, uint64(m.LastExecution.Size()))
n51, err := m.LastExecution.MarshalTo(dAtA[i:])
if err != nil {
return 0, err
}
i += n51
}
return i, nil
}
func encodeVarintTypes(dAtA []byte, offset int, v uint64) int {
for v >= 1<<7 {
dAtA[offset] = uint8(v&0x7f | 0x80)
@ -9927,6 +10035,21 @@ func (m *Privileges_SELinuxContext) Size() (n int) {
return n
}
func (m *JobStatus) Size() (n int) {
if m == nil {
return 0
}
var l int
_ = l
l = m.JobIteration.Size()
n += 1 + l + sovTypes(uint64(l))
if m.LastExecution != nil {
l = m.LastExecution.Size()
n += 1 + l + sovTypes(uint64(l))
}
return n
}
func sovTypes(x uint64) (n int) {
for {
n++
@ -10865,6 +10988,17 @@ func (this *Privileges_SELinuxContext) String() string {
}, "")
return s
}
func (this *JobStatus) String() string {
if this == nil {
return "nil"
}
s := strings.Join([]string{`&JobStatus{`,
`JobIteration:` + strings.Replace(strings.Replace(this.JobIteration.String(), "Version", "Version", 1), `&`, ``, 1) + `,`,
`LastExecution:` + strings.Replace(fmt.Sprintf("%v", this.LastExecution), "Timestamp", "types.Timestamp", 1) + `,`,
`}`,
}, "")
return s
}
func valueToStringTypes(v interface{}) string {
rv := reflect.ValueOf(v)
if rv.IsNil() {
@ -20502,6 +20636,128 @@ func (m *Privileges_SELinuxContext) Unmarshal(dAtA []byte) error {
}
return nil
}
func (m *JobStatus) 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 ErrIntOverflowTypes
}
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: JobStatus: wiretype end group for non-group")
}
if fieldNum <= 0 {
return fmt.Errorf("proto: JobStatus: illegal tag %d (wire type %d)", fieldNum, wire)
}
switch fieldNum {
case 1:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field JobIteration", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if err := m.JobIteration.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
case 2:
if wireType != 2 {
return fmt.Errorf("proto: wrong wireType = %d for field LastExecution", wireType)
}
var msglen int
for shift := uint(0); ; shift += 7 {
if shift >= 64 {
return ErrIntOverflowTypes
}
if iNdEx >= l {
return io.ErrUnexpectedEOF
}
b := dAtA[iNdEx]
iNdEx++
msglen |= int(b&0x7F) << shift
if b < 0x80 {
break
}
}
if msglen < 0 {
return ErrInvalidLengthTypes
}
postIndex := iNdEx + msglen
if postIndex < 0 {
return ErrInvalidLengthTypes
}
if postIndex > l {
return io.ErrUnexpectedEOF
}
if m.LastExecution == nil {
m.LastExecution = &types.Timestamp{}
}
if err := m.LastExecution.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
return err
}
iNdEx = postIndex
default:
iNdEx = preIndex
skippy, err := skipTypes(dAtA[iNdEx:])
if err != nil {
return err
}
if skippy < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) < 0 {
return ErrInvalidLengthTypes
}
if (iNdEx + skippy) > l {
return io.ErrUnexpectedEOF
}
iNdEx += skippy
}
}
if iNdEx > l {
return io.ErrUnexpectedEOF
}
return nil
}
func skipTypes(dAtA []byte) (n int, err error) {
l := len(dAtA)
iNdEx := 0

16
vendor/github.com/docker/swarmkit/api/types.proto generated vendored
View file

@ -1115,3 +1115,19 @@ message Privileges {
}
SELinuxContext selinux_context = 2 [(gogoproto.customname) = "SELinuxContext"];
}
// JobStatus indicates the status of a Service that is in one of the Job modes.
message JobStatus {
// JobIteration is the count of how many times the Job has been excecuted,
// successfully or otherwise. "Executed" refers to the job as a whole being
// started, not to the individual Tasks being launched. This is used to
// disambiguate which Tasks belong to which iteration of a Job.
Version job_iteration = 1 [(gogoproto.nullable) = false];
// LastExecution is the time that the job was last executed. This is set by
// the orchestrator in the same transaction that JobIteration is incremented.
// While time is a fungible concept in distributed systems like Swarmkit,
// this value gives us a best-effort attempt to prevent weird behavior like
// newly added nodes executing long-forgotten jobs.
google.protobuf.Timestamp last_execution = 2;
}

102
vendor/github.com/docker/swarmkit/manager/controlapi/service.go generated vendored
View file

@ -474,12 +474,32 @@ func (s *Server) validateNetworks(networks []*api.NetworkAttachmentConfig) error
func validateMode(s *api.ServiceSpec) error {
m := s.GetMode()
switch m.(type) {
switch mode := m.(type) {
case *api.ServiceSpec_Replicated:
if int64(m.(*api.ServiceSpec_Replicated).Replicated.Replicas) < 0 {
if int64(mode.Replicated.Replicas) < 0 {
return status.Errorf(codes.InvalidArgument, "Number of replicas must be non-negative")
}
case *api.ServiceSpec_Global:
case *api.ServiceSpec_ReplicatedJob:
// this check shouldn't be required as the point of uint64 is to
// constrain the possible values to positive numbers, but it almost
// certainly is required because there are almost certainly blind casts
// from int64 to uint64, and uint64(-1) is almost certain to crash the
// cluster because of how large it is.
if int64(mode.ReplicatedJob.MaxConcurrent) < 0 {
return status.Errorf(
codes.InvalidArgument,
"Maximum concurrent jobs must not be negative",
)
}
if int64(mode.ReplicatedJob.TotalCompletions) < 0 {
return status.Errorf(
codes.InvalidArgument,
"Total completed jobs must not be negative",
)
}
case *api.ServiceSpec_GlobalJob:
default:
return status.Errorf(codes.InvalidArgument, "Unrecognized service mode")
}
@ -487,6 +507,13 @@ func validateMode(s *api.ServiceSpec) error {
return nil
}
func validateJob(spec *api.ServiceSpec) error {
if spec.Update != nil {
return status.Errorf(codes.InvalidArgument, "Jobs may not have an update config")
}
return nil
}
func validateServiceSpec(spec *api.ServiceSpec) error {
if spec == nil {
return status.Errorf(codes.InvalidArgument, errInvalidArgument.Error())
@ -497,13 +524,32 @@ func validateServiceSpec(spec *api.ServiceSpec) error {
if err := validateTaskSpec(spec.Task); err != nil {
return err
}
err := validateMode(spec)
if err != nil {
return err
}
// job-mode services are validated differently. most notably, they do not
// have UpdateConfigs, which is why this case statement skips update
// validation.
if isJobSpec(spec) {
if err := validateJob(spec); err != nil {
return err
}
} else {
if err := validateUpdate(spec.Update); err != nil {
return err
}
if err := validateEndpointSpec(spec.Endpoint); err != nil {
return err
}
return validateMode(spec)
return validateEndpointSpec(spec.Endpoint)
}
func isJobSpec(spec *api.ServiceSpec) bool {
mode := spec.GetMode()
_, isGlobalJob := mode.(*api.ServiceSpec_GlobalJob)
_, isReplicatedJob := mode.(*api.ServiceSpec_ReplicatedJob)
return isGlobalJob || isReplicatedJob
}
// checkPortConflicts does a best effort to find if the passed in spec has port
@ -689,6 +735,12 @@ func (s *Server) CreateService(ctx context.Context, request *api.CreateServiceRe
SpecVersion: &api.Version{},
}
if isJobSpec(request.Spec) {
service.JobStatus = &api.JobStatus{
LastExecution: gogotypes.TimestampNow(),
}
}
if allocator.IsIngressNetworkNeeded(service) {
if _, err := allocator.GetIngressNetwork(s.store); err == allocator.ErrNoIngress {
return nil, status.Errorf(codes.FailedPrecondition, "service needs ingress network, but no ingress network is present")
@ -819,6 +871,13 @@ func (s *Server) UpdateService(ctx context.Context, request *api.UpdateServiceRe
service.Meta.Version = *request.ServiceVersion
// if the service has a JobStatus, that means it must be a Job, and we
// should increment the JobIteration
if service.JobStatus != nil {
service.JobStatus.JobIteration.Index = service.JobStatus.JobIteration.Index + 1
service.JobStatus.LastExecution = gogotypes.TimestampNow()
}
if request.Rollback == api.UpdateServiceRequest_PREVIOUS {
if service.PreviousSpec == nil {
return status.Errorf(codes.FailedPrecondition, "service %s does not have a previous spec", request.ServiceID)
@ -999,6 +1058,10 @@ func (s *Server) ListServiceStatuses(ctx context.Context, req *api.ListServiceSt
// use a boolean to see global vs replicated. this avoids us having to
// iterate the task list twice.
global := false
// jobIteration is the iteration that the Job is currently
// operating on, to distinguish Tasks in old executions from tasks
// in the current one. if nil, service is not a Job
var jobIteration *api.Version
service := store.GetService(tx, id)
// a service might be deleted, but it may still have tasks. in that
// case, we will be using 0 as the desired task count.
@ -1009,23 +1072,52 @@ func (s *Server) ListServiceStatuses(ctx context.Context, req *api.ListServiceSt
// numbercrunchin
if replicated := service.Spec.GetReplicated(); replicated != nil {
status.DesiredTasks = replicated.Replicas
} else if replicatedJob := service.Spec.GetReplicatedJob(); replicatedJob != nil {
status.DesiredTasks = replicatedJob.MaxConcurrent
} else {
// global applies to both GlobalJob and regular Global
global = true
}
if service.JobStatus != nil {
jobIteration = &service.JobStatus.JobIteration
}
}
// now, figure out how many tasks are running. Pretty easy, and
// universal across both global and replicated services
for _, task := range tasks {
// if the service is a Job, jobIteration will be non-nil. This
// means we should check if the task belongs to the current job
// iteration. If not, skip accounting the task.
if jobIteration != nil {
if task.JobIteration == nil || task.JobIteration.Index != jobIteration.Index {
continue
}
// additionally, since we've verified that the service is a
// job and the task belongs to this iteration, we should
// increment CompletedTasks
if task.Status.State == api.TaskStateCompleted {
status.CompletedTasks++
}
}
if task.Status.State == api.TaskStateRunning {
status.RunningTasks++
}
// if the service is global, a shortcut for figuring out the
// number of tasks desired is to look at all tasks, and take a
// count of the ones whose desired state is not Shutdown.
if global && task.DesiredState == api.TaskStateRunning {
status.DesiredTasks++
}
// for jobs, this is any task with desired state Completed
// which is not actually in that state.
if global && task.Status.State != api.TaskStateCompleted && task.DesiredState == api.TaskStateCompleted {
status.DesiredTasks++
}
}
}
})

11
vendor/github.com/docker/swarmkit/manager/manager.go generated vendored
View file

@ -33,6 +33,7 @@ import (
"github.com/docker/swarmkit/manager/metrics"
"github.com/docker/swarmkit/manager/orchestrator/constraintenforcer"
"github.com/docker/swarmkit/manager/orchestrator/global"
"github.com/docker/swarmkit/manager/orchestrator/jobs"
"github.com/docker/swarmkit/manager/orchestrator/replicated"
"github.com/docker/swarmkit/manager/orchestrator/taskreaper"
"github.com/docker/swarmkit/manager/resourceapi"
@ -146,6 +147,7 @@ type Manager struct {
watchServer *watchapi.Server
replicatedOrchestrator *replicated.Orchestrator
globalOrchestrator *global.Orchestrator
jobsOrchestrator *jobs.Orchestrator
taskReaper *taskreaper.TaskReaper
constraintEnforcer *constraintenforcer.ConstraintEnforcer
scheduler *scheduler.Scheduler
@ -681,6 +683,9 @@ func (m *Manager) Stop(ctx context.Context, clearData bool) {
if m.globalOrchestrator != nil {
m.globalOrchestrator.Stop()
}
if m.jobsOrchestrator != nil {
m.jobsOrchestrator.Stop()
}
if m.taskReaper != nil {
m.taskReaper.Stop()
}
@ -994,6 +999,7 @@ func (m *Manager) becomeLeader(ctx context.Context) {
m.replicatedOrchestrator = replicated.NewReplicatedOrchestrator(s)
m.constraintEnforcer = constraintenforcer.New(s)
m.globalOrchestrator = global.NewGlobalOrchestrator(s)
m.jobsOrchestrator = jobs.NewOrchestrator(s)
m.taskReaper = taskreaper.New(s)
m.scheduler = scheduler.New(s)
m.keyManager = keymanager.New(s, keymanager.DefaultConfig())
@ -1090,6 +1096,11 @@ func (m *Manager) becomeLeader(ctx context.Context) {
}
}(m.replicatedOrchestrator)
go func(orchestrator *jobs.Orchestrator) {
// jobs orchestrator does not return errors.
orchestrator.Run(ctx)
}(m.jobsOrchestrator)
go func(globalOrchestrator *global.Orchestrator) {
if err := globalOrchestrator.Run(ctx); err != nil {
log.G(ctx).WithError(err).Error("global orchestrator exited with an error")

4
vendor/github.com/docker/swarmkit/manager/orchestrator/constraintenforcer/constraint_enforcer.go generated vendored
View file

@ -115,7 +115,7 @@ func (ce *ConstraintEnforcer) rejectNoncompliantTasks(node *api.Node) {
// to remove the most resource-intensive tasks.
loop:
for _, t := range tasks {
if t.DesiredState < api.TaskStateAssigned || t.DesiredState > api.TaskStateRunning {
if t.DesiredState < api.TaskStateAssigned || t.DesiredState > api.TaskStateCompleted {
continue
}
@ -195,7 +195,7 @@ loop:
for _, t := range removeTasks {
err := batch.Update(func(tx store.Tx) error {
t = store.GetTask(tx, t.ID)
if t == nil || t.DesiredState > api.TaskStateRunning {
if t == nil || t.DesiredState > api.TaskStateCompleted {
return nil
}

301
vendor/github.com/docker/swarmkit/manager/orchestrator/jobs/global/reconciler.go generated vendored Normal file
View file

@ -0,0 +1,301 @@
package global
import (
"context"
"github.com/docker/swarmkit/api"
"github.com/docker/swarmkit/manager/constraint"
"github.com/docker/swarmkit/manager/orchestrator"
"github.com/docker/swarmkit/manager/state/store"
)
// restartSupervisor is an interface representing the methods from the
// restart.SupervisorInterface that are actually needed by the reconciler. This
// more limited interface allows us to write a less ugly fake for unit testing.
type restartSupervisor interface {
Restart(context.Context, store.Tx, *api.Cluster, *api.Service, api.Task) error
}
// Reconciler is an object that manages reconciliation of global jobs. It is
// blocking and non-asynchronous, for ease of testing. It implements the
// Reconciler interface from the orchestrator package above it, and the
// taskinit.InitHandler interface.
type Reconciler struct {
store *store.MemoryStore
restart restartSupervisor
}
// NewReconciler creates a new global job reconciler.
func NewReconciler(store *store.MemoryStore, restart restartSupervisor) *Reconciler {
return &Reconciler{
store: store,
restart: restart,
}
}
// ReconcileService reconciles one global job service.
func (r *Reconciler) ReconcileService(id string) error {
var (
service *api.Service
cluster *api.Cluster
tasks []*api.Task
nodes []*api.Node
viewErr error
)
// we need to first get the latest iteration of the service, its tasks, and
// the nodes in the cluster.
r.store.View(func(tx store.ReadTx) {
service = store.GetService(tx, id)
if service == nil {
return
}
// getting tasks with FindTasks should only return an error if we've
// made a mistake coding; there's no user-input or even reasonable
// system state that can cause it. If it returns an error, we'll just
// panic and crash.
tasks, viewErr = store.FindTasks(tx, store.ByServiceID(id))
if viewErr != nil {
return
}
// same as with FindTasks
nodes, viewErr = store.FindNodes(tx, store.All)
if viewErr != nil {
return
}
clusters, _ := store.FindClusters(tx, store.All)
if len(clusters) == 1 {
cluster = clusters[0]
} else if len(clusters) > 1 {
panic("there should never be more than one cluster object")
}
})
if viewErr != nil {
return viewErr
}
// the service may be nil if the service has been deleted before we entered
// the View.
if service == nil {
return nil
}
if service.JobStatus == nil {
service.JobStatus = &api.JobStatus{}
}
// we need to compute the constraints on the service so we know which nodes
// to schedule it on
var constraints []constraint.Constraint
if service.Spec.Task.Placement != nil && len(service.Spec.Task.Placement.Constraints) != 0 {
// constraint.Parse does return an error, but we don't need to check
// it, because it was already checked when the service was created or
// updated.
constraints, _ = constraint.Parse(service.Spec.Task.Placement.Constraints)
}
var candidateNodes []string
var invalidNodes []string
for _, node := range nodes {
// instead of having a big ugly multi-line boolean expression in the
// if-statement, we'll have several if-statements, and bail out of
// this loop iteration with continue if the node is not acceptable
if !constraint.NodeMatches(constraints, node) {
continue
}
// if a node is invalid, we should remove any tasks that might be on it
if orchestrator.InvalidNode(node) {
invalidNodes = append(invalidNodes, node.ID)
continue
}
if node.Spec.Availability != api.NodeAvailabilityActive {
continue
}
if node.Status.State != api.NodeStatus_READY {
continue
}
// you can append to a nil slice and get a non-nil slice, which is
// pretty slick.
candidateNodes = append(candidateNodes, node.ID)
}
// now, we have a list of all nodes that match constraints. it's time to
// match running tasks to the nodes. we need to identify all nodes that
// need new tasks, which is any node that doesn't have a task of this job
// iteration. trade some space for some time by building a node ID to task
// ID mapping, so that we're just doing 2x linear operation, instead of a
// quadratic operation.
nodeToTask := map[string]string{}
// additionally, while we're iterating through tasks, if any of those tasks
// are failed, we'll hand them to the restart supervisor to handle
restartTasks := []string{}
// and if there are any tasks belonging to old job iterations, set them to
// be removed
removeTasks := []string{}
for _, task := range tasks {
// match all tasks belonging to this job iteration which are in desired
// state completed, including failed tasks. We only want to create
// tasks for nodes on which there are no existing tasks.
if task.JobIteration != nil {
if task.JobIteration.Index == service.JobStatus.JobIteration.Index &&
task.DesiredState <= api.TaskStateCompleted {
// we already know the task is desired to be executing (because its
// desired state is Completed). Check here to see if it's already
// failed, so we can restart it
if task.Status.State > api.TaskStateCompleted {
restartTasks = append(restartTasks, task.ID)
}
nodeToTask[task.NodeID] = task.ID
}
if task.JobIteration.Index != service.JobStatus.JobIteration.Index {
if task.DesiredState != api.TaskStateRemove {
removeTasks = append(removeTasks, task.ID)
}
}
}
}
return r.store.Batch(func(batch *store.Batch) error {
// first, create any new tasks required.
for _, node := range candidateNodes {
// check if there is a task for this node ID. If not, then we need
// to create one.
if _, ok := nodeToTask[node]; !ok {
if err := batch.Update(func(tx store.Tx) error {
// if the node does not already have a running or completed
// task, create a task for this node.
task := orchestrator.NewTask(cluster, service, 0, node)
task.JobIteration = &service.JobStatus.JobIteration
task.DesiredState = api.TaskStateCompleted
return store.CreateTask(tx, task)
}); err != nil {
return err
}
}
}
// then, restart any tasks that are failed
for _, taskID := range restartTasks {
if err := batch.Update(func(tx store.Tx) error {
// get the latest version of the task for the restart
t := store.GetTask(tx, taskID)
// if it's deleted, nothing to do
if t == nil {
return nil
}
// if it's not still desired to be running, then don't restart
// it.
if t.DesiredState > api.TaskStateCompleted {
return nil
}
// Finally, restart it
// TODO(dperny): pass in context to ReconcileService, so we can
// pass it in here.
return r.restart.Restart(context.Background(), tx, cluster, service, *t)
}); err != nil {
// TODO(dperny): probably should log like in the other
// orchestrators instead of returning here.
return err
}
}
// remove tasks that need to be removed
for _, taskID := range removeTasks {
if err := batch.Update(func(tx store.Tx) error {
t := store.GetTask(tx, taskID)
if t == nil {
return nil
}
if t.DesiredState == api.TaskStateRemove {
return nil
}
t.DesiredState = api.TaskStateRemove
return store.UpdateTask(tx, t)
}); err != nil {
return err
}
}
// finally, shut down any tasks on invalid nodes
for _, nodeID := range invalidNodes {
if taskID, ok := nodeToTask[nodeID]; ok {
if err := batch.Update(func(tx store.Tx) error {
t := store.GetTask(tx, taskID)
if t == nil {
return nil
}
// if the task is still desired to be running, and is still
// actually, running, then it still needs to be shut down.
if t.DesiredState > api.TaskStateCompleted || t.Status.State <= api.TaskStateRunning {
t.DesiredState = api.TaskStateShutdown
return store.UpdateTask(tx, t)
}
return nil
}); err != nil {
return err
}
}
}
return nil
})
}
// IsRelatedService returns true if the task is a global job. This method
// fulfills the taskinit.InitHandler interface. Because it is just a wrapper
// around a well-tested function call, it has no tests of its own.
func (r *Reconciler) IsRelatedService(service *api.Service) bool {
return orchestrator.IsGlobalJob(service)
}
// FixTask validates that a task is compliant with the rest of the cluster
// state, and fixes it if it's not. This covers some main scenarios:
//
// * The node that the task is running on is now paused or drained. we do not
// need to check if the node still meets constraints -- that is the purview
// of the constraint enforcer.
// * The task has failed and needs to be restarted.
//
// This implements the FixTask method of the taskinit.InitHandler interface.
func (r *Reconciler) FixTask(ctx context.Context, batch *store.Batch, t *api.Task) {
// tasks already desired to be shut down need no action.
if t.DesiredState > api.TaskStateCompleted {
return
}
batch.Update(func(tx store.Tx) error {
node := store.GetNode(tx, t.NodeID)
// if the node is no longer a valid node for this task, we need to shut
// it down
if orchestrator.InvalidNode(node) {
task := store.GetTask(tx, t.ID)
if task != nil && task.DesiredState < api.TaskStateShutdown {
task.DesiredState = api.TaskStateShutdown
return store.UpdateTask(tx, task)
}
}
// we will reconcile all services after fixing the tasks, so we don't
// need to restart tasks right now; we'll do so after this.
return nil
})
}
// SlotTuple returns a slot tuple representing this task. It implements the
// taskinit.InitHandler interface.
func (r *Reconciler) SlotTuple(t *api.Task) orchestrator.SlotTuple {
return orchestrator.SlotTuple{
ServiceID: t.ServiceID,
NodeID: t.NodeID,
}
}

250
vendor/github.com/docker/swarmkit/manager/orchestrator/jobs/orchestrator.go generated vendored Normal file
View file

@ -0,0 +1,250 @@
package jobs
import (
"context"
"sync"
"github.com/docker/go-events"
"github.com/docker/swarmkit/api"
"github.com/docker/swarmkit/log"
"github.com/docker/swarmkit/manager/orchestrator"
"github.com/docker/swarmkit/manager/orchestrator/jobs/global"
"github.com/docker/swarmkit/manager/orchestrator/jobs/replicated"
"github.com/docker/swarmkit/manager/orchestrator/restart"
"github.com/docker/swarmkit/manager/orchestrator/taskinit"
"github.com/docker/swarmkit/manager/state/store"
)
// Reconciler is the type that holds the reconciliation logic for the
// orchestrator. It exists so that the logic of actually reconciling and
// writing to the store is separated from the orchestrator, to make the event
// handling logic in the orchestrator easier to test.
type Reconciler interface {
taskinit.InitHandler
ReconcileService(id string) error
}
// Orchestrator is the combined orchestrator controlling both Global and
// Replicated Jobs. Initially, these job types were two separate orchestrators,
// like the Replicated and Global orchestrators. However, it became apparent
// that because of the simplicity of Jobs as compared to Services, one combined
// orchestrator suffices for both job types.
type Orchestrator struct {
store *store.MemoryStore
// two reconcilers, one for each service type
replicatedReconciler Reconciler
globalReconciler Reconciler
// startOnce is a function that stops the orchestrator from being started
// multiple times.
startOnce sync.Once
// restartSupervisor is the component that handles restarting tasks
restartSupervisor restart.SupervisorInterface
// stopChan is a channel that is closed to signal the orchestrator to stop
// running
stopChan chan struct{}
// stopOnce is used to ensure that stopChan can only be closed once, just
// in case some freak accident causes subsequent calls to Stop.
stopOnce sync.Once
// doneChan is closed when the orchestrator actually stops running
doneChan chan struct{}
// checkTasksFunc is a variable that hold taskinit.CheckTasks, but allows
// swapping it out in testing.
checkTasksFunc func(context.Context, *store.MemoryStore, store.ReadTx, taskinit.InitHandler, restart.SupervisorInterface) error
// the watchChan and watchCancel provide the event stream
watchChan chan events.Event
watchCancel func()
}
func NewOrchestrator(store *store.MemoryStore) *Orchestrator {
return &Orchestrator{
store: store,
stopChan: make(chan struct{}),
doneChan: make(chan struct{}),
}
}
// Run runs the Orchestrator reconciliation loop. It takes a context as an
// argument, but canceling this context will not stop the routine; this context
// is only for passing in logging information. Call Stop to stop the
// Orchestrator
func (o *Orchestrator) Run(ctx context.Context) {
o.startOnce.Do(func() { o.run(ctx) })
}
// init runs the once-off initialization logic for the orchestrator. This
// includes initializing the sub-components, starting the channel watch, and
// running the initial reconciliation pass. this runs as part of the run
// method, but is broken out for the purpose of testing.
func (o *Orchestrator) init(ctx context.Context) {
var (
services []*api.Service
)
// there are several components to the Orchestrator that are interfaces
// designed to be swapped out in testing. in production, these fields will
// all be unset, and be initialized here. in testing, we will set fakes,
// and this initialization will be skipped.
if o.restartSupervisor == nil {
o.restartSupervisor = restart.NewSupervisor(o.store)
}
if o.replicatedReconciler == nil {
// the cluster might be nil, but that doesn't matter.
o.replicatedReconciler = replicated.NewReconciler(o.store, o.restartSupervisor)
}
if o.globalReconciler == nil {
o.globalReconciler = global.NewReconciler(o.store, o.restartSupervisor)
}
if o.checkTasksFunc == nil {
o.checkTasksFunc = taskinit.CheckTasks
}
o.watchChan, o.watchCancel, _ = store.ViewAndWatch(o.store, func(tx store.ReadTx) error {
services, _ = store.FindServices(tx, store.All)
return nil
})
// checkTasksFunc is used to resume any in-progress restarts that were
// interrupted by a leadership change. In other orchestrators, this
// additionally queues up some tasks to be restarted. However, the jobs
// orchestrator will make a reconciliation pass across all services
// immediately after this, and so does not need to restart any tasks; they
// will be restarted during this pass.
//
// we cannot call o.checkTasksFunc inside of store.ViewAndWatch above.
// despite taking a callback with a ReadTx, it actually performs an Update,
// which acquires a lock and will result in a deadlock. instead, do
// o.checkTasksFunc here.
o.store.View(func(tx store.ReadTx) {
o.checkTasksFunc(ctx, o.store, tx, o.replicatedReconciler, o.restartSupervisor)
o.checkTasksFunc(ctx, o.store, tx, o.globalReconciler, o.restartSupervisor)
})
for _, service := range services {
if orchestrator.IsReplicatedJob(service) {
if err := o.replicatedReconciler.ReconcileService(service.ID); err != nil {
log.G(ctx).WithField(
"service.id", service.ID,
).WithError(err).Error("error reconciling replicated job")
}
}
if orchestrator.IsGlobalJob(service) {
if err := o.globalReconciler.ReconcileService(service.ID); err != nil {
log.G(ctx).WithField(
"service.id", service.ID,
).WithError(err).Error("error reconciling global job")
}
}
}
}
// run provides the actual meat of the the run operation. The call to run is
// made inside of Run, and is enclosed in a sync.Once to stop this from being
// called multiple times
func (o *Orchestrator) run(ctx context.Context) {
ctx = log.WithModule(ctx, "orchestrator/jobs")
// closing doneChan should be the absolute last thing that happens in this
// method, and so should be the absolute first thing we defer.
defer close(o.doneChan)
o.init(ctx)
defer o.watchCancel()
for {
// first, before taking any action, see if we should stop the
// orchestrator. if both the stop channel and the watch channel are
// available to read, the channel that gets read is picked at random,
// but we always want to stop if it's possible.
select {
case <-o.stopChan:
return
default:
}
select {
case event := <-o.watchChan:
o.handleEvent(ctx, event)
case <-o.stopChan:
// we also need to check for stop in here, in case there are no
// updates to cause the loop to turn over.
return
}
}
}
// handle event does the logic of handling one event message and calling the
// reconciler as needed. by handling the event logic in this function, we can
// make an end-run around the run-loop and avoid being at the mercy of the go
// scheduler when testing the orchestrator.
func (o *Orchestrator) handleEvent(ctx context.Context, event events.Event) {
var (
service *api.Service
task *api.Task
)
switch ev := event.(type) {
case api.EventCreateService:
service = ev.Service
case api.EventUpdateService:
service = ev.Service
case api.EventUpdateTask:
task = ev.Task
}
// if this is a task event, we should check if it means the service
// should be reconciled.
if task != nil {
// only bother with all this if the task has entered a terminal
// state and we don't want that to have happened.
if task.Status.State > api.TaskStateRunning && task.DesiredState <= api.TaskStateCompleted {
o.store.View(func(tx store.ReadTx) {
// if for any reason the service ID is invalid, then
// service will just be nil and nothing needs to be
// done
service = store.GetService(tx, task.ServiceID)
})
}
}
if orchestrator.IsReplicatedJob(service) {
if err := o.replicatedReconciler.ReconcileService(service.ID); err != nil {
log.G(ctx).WithField(
"service.id", service.ID,
).WithError(err).Error("error reconciling replicated job")
}
}
if orchestrator.IsGlobalJob(service) {
if err := o.globalReconciler.ReconcileService(service.ID); err != nil {
log.G(ctx).WithField(
"service.id", service.ID,
).WithError(err).Error("error reconciling global job")
}
}
}
// Stop stops the Orchestrator
func (o *Orchestrator) Stop() {
// close stopChan inside of the Once so that there can be no races
// involving multiple attempts to close stopChan.
o.stopOnce.Do(func() {
close(o.stopChan)
})
// now, we wait for the Orchestrator to stop. this wait is unqualified; we
// will not return until Orchestrator has stopped successfully.
<-o.doneChan
}

296
vendor/github.com/docker/swarmkit/manager/orchestrator/jobs/replicated/reconciler.go generated vendored Normal file
View file

@ -0,0 +1,296 @@
package replicated
import (
"context"
"fmt"
"github.com/docker/swarmkit/api"
"github.com/docker/swarmkit/manager/orchestrator"
"github.com/docker/swarmkit/manager/state/store"
)
// restartSupervisor is an interface representing the methods from the
// restart.SupervisorInterface that are actually needed by the reconciler. This
// more limited interface allows us to write a less ugly fake for unit testing.
type restartSupervisor interface {
Restart(context.Context, store.Tx, *api.Cluster, *api.Service, api.Task) error
}
// Reconciler is an object that manages reconciliation of replicated jobs. It
// is blocking and non-asynchronous, for ease of testing. It implements two
// interfaces. The first is the Reconciler interface of the Orchestrator
// package above this one. The second is the taskinit.InitHandler interface.
type Reconciler struct {
// we need the store, of course, to do updates
store *store.MemoryStore
restart restartSupervisor
}
// newReconciler creates a new reconciler object
func NewReconciler(store *store.MemoryStore, restart restartSupervisor) *Reconciler {
return &Reconciler{
store: store,
restart: restart,
}
}
// ReconcileService reconciles the replicated job service with the given ID by
// checking to see if new replicas should be created. reconcileService returns
// an error if there is some case prevent it from correctly reconciling the
// service.
func (r *Reconciler) ReconcileService(id string) error {
var (
service *api.Service
tasks []*api.Task
cluster *api.Cluster
viewErr error
)
// first, get the service and all of its tasks
r.store.View(func(tx store.ReadTx) {
service = store.GetService(tx, id)
tasks, viewErr = store.FindTasks(tx, store.ByServiceID(id))
// there should only ever be 1 cluster object, but for reasons
// forgotten by me, it needs to be retrieved in a rather roundabout way
// from the store
var clusters []*api.Cluster
clusters, viewErr = store.FindClusters(tx, store.All)
if len(clusters) == 1 {
cluster = clusters[0]
} else if len(clusters) > 1 {
// this should never happen, and indicates that the system is
// broken.
panic("there should never be more than one cluster object")
}
})
// errors during view should only happen in a few rather catastrophic
// cases, but here it's not unreasonable to just return an error anyway.
if viewErr != nil {
return viewErr
}
// if the service has already been deleted, there's nothing to do here.
if service == nil {
return nil
}
// if this is the first iteration of the service, it may not yet have a
// JobStatus, so we should create one if so. this won't actually be
// committed, though.
if service.JobStatus == nil {
service.JobStatus = &api.JobStatus{}
}
// Jobs can be run in multiple iterations. The JobStatus of the service
// indicates which Version of iteration we're on. We should only be looking
// at tasks of the latest Version
jobVersion := service.JobStatus.JobIteration.Index
// now, check how many tasks we need and how many we have running. note
// that some of these Running tasks may complete before we even finish this
// code block, and so we might have to immediately re-enter reconciliation,
// so this number is 100% definitive, but it is accurate for this
// particular moment in time, and it won't result in us going OVER the
// needed task count
//
// importantly, we are computing only how many _new_ tasks are needed. Some
// tasks may need to be restarted as well, but we don't do this directly;
// restarting tasks is under the purview of the restartSupervisor.
//
// also also, for the math later, we need these values to be of type uint64.
runningTasks := uint64(0)
completeTasks := uint64(0)
restartTasks := []string{}
removeTasks := []string{}
// for replicated jobs, each task will get a different slot number, so that
// when the job has completed, there will be one Completed task in every
// slot number [0, TotalCompletions-1].
//
// By assigning each task to a unique slot, we simply handling of
// restarting failed tasks through the restart manager.
slots := map[uint64]bool{}
for _, task := range tasks {
// we only care about tasks from this job iteration. tasks from the
// previous job iteration are not important
if task.JobIteration != nil {
if task.JobIteration.Index == jobVersion {
if task.Status.State == api.TaskStateCompleted {
completeTasks++
slots[task.Slot] = true
}
// the Restart Manager may put a task in the desired state Ready,
// so we should match not only tasks in desired state Completed,
// but also those in any valid running state.
if task.Status.State != api.TaskStateCompleted && task.DesiredState <= api.TaskStateCompleted {
runningTasks++
slots[task.Slot] = true
// if the task is in a terminal state, we might need to restart
// it. throw it on the pile if so. this is still counted as a
// running task for the purpose of determining how many new
// tasks to create.
if task.Status.State > api.TaskStateCompleted {
restartTasks = append(restartTasks, task.ID)
}
}
} else {
// tasks belonging to a previous iteration of the job may
// exist. if any such tasks exist, they should have their task
// state set to Remove
if task.Status.State <= api.TaskStateRunning && task.DesiredState != api.TaskStateRemove {
removeTasks = append(removeTasks, task.ID)
}
}
}
}
// now that we have our counts, we need to see how many new tasks to
// create. this number can never exceed MaxConcurrent, but also should not
// result in us exceeding TotalCompletions. first, get these numbers out of
// the service spec.
rj := service.Spec.GetReplicatedJob()
// possibleNewTasks gives us the upper bound for how many tasks we'll
// create. also, ugh, subtracting uints. there's no way this can ever go
// wrong.
possibleNewTasks := rj.MaxConcurrent - runningTasks
// allowedNewTasks is how many tasks we could create, if there were no
// restriction on maximum concurrency. This is the total number of tasks
// we want completed, minus the tasks that are already completed, minus
// the tasks that are in progress.
//
// seriously, ugh, subtracting unsigned ints. totally a fine and not at all
// risky operation, with no possibility for catastrophe
allowedNewTasks := rj.TotalCompletions - completeTasks - runningTasks
// the lower number of allowedNewTasks and possibleNewTasks is how many we
// can create. we'll just use an if statement instead of some fancy floor
// function.
actualNewTasks := allowedNewTasks
if possibleNewTasks < allowedNewTasks {
actualNewTasks = possibleNewTasks
}
// this check might seem odd, but it protects us from an underflow of the
// above subtractions, which, again, is a totally impossible thing that can
// never happen, ever, obviously.
if actualNewTasks > rj.TotalCompletions {
return fmt.Errorf(
"uint64 underflow, we're not going to create %v tasks",
actualNewTasks,
)
}
// finally, we can create these tasks. do this in a batch operation, to
// avoid exceeding transaction size limits
err := r.store.Batch(func(batch *store.Batch) error {
for i := uint64(0); i < actualNewTasks; i++ {
if err := batch.Update(func(tx store.Tx) error {
var slot uint64
// each task will go into a unique slot, and at the end, there
// should be the same number of slots as there are desired
// total completions. We could simplify this logic by simply
// assuming that slots are filled in order, but it's a more
// robust solution to not assume that, and instead assure that
// the slot is unoccupied.
for s := uint64(0); s < rj.TotalCompletions; s++ {
// when we're iterating through, if the service has slots
// that haven't been used yet (for example, if this is the
// first time we're running this iteration), then doing
// a map lookup for the number will return the 0-value
// (false) even if the number doesn't exist in the map.
if !slots[s] {
slot = s
// once we've found a slot, mark it as occupied, so we
// don't double assign in subsequent iterations.
slots[slot] = true
break
}
}
task := orchestrator.NewTask(cluster, service, slot, "")
// when we create the task, we also need to set the
// JobIteration.
task.JobIteration = &api.Version{Index: jobVersion}
task.DesiredState = api.TaskStateCompleted
// finally, create the task in the store.
return store.CreateTask(tx, task)
}); err != nil {
return err
}
}
for _, taskID := range restartTasks {
if err := batch.Update(func(tx store.Tx) error {
t := store.GetTask(tx, taskID)
if t == nil {
return nil
}
if t.DesiredState > api.TaskStateCompleted {
return nil
}
// TODO(dperny): pass in context from above
return r.restart.Restart(context.Background(), tx, cluster, service, *t)
}); err != nil {
return err
}
}
for _, taskID := range removeTasks {
if err := batch.Update(func(tx store.Tx) error {
t := store.GetTask(tx, taskID)
if t == nil {
return nil
}
// don't do unnecessary updates
if t.DesiredState == api.TaskStateRemove {
return nil
}
t.DesiredState = api.TaskStateRemove
return store.UpdateTask(tx, t)
}); err != nil {
return err
}
}
return nil
})
return err
}
// IsRelatedService returns true if the task is a replicated job. This method
// fulfills the taskinit.InitHandler interface. Because it is just a wrapper
// around a well-tested function call, it has no tests of its own.
func (r *Reconciler) IsRelatedService(service *api.Service) bool {
return orchestrator.IsReplicatedJob(service)
}
// FixTask ostensibly validates that a task is compliant with the rest of the
// cluster state. However, in the replicated jobs case, the only action we
// can take with a noncompliant task is to restart it. Because the replicated
// jobs orchestrator reconciles the whole service at once, any tasks that
// need to be restarted will be done when we make the reconiliation pass over
// all services. Therefore, in this instance, FixTask does nothing except
// implement the FixTask method of the taskinit.InitHandler interface.
func (r *Reconciler) FixTask(_ context.Context, _ *store.Batch, _ *api.Task) {}
// SlotTuple returns an orchestrator.SlotTuple object for this task. It
// implements the taskinit.InitHandler interface
func (r *Reconciler) SlotTuple(t *api.Task) orchestrator.SlotTuple {
return orchestrator.SlotTuple{
ServiceID: t.ServiceID,
Slot: t.Slot,
}
}

46
vendor/github.com/docker/swarmkit/manager/orchestrator/restart/restart.go generated vendored
View file

@ -49,6 +49,20 @@ type delayedStart struct {
waiter bool
}
// SupervisorInterface is an interface implemented by the Supervisor. It exists
// to make testing easier, by allowing the restart supervisor to be mocked or
// faked where desired.
type SupervisorInterface interface {
Restart(context.Context, store.Tx, *api.Cluster, *api.Service, api.Task) error
UpdatableTasksInSlot(context.Context, orchestrator.Slot, *api.Service) orchestrator.Slot
RecordRestartHistory(orchestrator.SlotTuple, *api.Task)
DelayStart(context.Context, store.Tx, *api.Task, string, time.Duration, bool) <-chan struct{}
StartNow(store.Tx, string) error
Cancel(string)
CancelAll()
ClearServiceHistory(string)
}
// Supervisor initiates and manages restarts. It's responsible for
// delaying restarts when applicable.
type Supervisor struct {
@ -121,7 +135,7 @@ func (r *Supervisor) Restart(ctx context.Context, tx store.Tx, cluster *api.Clus
// Sanity check: was the task shut down already by a separate call to
// Restart? If so, we must avoid restarting it, because this will create
// an extra task. This should never happen unless there is a bug.
if t.DesiredState > api.TaskStateRunning {
if t.DesiredState > api.TaskStateCompleted {
return errors.New("Restart called on task that was already shut down")
}
@ -138,15 +152,21 @@ func (r *Supervisor) Restart(ctx context.Context, tx store.Tx, cluster *api.Clus
var restartTask *api.Task
if orchestrator.IsReplicatedService(service) {
if orchestrator.IsReplicatedService(service) || orchestrator.IsReplicatedJob(service) {
restartTask = orchestrator.NewTask(cluster, service, t.Slot, "")
} else if orchestrator.IsGlobalService(service) {
} else if orchestrator.IsGlobalService(service) || orchestrator.IsGlobalJob(service) {
restartTask = orchestrator.NewTask(cluster, service, 0, t.NodeID)
} else {
log.G(ctx).Error("service not supported by restart supervisor")
return nil
}
if orchestrator.IsReplicatedJob(service) || orchestrator.IsGlobalJob(service) {
restartTask.JobIteration = &api.Version{
Index: service.JobStatus.JobIteration.Index,
}
}
n := store.GetNode(tx, t.NodeID)
restartTask.DesiredState = api.TaskStateReady
@ -197,7 +217,17 @@ func (r *Supervisor) shouldRestart(ctx context.Context, t *api.Task, service *ap
// There are 3 possible restart policies.
switch orchestrator.RestartCondition(t) {
case api.RestartOnAny:
// we will be restarting, we just need to do a few more checks
// we will be restarting, we just need to do a few more checks.
// however, if the task belongs to a job, then we will treat
// RestartOnAny the same as RestartOnFailure, as it would be
// nonsensical to restart completed jobs.
if orchestrator.IsReplicatedJob(service) || orchestrator.IsGlobalJob(service) {
// it'd be nice to put a fallthrough here, but we can't fallthrough
// from inside of an if statement.
if t.Status.State == api.TaskStateCompleted {
return false
}
}
case api.RestartOnFailure:
// we won't restart if the task is in TaskStateCompleted, as this is a
// not a failed state -- it indicates that the task exited with 0
@ -498,7 +528,15 @@ func (r *Supervisor) StartNow(tx store.Tx, taskID string) error {
if t == nil || t.DesiredState >= api.TaskStateRunning {
return nil
}
// only tasks belonging to jobs will have a JobIteration, so this can be
// used to distinguish whether this is a job task without looking at the
// service.
if t.JobIteration != nil {
t.DesiredState = api.TaskStateCompleted
} else {
t.DesiredState = api.TaskStateRunning
}
return store.UpdateTask(tx, t)
}

20
vendor/github.com/docker/swarmkit/manager/orchestrator/service.go generated vendored
View file

@ -28,6 +28,26 @@ func IsGlobalService(service *api.Service) bool {
return ok
}
// IsReplicatedJob returns true if the service is a replicated job.
func IsReplicatedJob(service *api.Service) bool {
if service == nil {
return false
}
_, ok := service.Spec.GetMode().(*api.ServiceSpec_ReplicatedJob)
return ok
}
// IsGlobalJob returns true if the service is a global job.
func IsGlobalJob(service *api.Service) bool {
if service == nil {
return false
}
_, ok := service.Spec.GetMode().(*api.ServiceSpec_GlobalJob)
return ok
}
// SetServiceTasksRemove sets the desired state of tasks associated with a service
// to REMOVE, so that they can be properly shut down by the agent and later removed
// by the task reaper.

4
vendor/github.com/docker/swarmkit/manager/orchestrator/taskinit/init.go generated vendored
View file

@ -23,7 +23,7 @@ type InitHandler interface {
// CheckTasks fixes tasks in the store before orchestrator runs. The previous leader might
// not have finished processing their updates and left them in an inconsistent state.
func CheckTasks(ctx context.Context, s *store.MemoryStore, readTx store.ReadTx, initHandler InitHandler, startSupervisor *restart.Supervisor) error {
func CheckTasks(ctx context.Context, s *store.MemoryStore, readTx store.ReadTx, initHandler InitHandler, startSupervisor restart.SupervisorInterface) error {
instances := make(map[orchestrator.SlotTuple][]*api.Task)
err := s.Batch(func(batch *store.Batch) error {
tasks, err := store.FindTasks(readTx, store.All)
@ -59,7 +59,7 @@ func CheckTasks(ctx context.Context, s *store.MemoryStore, readTx store.ReadTx,
// desired state ready is a transient state that it should be started.
// however previous leader may not have started it, retry start here
if t.DesiredState != api.TaskStateReady || t.Status.State > api.TaskStateRunning {
if t.DesiredState != api.TaskStateReady || t.Status.State > api.TaskStateCompleted {
continue
}
restartDelay, _ := gogotypes.DurationFromProto(defaults.Service.Task.Restart.Delay)

8
vendor/github.com/docker/swarmkit/manager/scheduler/nodeinfo.go generated vendored
View file

@ -70,7 +70,7 @@ func (nodeInfo *NodeInfo) removeTask(t *api.Task) bool {
}
delete(nodeInfo.Tasks, t.ID)
if oldTask.DesiredState <= api.TaskStateRunning {
if oldTask.DesiredState <= api.TaskStateCompleted {
nodeInfo.ActiveTasksCount--
nodeInfo.ActiveTasksCountByService[t.ServiceID]--
}
@ -108,12 +108,12 @@ func (nodeInfo *NodeInfo) removeTask(t *api.Task) bool {
func (nodeInfo *NodeInfo) addTask(t *api.Task) bool {
oldTask, ok := nodeInfo.Tasks[t.ID]
if ok {
if t.DesiredState <= api.TaskStateRunning && oldTask.DesiredState > api.TaskStateRunning {
if t.DesiredState <= api.TaskStateCompleted && oldTask.DesiredState > api.TaskStateCompleted {
nodeInfo.Tasks[t.ID] = t
nodeInfo.ActiveTasksCount++
nodeInfo.ActiveTasksCountByService[t.ServiceID]++
return true
} else if t.DesiredState > api.TaskStateRunning && oldTask.DesiredState <= api.TaskStateRunning {
} else if t.DesiredState > api.TaskStateCompleted && oldTask.DesiredState <= api.TaskStateCompleted {
nodeInfo.Tasks[t.ID] = t
nodeInfo.ActiveTasksCount--
nodeInfo.ActiveTasksCountByService[t.ServiceID]--
@ -145,7 +145,7 @@ func (nodeInfo *NodeInfo) addTask(t *api.Task) bool {
}
}
if t.DesiredState <= api.TaskStateRunning {
if t.DesiredState <= api.TaskStateCompleted {
nodeInfo.ActiveTasksCount++
nodeInfo.ActiveTasksCountByService[t.ServiceID]++
}

7
vendor/github.com/docker/swarmkit/manager/scheduler/scheduler.go generated vendored
View file

@ -74,9 +74,10 @@ func (s *Scheduler) setupTasksList(tx store.ReadTx) error {
continue
}
// Also ignore tasks that have not yet been assigned but desired state is beyond TaskStateRunning
// This can happen if you update, delete or scale down a service before its tasks were assigned.
if t.Status.State == api.TaskStatePending && t.DesiredState > api.TaskStateRunning {
// Also ignore tasks that have not yet been assigned but desired state
// is beyond TaskStateCompleted. This can happen if you update, delete
// or scale down a service before its tasks were assigned.
if t.Status.State == api.TaskStatePending && t.DesiredState > api.TaskStateCompleted {
continue
}

9
vendor/github.com/docker/swarmkit/vendor.conf generated vendored
View file

@ -65,3 +65,12 @@ golang.org/x/net f3200d17e092c607f615320ecaad13d87ad9a2b3
golang.org/x/sys 9eafafc0a87e0fd0aeeba439a4573537970c44c7
golang.org/x/text f21a4dfb5e38f5895301dc265a8def02365cc3d0 # v0.3.0
golang.org/x/time fbb02b2291d28baffd63558aa44b4b56f178d650
# ginkgo is used for testing in some places in the code. this is it and its
# sub-dependencies.
github.com/onsi/ginkgo v1.8.0
github.com/onsi/gomega v1.5.0
gopkg.in/yaml.v2 v2.2.1
github.com/hpcloud/tail v1.0.0
gopkg.in/fsnotify.v1 v1.4.7
gopkg.in/tomb.v1 v1