diff --git a/addrs/resourcemode_string.go b/addrs/resourcemode_string.go index 56e99adfa854..0b5c33f8ee28 100644 --- a/addrs/resourcemode_string.go +++ b/addrs/resourcemode_string.go @@ -4,6 +4,15 @@ package addrs import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[InvalidResourceMode-0] + _ = x[ManagedResourceMode-77] + _ = x[DataResourceMode-68] +} + const ( _ResourceMode_name_0 = "InvalidResourceMode" _ResourceMode_name_1 = "DataResourceMode" diff --git a/backend/local/counthookaction_string.go b/backend/local/counthookaction_string.go index 507bab917a4c..591004749aa3 100644 --- a/backend/local/counthookaction_string.go +++ b/backend/local/counthookaction_string.go @@ -4,6 +4,15 @@ package local import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[countHookActionAdd-0] + _ = x[countHookActionChange-1] + _ = x[countHookActionRemove-2] +} + const _countHookAction_name = "countHookActionAddcountHookActionChangecountHookActionRemove" var _countHookAction_index = [...]uint8{0, 18, 39, 60} diff --git a/backend/operationtype_string.go b/backend/operationtype_string.go index 16b7b381941e..fe84d848ddb6 100644 --- a/backend/operationtype_string.go +++ b/backend/operationtype_string.go @@ -4,6 +4,16 @@ package backend import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[OperationTypeInvalid-0] + _ = x[OperationTypeRefresh-1] + _ = x[OperationTypePlan-2] + _ = x[OperationTypeApply-3] +} + const _OperationType_name = "OperationTypeInvalidOperationTypeRefreshOperationTypePlanOperationTypeApply" var _OperationType_index = [...]uint8{0, 20, 40, 57, 75} diff --git a/backend/remote-state/oss/backend.go b/backend/remote-state/oss/backend.go index 4b865543a237..33c2cbf5c4d4 100644 --- a/backend/remote-state/oss/backend.go +++ b/backend/remote-state/oss/backend.go @@ -11,9 +11,8 @@ import ( "github.com/aliyun/alibaba-cloud-sdk-go/sdk" "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials" - "github.com/aliyun/alibaba-cloud-sdk-go/sdk/resource" - "github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils" "github.com/aliyun/alibaba-cloud-sdk-go/services/location" + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore" "github.com/hashicorp/go-cleanhttp" "github.com/hashicorp/terraform/version" "log" @@ -44,7 +43,7 @@ func New() backend.Backend { Type: schema.TypeString, Optional: true, Description: "Alibaba Cloud Security Token", - DefaultFunc: schema.EnvDefaultFunc("ALICLOUD_SECURITY_TOKEN", os.Getenv("SECURITY_TOKEN")), + DefaultFunc: schema.EnvDefaultFunc("ALICLOUD_SECURITY_TOKEN", ""), }, "region": &schema.Schema{ @@ -53,7 +52,12 @@ func New() backend.Backend { Description: "The region of the OSS bucket.", DefaultFunc: schema.EnvDefaultFunc("ALICLOUD_REGION", os.Getenv("ALICLOUD_DEFAULT_REGION")), }, - + "tablestore_endpoint": { + Type: schema.TypeString, + Optional: true, + Description: "A custom endpoint for the TableStore API", + DefaultFunc: schema.EnvDefaultFunc("ALICLOUD_TABLESTORE_ENDPOINT", ""), + }, "endpoint": { Type: schema.TypeString, Optional: true, @@ -67,30 +71,38 @@ func New() backend.Backend { Description: "The name of the OSS bucket", }, - "path": &schema.Schema{ + "prefix": &schema.Schema{ Type: schema.TypeString, - Required: true, - Description: "The path relative to your object storage directory where the state file will be stored.", + Optional: true, + Description: "The directory where state files will be saved inside the bucket", + Default: "env:", + ValidateFunc: func(v interface{}, s string) ([]string, []error) { + prefix := v.(string) + if strings.HasPrefix(prefix, "/") || strings.HasPrefix(prefix, "./") { + return nil, []error{fmt.Errorf("workspace_key_prefix must not start with '/' or './'")} + } + return nil, nil + }, }, - "name": &schema.Schema{ + "key": &schema.Schema{ Type: schema.TypeString, Optional: true, - Description: "The name of the state file inside the bucket", + Description: "The path of the state file inside the bucket", ValidateFunc: func(v interface{}, s string) ([]string, []error) { if strings.HasPrefix(v.(string), "/") || strings.HasSuffix(v.(string), "/") { - return nil, []error{fmt.Errorf("name can not start and end with '/'")} + return nil, []error{fmt.Errorf("key can not start and end with '/'")} } return nil, nil }, Default: "terraform.tfstate", }, - "lock": &schema.Schema{ - Type: schema.TypeBool, + "tablestore_table": { + Type: schema.TypeString, Optional: true, - Description: "Whether to lock state access. Defaults to true", - Default: true, + Description: "TableStore table for state locking and consistency", + Default: "", }, "encrypt": &schema.Schema{ @@ -130,14 +142,16 @@ type Backend struct { // The fields below are set from configure ossClient *oss.Client + otsClient *tablestore.TableStoreClient bucketName string - statePath string - stateName string + statePrefix string + stateKey string serverSideEncryption bool acl string endpoint string - lock bool + otsEndpoint string + otsTable string } func (b *Backend) configure(ctx context.Context) error { @@ -149,27 +163,20 @@ func (b *Backend) configure(ctx context.Context) error { d := schema.FromContextBackendConfig(ctx) b.bucketName = d.Get("bucket").(string) - dir := strings.Trim(d.Get("path").(string), "/") - if strings.HasPrefix(dir, "./") { - dir = strings.TrimPrefix(dir, "./") - - } - - b.statePath = dir - b.stateName = d.Get("name").(string) + b.statePrefix = strings.TrimPrefix(strings.Trim(d.Get("prefix").(string), "/"), "./") + b.stateKey = d.Get("key").(string) b.serverSideEncryption = d.Get("encrypt").(bool) b.acl = d.Get("acl").(string) - b.lock = d.Get("lock").(bool) - access_key := d.Get("access_key").(string) - secret_key := d.Get("secret_key").(string) - security_token := d.Get("security_token").(string) + accessKey := d.Get("access_key").(string) + secretKey := d.Get("secret_key").(string) + securityToken := d.Get("security_token").(string) region := d.Get("region").(string) endpoint := d.Get("endpoint").(string) schma := "https" if endpoint == "" { - endpointItem, _ := b.getOSSEndpointByRegion(access_key, secret_key, security_token, region) + endpointItem, _ := b.getOSSEndpointByRegion(accessKey, secretKey, securityToken, region) if endpointItem != nil && len(endpointItem.Endpoint) > 0 { if len(endpointItem.Protocols.Protocols) > 0 { // HTTP or HTTPS @@ -191,13 +198,23 @@ func (b *Backend) configure(ctx context.Context) error { } log.Printf("[DEBUG] Instantiate OSS client using endpoint: %#v", endpoint) var options []oss.ClientOption - if security_token != "" { - options = append(options, oss.SecurityToken(security_token)) + if securityToken != "" { + options = append(options, oss.SecurityToken(securityToken)) } options = append(options, oss.UserAgent(fmt.Sprintf("%s/%s", TerraformUA, TerraformVersion))) - client, err := oss.New(endpoint, access_key, secret_key, options...) + client, err := oss.New(endpoint, accessKey, secretKey, options...) b.ossClient = client + otsEndpoint := d.Get("tablestore_endpoint").(string) + if otsEndpoint != "" { + if !strings.HasPrefix(otsEndpoint, "http") { + otsEndpoint = fmt.Sprintf("%s://%s", schma, otsEndpoint) + } + b.otsEndpoint = otsEndpoint + parts := strings.Split(strings.TrimPrefix(strings.TrimPrefix(otsEndpoint, "https://"), "http://"), ".") + b.otsClient = tablestore.NewClientWithConfig(otsEndpoint, parts[0], accessKey, secretKey, securityToken, tablestore.NewDefaultTableStoreConfig()) + } + b.otsTable = d.Get("tablestore_table").(string) return err } @@ -222,11 +239,6 @@ func (b *Backend) getOSSEndpointByRegion(access_key, secret_key, security_token, } func getSdkConfig() *sdk.Config { - // Fix bug "open /usr/local/go/lib/time/zoneinfo.zip: no such file or directory" which happened in windows. - if data, ok := resource.GetTZData("GMT"); ok { - utils.TZData = data - utils.LoadLocationFromTZData = time.LoadLocationFromTZData - } return sdk.NewConfig(). WithMaxRetryTime(5). WithTimeout(time.Duration(30) * time.Second). diff --git a/backend/remote-state/oss/backend_state.go b/backend/remote-state/oss/backend_state.go index f9bd655750e2..28c40ee4afb3 100644 --- a/backend/remote-state/oss/backend_state.go +++ b/backend/remote-state/oss/backend_state.go @@ -12,6 +12,7 @@ import ( "github.com/hashicorp/terraform/state/remote" "github.com/hashicorp/terraform/states" + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore" "log" "path" ) @@ -33,7 +34,32 @@ func (b *Backend) remoteClient(name string) (*RemoteClient, error) { lockFile: b.lockFile(name), serverSideEncryption: b.serverSideEncryption, acl: b.acl, - doLock: b.lock, + otsTable: b.otsTable, + otsClient: b.otsClient, + } + if b.otsEndpoint != "" && b.otsTable != "" { + table, err := b.otsClient.DescribeTable(&tablestore.DescribeTableRequest{ + TableName: b.otsTable, + }) + if err != nil { + return client, fmt.Errorf("Error describing table store %s: %#v", b.otsTable, err) + } + for _, t := range table.TableMeta.SchemaEntry { + pkMeta := TableStorePrimaryKeyMeta{ + PKName: *t.Name, + } + if *t.Type == tablestore.PrimaryKeyType_INTEGER { + pkMeta.PKType = "Integer" + } else if *t.Type == tablestore.PrimaryKeyType_STRING { + pkMeta.PKType = "String" + } else if *t.Type == tablestore.PrimaryKeyType_BINARY { + pkMeta.PKType = "Binary" + } else { + return client, fmt.Errorf("Unsupported PrimaryKey type: %d.", *t.Type) + } + client.otsTabkePK = pkMeta + break + } } return client, nil @@ -46,7 +72,7 @@ func (b *Backend) Workspaces() ([]string, error) { } var options []oss.Option - options = append(options, oss.Prefix(b.statePath)) + options = append(options, oss.Prefix(b.statePrefix+"/")) resp, err := bucket.ListObjects(options...) if err != nil { @@ -54,9 +80,17 @@ func (b *Backend) Workspaces() ([]string, error) { } result := []string{backend.DefaultStateName} + prefix := b.statePrefix for _, obj := range resp.Objects { - if b.keyEnv(obj.Key) != "" { - result = append(result, b.keyEnv(obj.Key)) + // we have 3 parts, the state prefix, the workspace name, and the state file: // + if path.Join(b.statePrefix, b.stateKey) == obj.Key { + // filter the default workspace + continue + } + + parts := strings.Split(strings.TrimPrefix(obj.Key, prefix+"/"), "/") + if len(parts) > 0 && parts[0] != "" { + result = append(result, parts[0]) } } @@ -83,16 +117,13 @@ func (b *Backend) StateMgr(name string) (state.State, error) { } stateMgr := &remote.State{Client: client} - if !b.lock { - stateMgr.DisableLocks() - } // Check to see if this state already exists. existing, err := b.Workspaces() if err != nil { return nil, err } - log.Printf("[DEBUG] Current state name: %s. All States:%#v", name, existing) + log.Printf("[DEBUG] Current workspace name: %s. All workspaces:%#v", name, existing) exists := false for _, s := range existing { @@ -146,41 +177,15 @@ func (b *Backend) StateMgr(name string) (state.State, error) { return stateMgr, nil } -// extract the object name from the OSS key -func (b *Backend) keyEnv(key string) string { - // we have 3 parts, the state path, the state name, and the state file - parts := strings.Split(key, "/") - length := len(parts) - if length < 3 { - // use default state - return "" - } - - // shouldn't happen since we listed by prefix - if strings.Join(parts[0:length-2], "/") != b.statePath { - return "" - } - - // not our key, so don't include it in our listing - if parts[length-1] != b.stateName { - return "" - } - - return parts[length-2] -} - func (b *Backend) stateFile(name string) string { if name == backend.DefaultStateName { - return path.Join(b.statePath, b.stateName) + return path.Join(b.statePrefix, b.stateKey) } - return path.Join(b.statePath, name, b.stateName) + return path.Join(b.statePrefix, name, b.stateKey) } func (b *Backend) lockFile(name string) string { - if name == backend.DefaultStateName { - return path.Join(b.statePath, b.stateName+lockFileSuffix) - } - return path.Join(b.statePath, name, b.stateName+lockFileSuffix) + return b.stateFile(name) + lockFileSuffix } const stateUnlockError = ` diff --git a/backend/remote-state/oss/backend_test.go b/backend/remote-state/oss/backend_test.go index 430b6d773216..c23d935ab2b1 100644 --- a/backend/remote-state/oss/backend_test.go +++ b/backend/remote-state/oss/backend_test.go @@ -7,6 +7,7 @@ import ( "time" "github.com/aliyun/aliyun-oss-go-sdk/oss" + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore" "github.com/hashicorp/terraform/backend" "github.com/hashicorp/terraform/config/hcl2shim" "strings" @@ -31,24 +32,26 @@ func TestBackend_impl(t *testing.T) { func TestBackendConfig(t *testing.T) { testACC(t) config := map[string]interface{}{ - "region": "cn-beijing", - "bucket": "terraform-backend-oss-test", - "path": "mystate", - "name": "first.tfstate", + "region": "cn-beijing", + "bucket": "terraform-backend-oss-test", + "prefix": "mystate", + "key": "first.tfstate", + "tablestore_endpoint": "https://terraformstate.cn-beijing.ots.aliyuncs.com", + "tablestore_table": "TableStore", } b := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(config)).(*Backend) - if !strings.HasPrefix(b.ossClient.Config.Endpoint, "http://oss-cn-beijing") { + if !strings.HasPrefix(b.ossClient.Config.Endpoint, "https://oss-cn-beijing") { t.Fatalf("Incorrect region was provided") } if b.bucketName != "terraform-backend-oss-test" { t.Fatalf("Incorrect bucketName was provided") } - if b.statePath != "mystate" { + if b.statePrefix != "mystate" { t.Fatalf("Incorrect state file path was provided") } - if b.stateName != "first.tfstate" { + if b.stateKey != "first.tfstate" { t.Fatalf("Incorrect keyName was provided") } @@ -63,10 +66,12 @@ func TestBackendConfig(t *testing.T) { func TestBackendConfig_invalidKey(t *testing.T) { testACC(t) cfg := hcl2shim.HCL2ValueFromConfigValue(map[string]interface{}{ - "region": "cn-beijing", - "bucket": "terraform-backend-oss-test", - "path": "/leading-slash", - "name": "/test.tfstate", + "region": "cn-beijing", + "bucket": "terraform-backend-oss-test", + "prefix": "/leading-slash", + "name": "/test.tfstate", + "tablestore_endpoint": "https://terraformstate.cn-beijing.ots.aliyuncs.com", + "tablestore_table": "TableStore", }) _, results := New().PrepareConfig(cfg) @@ -79,16 +84,16 @@ func TestBackend(t *testing.T) { testACC(t) bucketName := fmt.Sprintf("terraform-remote-oss-test-%x", time.Now().Unix()) - statePath := "multi/level/path/" + statePrefix := "multi/level/path/" b1 := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{ "bucket": bucketName, - "path": statePath, + "prefix": statePrefix, })).(*Backend) b2 := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{ "bucket": bucketName, - "path": statePath, + "prefix": statePrefix, })).(*Backend) createOSSBucket(t, b1.ossClient, bucketName) @@ -132,3 +137,35 @@ func deleteOSSBucket(t *testing.T, ossClient *oss.Client, bucketName string) { t.Logf(warning, err) } } + +// create the dynamoDB table, and wait until we can query it. +func createTablestoreTable(t *testing.T, otsClient *tablestore.TableStoreClient, tableName string) { + tableMeta := new(tablestore.TableMeta) + tableMeta.TableName = tableName + tableMeta.AddPrimaryKeyColumn("testbackend", tablestore.PrimaryKeyType_STRING) + + tableOption := new(tablestore.TableOption) + tableOption.TimeToAlive = -1 + tableOption.MaxVersion = 1 + + reservedThroughput := new(tablestore.ReservedThroughput) + + _, err := otsClient.CreateTable(&tablestore.CreateTableRequest{ + TableMeta: tableMeta, + TableOption: tableOption, + ReservedThroughput: reservedThroughput, + }) + if err != nil { + t.Fatal(err) + } +} + +func deleteTablestoreTable(t *testing.T, otsClient *tablestore.TableStoreClient, tableName string) { + params := &tablestore.DeleteTableRequest{ + TableName: tableName, + } + _, err := otsClient.DeleteTable(params) + if err != nil { + t.Logf("WARNING: Failed to delete the test TableStore table %q. It has been left in your Alibaba Cloud account and may incur charges. (error was %s)", tableName, err) + } +} diff --git a/backend/remote-state/oss/client.go b/backend/remote-state/oss/client.go index 4403e36c396b..e50f801e8406 100644 --- a/backend/remote-state/oss/client.go +++ b/backend/remote-state/oss/client.go @@ -7,79 +7,154 @@ import ( "fmt" "io" + "encoding/hex" "github.com/aliyun/aliyun-oss-go-sdk/oss" + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore" + "github.com/hashicorp/go-multierror" uuid "github.com/hashicorp/go-uuid" + "github.com/hashicorp/terraform/helper/hashcode" "github.com/hashicorp/terraform/state" "github.com/hashicorp/terraform/state/remote" + "github.com/pkg/errors" "log" "sync" + "time" ) +// Store the last saved serial in tablestore with this suffix for consistency checks. +const ( + stateIDSuffix = "-md5" + statePKValue = "terraform-remote-state-lock" +) + +var ( + // The amount of time we will retry a state waiting for it to match the + // expected checksum. + consistencyRetryTimeout = 10 * time.Second + + // delay when polling the state + consistencyRetryPollInterval = 2 * time.Second +) + +// test hook called when checksums don't match +var testChecksumHook func() + +type TableStorePrimaryKeyMeta struct { + PKName string + PKType string +} + type RemoteClient struct { ossClient *oss.Client + otsClient *tablestore.TableStoreClient bucketName string stateFile string lockFile string serverSideEncryption bool acl string - doLock bool info *state.LockInfo mu sync.Mutex + otsTable string + otsTabkePK TableStorePrimaryKeyMeta } func (c *RemoteClient) Get() (payload *remote.Payload, err error) { - c.mu.Lock() - defer c.mu.Unlock() + deadline := time.Now().Add(consistencyRetryTimeout) - buf, err := c.getObj(c.stateFile) - if err != nil { - return nil, err - } + // If we have a checksum, and the returned payload doesn't match, we retry + // up until deadline. + for { + payload, err = c.getObj() + if err != nil { + return nil, err + } - // If there was no data, then return nil - if buf == nil || len(buf.Bytes()) == 0 { - log.Printf("[DEBUG] State %s has no data.", c.stateFile) - return nil, nil - } - md5 := md5.Sum(buf.Bytes()) + // If the remote state was manually removed the payload will be nil, + // but if there's still a digest entry for that state we will still try + // to compare the MD5 below. + var digest []byte + if payload != nil { + digest = payload.MD5 + } - payload = &remote.Payload{ - Data: buf.Bytes(), - MD5: md5[:], + // verify that this state is what we expect + if expected, err := c.getMD5(); err != nil { + log.Printf("[WARN] failed to fetch state md5: %s", err) + } else if len(expected) > 0 && !bytes.Equal(expected, digest) { + log.Printf("[WARN] state md5 mismatch: expected '%x', got '%x'", expected, digest) + + if testChecksumHook != nil { + testChecksumHook() + } + + if time.Now().Before(deadline) { + time.Sleep(consistencyRetryPollInterval) + log.Println("[INFO] retrying OSS RemoteClient.Get...") + continue + } + + return nil, fmt.Errorf(errBadChecksumFmt, digest) + } + + break } return payload, nil } func (c *RemoteClient) Put(data []byte) error { - c.mu.Lock() - defer c.mu.Unlock() - - return c.putObj(c.stateFile, data) -} + bucket, err := c.ossClient.Bucket(c.bucketName) + if err != nil { + return fmt.Errorf("Error getting bucket: %#v", err) + } -func (c *RemoteClient) Delete() error { - c.mu.Lock() - defer c.mu.Unlock() + body := bytes.NewReader(data) - return c.deleteObj(c.stateFile) -} + var options []oss.Option + if c.acl != "" { + options = append(options, oss.ACL(oss.ACLType(c.acl))) + } + options = append(options, oss.ContentType("application/json")) + if c.serverSideEncryption { + options = append(options, oss.ServerSideEncryption("AES256")) + } + options = append(options, oss.ContentLength(int64(len(data)))) -func (c *RemoteClient) Lock(info *state.LockInfo) (string, error) { - c.mu.Lock() - defer c.mu.Unlock() + if body != nil { + if err := bucket.PutObject(c.stateFile, body, options...); err != nil { + return fmt.Errorf("Failed to upload state %s: %#v", c.stateFile, err) + } + } - if !c.doLock { - return "", nil + sum := md5.Sum(data) + if err := c.putMD5(sum[:]); err != nil { + // if this errors out, we unfortunately have to error out altogether, + // since the next Get will inevitably fail. + return fmt.Errorf("Failed to store state MD5: %s", err) } + return nil +} +func (c *RemoteClient) Delete() error { bucket, err := c.ossClient.Bucket(c.bucketName) if err != nil { - return "", fmt.Errorf("Error getting bucket: %#v", err) + return fmt.Errorf("Error getting bucket %s: %#v", c.bucketName, err) } - infoJson, err := json.Marshal(info) - if err != nil { - return "", err + log.Printf("[DEBUG] Deleting remote state from OSS: %#v", c.stateFile) + + if err := bucket.DeleteObject(c.stateFile); err != nil { + return fmt.Errorf("Error deleting state %s: %#v", c.stateFile, err) + } + + if err := c.deleteMD5(); err != nil { + log.Printf("[WARN] Error deleting state MD5: %s", err) + } + return nil +} + +func (c *RemoteClient) Lock(info *state.LockInfo) (string, error) { + if c.otsTable == "" { + return "", nil } if info.ID == "" { @@ -90,84 +165,276 @@ func (c *RemoteClient) Lock(info *state.LockInfo) (string, error) { info.ID = lockID } - info.Path = c.lockFile - exist, err := bucket.IsObjectExist(info.Path) - if err != nil { - return "", fmt.Errorf("Error checking object %s: %#v", info.Path, err) + putParams := &tablestore.PutRowChange{ + TableName: c.otsTable, + PrimaryKey: &tablestore.PrimaryKey{ + PrimaryKeys: []*tablestore.PrimaryKeyColumn{ + { + ColumnName: c.otsTabkePK.PKName, + Value: c.getPKValue(), + }, + }, + }, + Columns: []tablestore.AttributeColumn{ + { + ColumnName: "LockID", + Value: c.lockFile, + }, + { + ColumnName: "Info", + Value: string(info.Marshal()), + }, + }, + Condition: &tablestore.RowCondition{ + RowExistenceExpectation: tablestore.RowExistenceExpectation_EXPECT_NOT_EXIST, + }, } - if !exist { - if err := c.putObj(info.Path, infoJson); err != nil { - return "", err + + log.Printf("[DEBUG] Recoring state lock in tablestore: %#v", putParams) + + _, err := c.otsClient.PutRow(&tablestore.PutRowRequest{ + PutRowChange: putParams, + }) + if err != nil { + log.Printf("[WARN] Error storing state lock in tablestore: %#v", err) + lockInfo, infoErr := c.getLockInfo() + if infoErr != nil { + log.Printf("[WARN] Error getting lock info: %#v", err) + err = multierror.Append(err, infoErr) } - } else if _, err := c.validLock(info.ID); err != nil { - return "", err + lockErr := &state.LockError{ + Err: err, + Info: lockInfo, + } + log.Printf("[WARN] state lock error: %#v", lockErr) + return "", lockErr } return info.ID, nil } -func (c *RemoteClient) Unlock(id string) error { - c.mu.Lock() - defer c.mu.Unlock() +func (c *RemoteClient) getMD5() ([]byte, error) { + if c.otsTable == "" { + return nil, nil + } + + getParams := &tablestore.SingleRowQueryCriteria{ + TableName: c.otsTable, + PrimaryKey: &tablestore.PrimaryKey{ + PrimaryKeys: []*tablestore.PrimaryKeyColumn{ + { + ColumnName: c.otsTabkePK.PKName, + Value: c.getPKValue(), + }, + }, + }, + ColumnsToGet: []string{"LockID", "Digest"}, + MaxVersion: 1, + } - if !c.doLock { + log.Printf("[DEBUG] Retrieving state serial in tablestore: %#v", getParams) + + object, err := c.otsClient.GetRow(&tablestore.GetRowRequest{ + SingleRowQueryCriteria: getParams, + }) + + if err != nil { + return nil, err + } + + var val string + if v, ok := object.GetColumnMap().Columns["Digest"]; ok && len(v) > 0 { + val = v[0].Value.(string) + } + + sum, err := hex.DecodeString(val) + if err != nil || len(sum) != md5.Size { + return nil, errors.New("invalid md5") + } + + return sum, nil +} + +// store the hash of the state to that clients can check for stale state files. +func (c *RemoteClient) putMD5(sum []byte) error { + if c.otsTable == "" { return nil } - lockInfo, err := c.validLock(id) + if len(sum) != md5.Size { + return errors.New("invalid payload md5") + } + + putParams := &tablestore.PutRowChange{ + TableName: c.otsTable, + PrimaryKey: &tablestore.PrimaryKey{ + PrimaryKeys: []*tablestore.PrimaryKeyColumn{ + { + ColumnName: c.otsTabkePK.PKName, + Value: c.getPKValue(), + }, + }, + }, + Columns: []tablestore.AttributeColumn{ + { + ColumnName: "LockID", + Value: c.lockPath() + stateIDSuffix, + }, + { + ColumnName: "Digest", + Value: hex.EncodeToString(sum), + }, + }, + Condition: &tablestore.RowCondition{ + RowExistenceExpectation: tablestore.RowExistenceExpectation_EXPECT_NOT_EXIST, + }, + } + + log.Printf("[DEBUG] Recoring state serial in tablestore: %#v", putParams) + + _, err := c.otsClient.PutRow(&tablestore.PutRowRequest{ + PutRowChange: putParams, + }) + if err != nil { - return err + log.Printf("[WARN] failed to record state serial in tablestore: %s", err) } - if err := c.deleteObj(c.lockFile); err != nil { - return &state.LockError{ - Info: lockInfo, - Err: err, - } + return nil +} + +// remove the hash value for a deleted state +func (c *RemoteClient) deleteMD5() error { + if c.otsTable == "" { + return nil } + + params := &tablestore.DeleteRowRequest{ + DeleteRowChange: &tablestore.DeleteRowChange{ + TableName: c.otsTable, + PrimaryKey: &tablestore.PrimaryKey{ + PrimaryKeys: []*tablestore.PrimaryKeyColumn{ + { + ColumnName: c.otsTabkePK.PKName, + Value: c.getPKValue(), + }, + }, + }, + Condition: &tablestore.RowCondition{ + RowExistenceExpectation: tablestore.RowExistenceExpectation_EXPECT_EXIST, + }, + }, + } + + log.Printf("[DEBUG] Deleting state serial in tablestore: %#v", params) + + if _, err := c.otsClient.DeleteRow(params); err != nil { + return err + } + return nil } -func (c *RemoteClient) putObj(key string, data []byte) error { - bucket, err := c.ossClient.Bucket(c.bucketName) +func (c *RemoteClient) getLockInfo() (*state.LockInfo, error) { + getParams := &tablestore.SingleRowQueryCriteria{ + TableName: c.otsTable, + PrimaryKey: &tablestore.PrimaryKey{ + PrimaryKeys: []*tablestore.PrimaryKeyColumn{ + { + ColumnName: c.otsTabkePK.PKName, + Value: c.getPKValue(), + }, + }, + }, + ColumnsToGet: []string{"LockID", "Info"}, + MaxVersion: 1, + } + + log.Printf("[DEBUG] Retrieving state lock info from tablestore: %#v", getParams) + + object, err := c.otsClient.GetRow(&tablestore.GetRowRequest{ + SingleRowQueryCriteria: getParams, + }) if err != nil { - return fmt.Errorf("Error getting bucket: %#v", err) + return nil, err } - body := bytes.NewReader(data) - var options []oss.Option - if c.acl != "" { - options = append(options, oss.ACL(oss.ACLType(c.acl))) + var infoData string + if v, ok := object.GetColumnMap().Columns["Info"]; ok && len(v) > 0 { + infoData = v[0].Value.(string) } - options = append(options, oss.ContentType("application/json")) - if c.serverSideEncryption { - options = append(options, oss.ServerSideEncryption("AES256")) + lockInfo := &state.LockInfo{} + err = json.Unmarshal([]byte(infoData), lockInfo) + if err != nil { + return nil, err } - options = append(options, oss.ContentLength(int64(len(data)))) - - if body != nil { - if err := bucket.PutObject(key, body, options...); err != nil { - return fmt.Errorf("failed to upload %s: %#v", key, err) - } + return lockInfo, nil +} +func (c *RemoteClient) Unlock(id string) error { + if c.otsTable == "" { return nil } + + lockErr := &state.LockError{} + + lockInfo, err := c.getLockInfo() + if err != nil { + lockErr.Err = fmt.Errorf("failed to retrieve lock info: %s", err) + return lockErr + } + lockErr.Info = lockInfo + + if lockInfo.ID != id { + lockErr.Err = fmt.Errorf("lock id %q does not match existing lock", id) + return lockErr + } + params := &tablestore.DeleteRowRequest{ + DeleteRowChange: &tablestore.DeleteRowChange{ + TableName: c.otsTable, + PrimaryKey: &tablestore.PrimaryKey{ + PrimaryKeys: []*tablestore.PrimaryKeyColumn{ + { + ColumnName: c.otsTabkePK.PKName, + Value: c.getPKValue(), + }, + }, + }, + Condition: &tablestore.RowCondition{ + RowExistenceExpectation: tablestore.RowExistenceExpectation_EXPECT_EXIST, + }, + }, + } + + log.Printf("[DEBUG] Deleting state lock from tablestore: %#v", params) + + _, err = c.otsClient.DeleteRow(params) + + if err != nil { + lockErr.Err = err + return lockErr + } + return nil } -func (c *RemoteClient) getObj(key string) (*bytes.Buffer, error) { +func (c *RemoteClient) lockPath() string { + return fmt.Sprintf("%s/%s", c.bucketName, c.stateFile) +} + +func (c *RemoteClient) getObj() (*remote.Payload, error) { bucket, err := c.ossClient.Bucket(c.bucketName) if err != nil { - return nil, fmt.Errorf("Error getting bucket: %#v", err) + return nil, fmt.Errorf("Error getting bucket %s: %#v", c.bucketName, err) } - if exist, err := bucket.IsObjectExist(key); err != nil { - return nil, fmt.Errorf("Estimating object %s is exist got an error: %#v", key, err) + if exist, err := bucket.IsObjectExist(c.stateFile); err != nil { + return nil, fmt.Errorf("Estimating object %s is exist got an error: %#v", c.stateFile, err) } else if !exist { return nil, nil } var options []oss.Option - output, err := bucket.GetObject(key, options...) + output, err := bucket.GetObject(c.stateFile, options...) if err != nil { return nil, fmt.Errorf("Error getting object: %#v", err) } @@ -176,51 +443,42 @@ func (c *RemoteClient) getObj(key string) (*bytes.Buffer, error) { if _, err := io.Copy(buf, output); err != nil { return nil, fmt.Errorf("Failed to read remote state: %s", err) } - return buf, nil -} - -func (c *RemoteClient) deleteObj(key string) error { - bucket, err := c.ossClient.Bucket(c.bucketName) - if err != nil { - return fmt.Errorf("Error getting bucket: %#v", err) - } - - if err := bucket.DeleteObject(key); err != nil { - return fmt.Errorf("Error deleting object %s: %#v", key, err) + sum := md5.Sum(buf.Bytes()) + payload := &remote.Payload{ + Data: buf.Bytes(), + MD5: sum[:], } - return nil -} -// lockInfo reads the lock file, parses its contents and returns the parsed -// LockInfo struct. -func (c *RemoteClient) lockInfo() (*state.LockInfo, error) { - buf, err := c.getObj(c.lockFile) - if err != nil { - return nil, err - } - if buf == nil || len(buf.Bytes()) == 0 { + // If there was no data, then return nil + if len(payload.Data) == 0 { return nil, nil } - info := &state.LockInfo{} - if err := json.Unmarshal(buf.Bytes(), info); err != nil { - return nil, err - } - return info, nil + return payload, nil } -func (c *RemoteClient) validLock(id string) (*state.LockInfo, *state.LockError) { - lockErr := &state.LockError{} - lockInfo, err := c.lockInfo() - if err != nil { - lockErr.Err = fmt.Errorf("failed to retrieve lock info: %s", err) - return nil, lockErr +func (c *RemoteClient) getPKValue() (value interface{}) { + value = statePKValue + if c.otsTabkePK.PKType == "Integer" { + value = hashcode.String(statePKValue) + } else if c.otsTabkePK.PKType == "Binary" { + value = stringToBin(statePKValue) } - lockErr.Info = lockInfo + return +} - if lockInfo.ID != id { - lockErr.Err = fmt.Errorf("lock id %q does not match existing lock", id) - return nil, lockErr +func stringToBin(s string) (binString string) { + for _, c := range s { + binString = fmt.Sprintf("%s%b", binString, c) } - return lockInfo, nil + return } + +const errBadChecksumFmt = `state data in OSS does not have the expected content. + +This may be caused by unusually long delays in OSS processing a previous state +update. Please wait for a minute or two and try again. If this problem +persists, and neither OSS nor TableStore are experiencing an outage, you may need +to manually verify the remote state and update the Digest value stored in the +TableStore table to the following value: %x +` diff --git a/backend/remote-state/oss/client_test.go b/backend/remote-state/oss/client_test.go index a24dd0216cb2..b736ae8de9a5 100644 --- a/backend/remote-state/oss/client_test.go +++ b/backend/remote-state/oss/client_test.go @@ -2,14 +2,21 @@ package oss import ( "fmt" + "strings" "testing" "time" + "bytes" + "crypto/md5" "github.com/hashicorp/terraform/backend" "github.com/hashicorp/terraform/state" "github.com/hashicorp/terraform/state/remote" + "github.com/hashicorp/terraform/states/statefile" ) +// NOTE: Before running this testcase, please create a OTS instance called 'tf-oss-remote' +var RemoteTestUsedOTSEndpoint = "https://daafafdasdsf.cn-hangzhou.ots.aliyuncs.com" + func TestRemoteClient_impl(t *testing.T) { var _ remote.Client = new(RemoteClient) var _ remote.ClientLocker = new(RemoteClient) @@ -17,12 +24,12 @@ func TestRemoteClient_impl(t *testing.T) { func TestRemoteClient(t *testing.T) { testACC(t) - bucketName := fmt.Sprintf("terraform-remote-oss-test-%x", time.Now().Unix()) + bucketName := fmt.Sprintf("tf-remote-oss-test-%x", time.Now().Unix()) path := "testState" b := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{ "bucket": bucketName, - "path": path, + "prefix": path, "encrypt": true, })).(*Backend) @@ -37,76 +44,287 @@ func TestRemoteClient(t *testing.T) { remote.TestClient(t, state.(*remote.State).Client) } -func TestOSS_stateLock(t *testing.T) { +func TestRemoteClientLocks(t *testing.T) { testACC(t) - bucketName := fmt.Sprintf("terraform-remote-oss-test-%x", time.Now().Unix()) + bucketName := fmt.Sprintf("tf-remote-oss-test-%x", time.Now().Unix()) + tableName := fmt.Sprintf("tfRemoteTestForce%x", time.Now().Unix()) path := "testState" b1 := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{ - "bucket": bucketName, - "path": path, - "encrypt": true, + "bucket": bucketName, + "prefix": path, + "encrypt": true, + "tablestore_table": tableName, + "tablestore_endpoint": RemoteTestUsedOTSEndpoint, })).(*Backend) b2 := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{ - "bucket": bucketName, - "path": path, - "encrypt": true, + "bucket": bucketName, + "prefix": path, + "encrypt": true, + "tablestore_table": tableName, + "tablestore_endpoint": RemoteTestUsedOTSEndpoint, })).(*Backend) createOSSBucket(t, b1.ossClient, bucketName) defer deleteOSSBucket(t, b1.ossClient, bucketName) + createTablestoreTable(t, b1.otsClient, tableName) + defer deleteTablestoreTable(t, b1.otsClient, tableName) s1, err := b1.StateMgr(backend.DefaultStateName) if err != nil { - t.Fatalf("err: %s", err) + t.Fatal(err) } s2, err := b2.StateMgr(backend.DefaultStateName) if err != nil { - t.Fatalf("err: %s", err) + t.Fatal(err) } remote.TestRemoteLocks(t, s1.(*remote.State).Client, s2.(*remote.State).Client) } // verify that we can unlock a state with an existing lock -func TestOSS_destroyLock(t *testing.T) { +func TestRemoteForceUnlock(t *testing.T) { testACC(t) - bucketName := fmt.Sprintf("terraform-remote-oss-test-%x", time.Now().Unix()) + bucketName := fmt.Sprintf("tf-remote-oss-test-force-%x", time.Now().Unix()) + tableName := fmt.Sprintf("tfRemoteTestForce%x", time.Now().Unix()) + path := "testState" + + b1 := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{ + "bucket": bucketName, + "prefix": path, + "encrypt": true, + "tablestore_table": tableName, + "tablestore_endpoint": RemoteTestUsedOTSEndpoint, + })).(*Backend) + + b2 := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{ + "bucket": bucketName, + "prefix": path, + "encrypt": true, + "tablestore_table": tableName, + "tablestore_endpoint": RemoteTestUsedOTSEndpoint, + })).(*Backend) + + createOSSBucket(t, b1.ossClient, bucketName) + defer deleteOSSBucket(t, b1.ossClient, bucketName) + createTablestoreTable(t, b1.otsClient, tableName) + defer deleteTablestoreTable(t, b1.otsClient, tableName) + + // first test with default + s1, err := b1.StateMgr(backend.DefaultStateName) + if err != nil { + t.Fatal(err) + } + + info := state.NewLockInfo() + info.Operation = "test" + info.Who = "clientA" + + lockID, err := s1.Lock(info) + if err != nil { + t.Fatal("unable to get initial lock:", err) + } + + // s1 is now locked, get the same state through s2 and unlock it + s2, err := b2.StateMgr(backend.DefaultStateName) + if err != nil { + t.Fatal("failed to get default state to force unlock:", err) + } + + if err := s2.Unlock(lockID); err != nil { + t.Fatal("failed to force-unlock default state") + } + + // now try the same thing with a named state + // first test with default + s1, err = b1.StateMgr("test") + if err != nil { + t.Fatal(err) + } + + info = state.NewLockInfo() + info.Operation = "test" + info.Who = "clientA" + + lockID, err = s1.Lock(info) + if err != nil { + t.Fatal("unable to get initial lock:", err) + } + + // s1 is now locked, get the same state through s2 and unlock it + s2, err = b2.StateMgr("test") + if err != nil { + t.Fatal("failed to get named state to force unlock:", err) + } + + if err = s2.Unlock(lockID); err != nil { + t.Fatal("failed to force-unlock named state") + } +} + +func TestRemoteClient_clientMD5(t *testing.T) { + testACC(t) + + bucketName := fmt.Sprintf("tf-remote-oss-test-%x", time.Now().Unix()) + tableName := fmt.Sprintf("tfRemoteTestForce%x", time.Now().Unix()) path := "testState" b := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{ - "bucket": bucketName, - "path": path, - "encrypt": true, + "bucket": bucketName, + "prefix": path, + "tablestore_table": tableName, + "tablestore_endpoint": RemoteTestUsedOTSEndpoint, })).(*Backend) createOSSBucket(t, b.ossClient, bucketName) defer deleteOSSBucket(t, b.ossClient, bucketName) + createTablestoreTable(t, b.otsClient, tableName) + defer deleteTablestoreTable(t, b.otsClient, tableName) s, err := b.StateMgr(backend.DefaultStateName) if err != nil { - t.Fatalf("err: %s", err) + t.Fatal(err) } + client := s.(*remote.State).Client.(*RemoteClient) - c := s.(*remote.State).Client.(*RemoteClient) + sum := md5.Sum([]byte("test")) - info := state.NewLockInfo() - id, err := c.Lock(info) + if err := client.putMD5(sum[:]); err != nil { + t.Fatal(err) + } + + getSum, err := client.getMD5() if err != nil { - t.Fatalf("err: %s", err) + t.Fatal(err) + } + + if !bytes.Equal(getSum, sum[:]) { + t.Fatalf("getMD5 returned the wrong checksum: expected %x, got %x", sum[:], getSum) + } + + if err := client.deleteMD5(); err != nil { + t.Fatal(err) + } + + if getSum, err := client.getMD5(); err == nil { + t.Fatalf("expected getMD5 error, got none. checksum: %x", getSum) + } +} + +// verify that a client won't return a state with an incorrect checksum. +func TestRemoteClient_stateChecksum(t *testing.T) { + testACC(t) + + bucketName := fmt.Sprintf("tf-remote-oss-test-%x", time.Now().Unix()) + tableName := fmt.Sprintf("tfRemoteTestForce%x", time.Now().Unix()) + path := "testState" + + b1 := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{ + "bucket": bucketName, + "prefix": path, + "tablestore_table": tableName, + "tablestore_endpoint": RemoteTestUsedOTSEndpoint, + })).(*Backend) + + createOSSBucket(t, b1.ossClient, bucketName) + defer deleteOSSBucket(t, b1.ossClient, bucketName) + createTablestoreTable(t, b1.otsClient, tableName) + defer deleteTablestoreTable(t, b1.otsClient, tableName) + + s1, err := b1.StateMgr(backend.DefaultStateName) + if err != nil { + t.Fatal(err) } + client1 := s1.(*remote.State).Client - if err := c.Unlock(id); err != nil { - t.Fatalf("err: %s", err) + // create an old and new state version to persist + s := state.TestStateInitial() + sf := &statefile.File{State: s} + var oldState bytes.Buffer + if err := statefile.Write(sf, &oldState); err != nil { + t.Fatal(err) + } + sf.Serial++ + var newState bytes.Buffer + if err := statefile.Write(sf, &newState); err != nil { + t.Fatal(err) } - res, err := c.getObj(c.lockFile) + // Use b2 without a tablestore_table to bypass the lock table to write the state directly. + // client2 will write the "incorrect" state, simulating oss eventually consistency delays + b2 := backend.TestBackendConfig(t, New(), backend.TestWrapConfig(map[string]interface{}{ + "bucket": bucketName, + "prefix": path, + })).(*Backend) + s2, err := b2.StateMgr(backend.DefaultStateName) if err != nil { - t.Fatalf("err: %s", err) + t.Fatal(err) + } + client2 := s2.(*remote.State).Client + + // write the new state through client2 so that there is no checksum yet + if err := client2.Put(newState.Bytes()); err != nil { + t.Fatal(err) + } + + // verify that we can pull a state without a checksum + if _, err := client1.Get(); err != nil { + t.Fatal(err) + } + + // write the new state back with its checksum + if err := client1.Put(newState.Bytes()); err != nil { + t.Fatal(err) + } + + // put an empty state in place to check for panics during get + if err := client2.Put([]byte{}); err != nil { + t.Fatal(err) + } + + // remove the timeouts so we can fail immediately + origTimeout := consistencyRetryTimeout + origInterval := consistencyRetryPollInterval + defer func() { + consistencyRetryTimeout = origTimeout + consistencyRetryPollInterval = origInterval + }() + consistencyRetryTimeout = 0 + consistencyRetryPollInterval = 0 + + // fetching an empty state through client1 should now error out due to a + // mismatched checksum. + if _, err := client1.Get(); !strings.HasPrefix(err.Error(), errBadChecksumFmt[:80]) { + t.Fatalf("expected state checksum error: got %s", err) + } + + // put the old state in place of the new, without updating the checksum + if err := client2.Put(oldState.Bytes()); err != nil { + t.Fatal(err) } - if res != nil && res.String() != "" { - t.Fatalf("lock key not cleaned up at: %s", string(c.stateFile)) + + // fetching the wrong state through client1 should now error out due to a + // mismatched checksum. + if _, err := client1.Get(); !strings.HasPrefix(err.Error(), errBadChecksumFmt[:80]) { + t.Fatalf("expected state checksum error: got %s", err) + } + + // update the state with the correct one after we Get again + testChecksumHook = func() { + if err := client2.Put(newState.Bytes()); err != nil { + t.Fatal(err) + } + testChecksumHook = nil + } + + consistencyRetryTimeout = origTimeout + + // this final Get will fail to fail the checksum verification, the above + // callback will update the state with the correct version, and Get should + // retry automatically. + if _, err := client1.Get(); err != nil { + t.Fatal(err) } } diff --git a/config/resource_mode_string.go b/config/resource_mode_string.go index 8a55e0603e90..010527824007 100644 --- a/config/resource_mode_string.go +++ b/config/resource_mode_string.go @@ -4,6 +4,14 @@ package config import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[ManagedResourceMode-0] + _ = x[DataResourceMode-1] +} + const _ResourceMode_name = "ManagedResourceModeDataResourceMode" var _ResourceMode_index = [...]uint8{0, 19, 35} diff --git a/configs/configschema/nestingmode_string.go b/configs/configschema/nestingmode_string.go index 6cb9313e260b..862f954f0e08 100644 --- a/configs/configschema/nestingmode_string.go +++ b/configs/configschema/nestingmode_string.go @@ -4,6 +4,17 @@ package configschema import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[nestingModeInvalid-0] + _ = x[NestingSingle-1] + _ = x[NestingList-2] + _ = x[NestingSet-3] + _ = x[NestingMap-4] +} + const _NestingMode_name = "nestingModeInvalidNestingSingleNestingListNestingSetNestingMap" var _NestingMode_index = [...]uint8{0, 18, 31, 42, 52, 62} diff --git a/configs/provisioneronfailure_string.go b/configs/provisioneronfailure_string.go index 8704b0861c36..7ff5a6e00b55 100644 --- a/configs/provisioneronfailure_string.go +++ b/configs/provisioneronfailure_string.go @@ -4,6 +4,15 @@ package configs import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[ProvisionerOnFailureInvalid-0] + _ = x[ProvisionerOnFailureContinue-1] + _ = x[ProvisionerOnFailureFail-2] +} + const _ProvisionerOnFailure_name = "ProvisionerOnFailureInvalidProvisionerOnFailureContinueProvisionerOnFailureFail" var _ProvisionerOnFailure_index = [...]uint8{0, 27, 55, 79} diff --git a/configs/provisionerwhen_string.go b/configs/provisionerwhen_string.go index cbecb20ae186..9f21b3ac636e 100644 --- a/configs/provisionerwhen_string.go +++ b/configs/provisionerwhen_string.go @@ -4,6 +4,15 @@ package configs import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[ProvisionerWhenInvalid-0] + _ = x[ProvisionerWhenCreate-1] + _ = x[ProvisionerWhenDestroy-2] +} + const _ProvisionerWhen_name = "ProvisionerWhenInvalidProvisionerWhenCreateProvisionerWhenDestroy" var _ProvisionerWhen_index = [...]uint8{0, 22, 43, 65} diff --git a/configs/variabletypehint_string.go b/configs/variabletypehint_string.go index 4447cf5562bf..2b50428ce122 100644 --- a/configs/variabletypehint_string.go +++ b/configs/variabletypehint_string.go @@ -4,6 +4,16 @@ package configs import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[TypeHintNone-0] + _ = x[TypeHintString-83] + _ = x[TypeHintList-76] + _ = x[TypeHintMap-77] +} + const ( _VariableTypeHint_name_0 = "TypeHintNone" _VariableTypeHint_name_1 = "TypeHintListTypeHintMap" diff --git a/go.mod b/go.mod index 150fd5bff365..35a7d34315d8 100644 --- a/go.mod +++ b/go.mod @@ -8,14 +8,16 @@ require ( github.com/abdullin/seq v0.0.0-20160510034733-d5467c17e7af // indirect github.com/agext/levenshtein v1.2.2 github.com/agl/ed25519 v0.0.0-20150830182803-278e1ec8e8a6 // indirect - github.com/aliyun/alibaba-cloud-sdk-go v0.0.0-20190104080739-ef2ef6084d8f + github.com/aliyun/alibaba-cloud-sdk-go v0.0.0-20190329064014-6e358769c32a github.com/aliyun/aliyun-oss-go-sdk v0.0.0-20190103054945-8205d1f41e70 + github.com/aliyun/aliyun-tablestore-go-sdk v4.1.2+incompatible github.com/apparentlymart/go-cidr v1.0.0 github.com/apparentlymart/go-dump v0.0.0-20190214190832-042adf3cf4a0 github.com/armon/circbuf v0.0.0-20190214190532-5111143e8da2 github.com/armon/go-metrics v0.0.0-20180917152333-f0300d1749da // indirect github.com/armon/go-radix v1.0.0 // indirect github.com/aws/aws-sdk-go v1.16.36 + github.com/baiyubin/aliyun-sts-go-sdk v0.0.0-20180326062324-cfa1a18b161f // indirect github.com/blang/semver v3.5.1+incompatible github.com/boltdb/bolt v1.3.1 // indirect github.com/chzyer/logex v1.1.10 // indirect @@ -97,7 +99,7 @@ require ( github.com/modern-go/reflect2 v1.0.1 // indirect github.com/packer-community/winrmcp v0.0.0-20180102160824-81144009af58 github.com/pascaldekloe/goe v0.0.0-20180627143212-57f6aae5913c // indirect - github.com/pkg/errors v0.0.0-20170505043639-c605e284fe17 // indirect + github.com/pkg/errors v0.0.0-20170505043639-c605e284fe17 github.com/posener/complete v1.2.1 github.com/sean-/seed v0.0.0-20170313163322-e2103e2c3529 // indirect github.com/sirupsen/logrus v1.1.1 // indirect @@ -121,5 +123,8 @@ require ( golang.org/x/oauth2 v0.0.0-20190220154721-9b3c75971fc9 google.golang.org/api v0.1.0 google.golang.org/grpc v1.18.0 + gopkg.in/ini.v1 v1.42.0 // indirect gopkg.in/vmihailenco/msgpack.v2 v2.9.1 // indirect + labix.org/v2/mgo v0.0.0-20140701140051-000000000287 // indirect + launchpad.net/gocheck v0.0.0-20140225173054-000000000087 // indirect ) diff --git a/go.sum b/go.sum index ecb374aac7e7..aa9f789bf54c 100644 --- a/go.sum +++ b/go.sum @@ -28,10 +28,12 @@ github.com/agext/levenshtein v1.2.2 h1:0S/Yg6LYmFJ5stwQeRp6EeOcCbj7xiqQSdNelsXva github.com/agext/levenshtein v1.2.2/go.mod h1:JEDfjyjHDjOF/1e4FlBE/PkbqA9OfWu2ki2W0IB5558= github.com/agl/ed25519 v0.0.0-20150830182803-278e1ec8e8a6 h1:LoeFxdq5zUCBQPhbQKE6zvoGwHMxCBlqwbH9+9kHoHA= github.com/agl/ed25519 v0.0.0-20150830182803-278e1ec8e8a6/go.mod h1:WPjqKcmVOxf0XSf3YxCJs6N6AOSrOx3obionmG7T0y0= -github.com/aliyun/alibaba-cloud-sdk-go v0.0.0-20190104080739-ef2ef6084d8f h1:pM8wn2zKfEVQkR9cj//GkywiJXMwtZ9feuNsEkHqBC8= -github.com/aliyun/alibaba-cloud-sdk-go v0.0.0-20190104080739-ef2ef6084d8f/go.mod h1:T9M45xf79ahXVelWoOBmH0y4aC1t5kXO5BxwyakgIGA= +github.com/aliyun/alibaba-cloud-sdk-go v0.0.0-20190329064014-6e358769c32a h1:APorzFpCcv6wtD5vmRWYqNm4N55kbepL7c7kTq9XI6A= +github.com/aliyun/alibaba-cloud-sdk-go v0.0.0-20190329064014-6e358769c32a/go.mod h1:T9M45xf79ahXVelWoOBmH0y4aC1t5kXO5BxwyakgIGA= github.com/aliyun/aliyun-oss-go-sdk v0.0.0-20190103054945-8205d1f41e70 h1:FrF4uxA24DF3ARNXVbUin3wa5fDLaB1Cy8mKks/LRz4= github.com/aliyun/aliyun-oss-go-sdk v0.0.0-20190103054945-8205d1f41e70/go.mod h1:T/Aws4fEfogEE9v+HPhhw+CntffsBHJ8nXQCwKr0/g8= +github.com/aliyun/aliyun-tablestore-go-sdk v4.1.2+incompatible h1:ABQ7FF+IxSFHDMOTtjCfmMDMHiCq6EsAoCV/9sFinaM= +github.com/aliyun/aliyun-tablestore-go-sdk v4.1.2+incompatible/go.mod h1:LDQHRZylxvcg8H7wBIDfvO5g/cy4/sz1iucBlc2l3Jw= github.com/anmitsu/go-shlex v0.0.0-20161002113705-648efa622239/go.mod h1:2FmKhYUyUczH0OGQWaF5ceTx0UBShxjsH6f8oGKYe2c= github.com/antchfx/xpath v0.0.0-20190129040759-c8489ed3251e h1:ptBAamGVd6CfRsUtyHD+goy2JGhv1QC32v3gqM8mYAM= github.com/antchfx/xpath v0.0.0-20190129040759-c8489ed3251e/go.mod h1:Yee4kTMuNiPYJ7nSNorELQMr1J33uOpXDMByNYhvtNk= @@ -55,6 +57,8 @@ github.com/armon/go-radix v1.0.0/go.mod h1:ufUuZ+zHj4x4TnLV4JWEpy2hxWSpsRywHrMgI github.com/aws/aws-sdk-go v1.15.78/go.mod h1:E3/ieXAlvM0XWO57iftYVDLLvQ824smPP3ATZkfNZeM= github.com/aws/aws-sdk-go v1.16.36 h1:POeH34ZME++pr7GBGh+ZO6Y5kOwSMQpqp5BGUgooJ6k= github.com/aws/aws-sdk-go v1.16.36/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo= +github.com/baiyubin/aliyun-sts-go-sdk v0.0.0-20180326062324-cfa1a18b161f h1:ZNv7On9kyUzm7fvRZumSyy/IUiSC7AzL0I1jKKtwooA= +github.com/baiyubin/aliyun-sts-go-sdk v0.0.0-20180326062324-cfa1a18b161f/go.mod h1:AuiFmCCPBSrqvVMvuqFuk0qogytodnVFVSN5CeJB8Gc= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973 h1:xJ4a3vCFaGF/jqvzLMYoU8P317H5OQ+Via4RmuPwCS0= github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q= github.com/bgentry/go-netrc v0.0.0-20140422174119-9fd32a8b3d3d h1:xDfNPAt8lFiC1UJrqV3uuy861HCTo708pDMbjHHdCas= @@ -510,6 +514,8 @@ gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8 gopkg.in/cheggaaa/pb.v1 v1.0.27/go.mod h1:V/YB90LKu/1FcN3WVnfiiE5oMCibMjukxqG/qStrOgw= gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys= gopkg.in/inf.v0 v0.9.1/go.mod h1:cWUDdTG/fYaXco+Dcufb5Vnc6Gp2YChqWtbxRZE0mXw= +gopkg.in/ini.v1 v1.42.0 h1:7N3gPTt50s8GuLortA00n8AqRTk75qOP98+mTPpgzRk= +gopkg.in/ini.v1 v1.42.0/go.mod h1:pNLf8WUiyNEtQjuu5G5vTm06TEv9tsIgeAvK8hOrP4k= gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw= gopkg.in/vmihailenco/msgpack.v2 v2.9.1 h1:kb0VV7NuIojvRfzwslQeP3yArBqJHW9tOl4t38VS1jM= gopkg.in/vmihailenco/msgpack.v2 v2.9.1/go.mod h1:/3Dn1Npt9+MYyLpYYXjInO/5jvMLamn+AEGwNEOatn8= @@ -520,5 +526,9 @@ grpc.go4.org v0.0.0-20170609214715-11d0a25b4919/go.mod h1:77eQGdRu53HpSqPFJFmuJd honnef.co/go/tools v0.0.0-20180728063816-88497007e858/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= honnef.co/go/tools v0.0.0-20190106161140-3f1c8253044a/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4= howett.net/plist v0.0.0-20181124034731-591f970eefbb/go.mod h1:vMygbs4qMhSZSc4lCUl2OEE+rDiIIJAIdR4m7MiMcm0= +labix.org/v2/mgo v0.0.0-20140701140051-000000000287 h1:L0cnkNl4TfAXzvdrqsYEmxOHOCv2p5I3taaReO8BWFs= +labix.org/v2/mgo v0.0.0-20140701140051-000000000287/go.mod h1:Lg7AYkt1uXJoR9oeSZ3W/8IXLdvOfIITgZnommstyz4= +launchpad.net/gocheck v0.0.0-20140225173054-000000000087 h1:Izowp2XBH6Ya6rv+hqbceQyw/gSGoXfH/UPoTGduL54= +launchpad.net/gocheck v0.0.0-20140225173054-000000000087/go.mod h1:hj7XX3B/0A+80Vse0e+BUHsHMTEhd0O4cpUHr/e/BUM= sourcegraph.com/sourcegraph/go-diff v0.5.0/go.mod h1:kuch7UrkMzY0X+p9CRK03kfuPQ2zzQcaEFbx8wA8rck= sourcegraph.com/sqs/pbtypes v0.0.0-20180604144634-d3ebe8f20ae4/go.mod h1:ketZ/q3QxT9HOBeFhu6RdvsftgpsbFHBF5Cas6cDKZ0= diff --git a/helper/schema/getsource_string.go b/helper/schema/getsource_string.go index 38cd8c70d03c..0184d7b08abd 100644 --- a/helper/schema/getsource_string.go +++ b/helper/schema/getsource_string.go @@ -4,6 +4,18 @@ package schema import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[getSourceState-1] + _ = x[getSourceConfig-2] + _ = x[getSourceDiff-4] + _ = x[getSourceSet-8] + _ = x[getSourceExact-16] + _ = x[getSourceLevelMask-15] +} + const ( _getSource_name_0 = "getSourceStategetSourceConfig" _getSource_name_1 = "getSourceDiff" diff --git a/helper/schema/valuetype_string.go b/helper/schema/valuetype_string.go index 3bc3ac455ea1..914ca32cbe09 100644 --- a/helper/schema/valuetype_string.go +++ b/helper/schema/valuetype_string.go @@ -4,6 +4,21 @@ package schema import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[TypeInvalid-0] + _ = x[TypeBool-1] + _ = x[TypeInt-2] + _ = x[TypeFloat-3] + _ = x[TypeString-4] + _ = x[TypeList-5] + _ = x[TypeMap-6] + _ = x[TypeSet-7] + _ = x[typeObject-8] +} + const _ValueType_name = "TypeInvalidTypeBoolTypeIntTypeFloatTypeStringTypeListTypeMapTypeSettypeObject" var _ValueType_index = [...]uint8{0, 11, 19, 26, 35, 45, 53, 60, 67, 77} diff --git a/plans/action_string.go b/plans/action_string.go index c79465a2ae9d..be43ab1757b7 100644 --- a/plans/action_string.go +++ b/plans/action_string.go @@ -4,6 +4,19 @@ package plans import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[NoOp-0] + _ = x[Create-43] + _ = x[Read-8592] + _ = x[Update-126] + _ = x[DeleteThenCreate-8723] + _ = x[CreateThenDelete-177] + _ = x[Delete-45] +} + const ( _Action_name_0 = "NoOp" _Action_name_1 = "Create" diff --git a/states/eachmode_string.go b/states/eachmode_string.go index 6de61802fbbc..0dc73499a333 100644 --- a/states/eachmode_string.go +++ b/states/eachmode_string.go @@ -4,6 +4,15 @@ package states import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[NoEach-0] + _ = x[EachList-76] + _ = x[EachMap-77] +} + const ( _EachMode_name_0 = "NoEach" _EachMode_name_1 = "EachListEachMap" diff --git a/states/objectstatus_string.go b/states/objectstatus_string.go index cd6d12849af3..96a6db2f4c4a 100644 --- a/states/objectstatus_string.go +++ b/states/objectstatus_string.go @@ -4,6 +4,15 @@ package states import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[ObjectReady-82] + _ = x[ObjectTainted-84] + _ = x[ObjectPlanned-80] +} + const ( _ObjectStatus_name_0 = "ObjectPlanned" _ObjectStatus_name_1 = "ObjectReady" diff --git a/states/statemgr/snapshotmetarel_string.go b/states/statemgr/snapshotmetarel_string.go index 28e1b966f94f..a5b66138cfee 100644 --- a/states/statemgr/snapshotmetarel_string.go +++ b/states/statemgr/snapshotmetarel_string.go @@ -4,6 +4,17 @@ package statemgr import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[SnapshotOlder-60] + _ = x[SnapshotNewer-62] + _ = x[SnapshotEqual-61] + _ = x[SnapshotUnrelated-33] + _ = x[SnapshotLegacy-63] +} + const ( _SnapshotMetaRel_name_0 = "SnapshotUnrelated" _SnapshotMetaRel_name_1 = "SnapshotOlderSnapshotEqualSnapshotNewerSnapshotLegacy" diff --git a/terraform/graphtype_string.go b/terraform/graphtype_string.go index 855ef7b1271e..b51e1a266176 100644 --- a/terraform/graphtype_string.go +++ b/terraform/graphtype_string.go @@ -4,6 +4,20 @@ package terraform import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[GraphTypeInvalid-0] + _ = x[GraphTypeLegacy-1] + _ = x[GraphTypeRefresh-2] + _ = x[GraphTypePlan-3] + _ = x[GraphTypePlanDestroy-4] + _ = x[GraphTypeApply-5] + _ = x[GraphTypeValidate-6] + _ = x[GraphTypeEval-7] +} + const _GraphType_name = "GraphTypeInvalidGraphTypeLegacyGraphTypeRefreshGraphTypePlanGraphTypePlanDestroyGraphTypeApplyGraphTypeValidateGraphTypeEval" var _GraphType_index = [...]uint8{0, 16, 31, 47, 60, 80, 94, 111, 124} diff --git a/terraform/instancetype_string.go b/terraform/instancetype_string.go index b8e7d1fb910d..95b7a9802e51 100644 --- a/terraform/instancetype_string.go +++ b/terraform/instancetype_string.go @@ -4,6 +4,16 @@ package terraform import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[TypeInvalid-0] + _ = x[TypePrimary-1] + _ = x[TypeTainted-2] + _ = x[TypeDeposed-3] +} + const _InstanceType_name = "TypeInvalidTypePrimaryTypeTaintedTypeDeposed" var _InstanceType_index = [...]uint8{0, 11, 22, 33, 44} diff --git a/terraform/valuesourcetype_string.go b/terraform/valuesourcetype_string.go index 1380c851f910..627593d762b5 100644 --- a/terraform/valuesourcetype_string.go +++ b/terraform/valuesourcetype_string.go @@ -4,6 +4,21 @@ package terraform import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[ValueFromUnknown-0] + _ = x[ValueFromConfig-67] + _ = x[ValueFromAutoFile-70] + _ = x[ValueFromNamedFile-78] + _ = x[ValueFromCLIArg-65] + _ = x[ValueFromEnvVar-69] + _ = x[ValueFromInput-73] + _ = x[ValueFromPlan-80] + _ = x[ValueFromCaller-83] +} + const ( _ValueSourceType_name_0 = "ValueFromUnknown" _ValueSourceType_name_1 = "ValueFromCLIArg" diff --git a/terraform/walkoperation_string.go b/terraform/walkoperation_string.go index a802b5286e6d..0666aa5f3fff 100644 --- a/terraform/walkoperation_string.go +++ b/terraform/walkoperation_string.go @@ -4,6 +4,21 @@ package terraform import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[walkInvalid-0] + _ = x[walkApply-1] + _ = x[walkPlan-2] + _ = x[walkPlanDestroy-3] + _ = x[walkRefresh-4] + _ = x[walkValidate-5] + _ = x[walkDestroy-6] + _ = x[walkImport-7] + _ = x[walkEval-8] +} + const _walkOperation_name = "walkInvalidwalkApplywalkPlanwalkPlanDestroywalkRefreshwalkValidatewalkDestroywalkImportwalkEval" var _walkOperation_index = [...]uint8{0, 11, 20, 28, 43, 54, 66, 77, 87, 95} diff --git a/tfdiags/severity_string.go b/tfdiags/severity_string.go index 0b1249bbef94..78a721068c31 100644 --- a/tfdiags/severity_string.go +++ b/tfdiags/severity_string.go @@ -4,6 +4,14 @@ package tfdiags import "strconv" +func _() { + // An "invalid array index" compiler error signifies that the constant values have changed. + // Re-run the stringer command to generate them again. + var x [1]struct{} + _ = x[Error-69] + _ = x[Warning-87] +} + const ( _Severity_name_0 = "Error" _Severity_name_1 = "Warning" diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/bearer_token_credential.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/bearer_token_credential.go new file mode 100644 index 000000000000..6d4763e663fe --- /dev/null +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/bearer_token_credential.go @@ -0,0 +1,12 @@ +package credentials + +type BearerTokenCredential struct { + BearerToken string +} + +// NewBearerTokenCredential return a BearerTokenCredential object +func NewBearerTokenCredential(token string) *BearerTokenCredential { + return &BearerTokenCredential{ + BearerToken: token, + } +} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/ecs_ram_role.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/ecs_ram_role.go index 1e1f73ae4a64..55a5c2da0367 100644 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/ecs_ram_role.go +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/ecs_ram_role.go @@ -1,17 +1,5 @@ package credentials -// Deprecated: Use EcsRamRoleCredential in this package instead. -type StsRoleNameOnEcsCredential struct { - RoleName string -} - -// Deprecated: Use NewEcsRamRoleCredential in this package instead. -func NewStsRoleNameOnEcsCredential(roleName string) *StsRoleNameOnEcsCredential { - return &StsRoleNameOnEcsCredential{ - RoleName: roleName, - } -} - func (oldCred *StsRoleNameOnEcsCredential) ToEcsRamRoleCredential() *EcsRamRoleCredential { return &EcsRamRoleCredential{ RoleName: oldCred.RoleName, @@ -27,3 +15,15 @@ func NewEcsRamRoleCredential(roleName string) *EcsRamRoleCredential { RoleName: roleName, } } + +// Deprecated: Use EcsRamRoleCredential in this package instead. +type StsRoleNameOnEcsCredential struct { + RoleName string +} + +// Deprecated: Use NewEcsRamRoleCredential in this package instead. +func NewStsRoleNameOnEcsCredential(roleName string) *StsRoleNameOnEcsCredential { + return &StsRoleNameOnEcsCredential{ + RoleName: roleName, + } +} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider/env.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider/env.go new file mode 100644 index 000000000000..3cd0d020a75d --- /dev/null +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider/env.go @@ -0,0 +1,30 @@ +package provider + +import ( + "errors" + "os" + + "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials" + + "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth" +) + +type EnvProvider struct{} + +var ProviderEnv = new(EnvProvider) + +func NewEnvProvider() Provider { + return &EnvProvider{} +} + +func (p *EnvProvider) Resolve() (auth.Credential, error) { + accessKeyID, ok1 := os.LookupEnv(ENVAccessKeyID) + accessKeySecret, ok2 := os.LookupEnv(ENVAccessKeySecret) + if !ok1 || !ok2 { + return nil, nil + } + if accessKeyID == "" || accessKeySecret == "" { + return nil, errors.New("Environmental variable (ALIBABACLOUD_ACCESS_KEY_ID or ALIBABACLOUD_ACCESS_KEY_SECRET) is empty") + } + return credentials.NewAccessKeyCredential(accessKeyID, accessKeySecret), nil +} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider/instance_credentials.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider/instance_credentials.go new file mode 100644 index 000000000000..1906d21f67de --- /dev/null +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider/instance_credentials.go @@ -0,0 +1,92 @@ +package provider + +import ( + "encoding/json" + "errors" + "fmt" + "io/ioutil" + "net/http" + "os" + "time" + + "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth" + "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials" +) + +var securityCredURL = "http://100.100.100.200/latest/meta-data/ram/security-credentials/" + +type InstanceCredentialsProvider struct{} + +var ProviderInstance = new(InstanceCredentialsProvider) + +var HookGet = func(fn func(string) (int, []byte, error)) func(string) (int, []byte, error) { + return fn +} + +func NewInstanceCredentialsProvider() Provider { + return &InstanceCredentialsProvider{} +} + +func (p *InstanceCredentialsProvider) Resolve() (auth.Credential, error) { + roleName, ok := os.LookupEnv(ENVEcsMetadata) + if !ok { + return nil, nil + } + if roleName == "" { + return nil, errors.New("Environmental variable 'ALIBABA_CLOUD_ECS_METADATA' are empty") + } + status, content, err := HookGet(get)(securityCredURL + roleName) + if err != nil { + return nil, err + } + if status != 200 { + if status == 404 { + return nil, fmt.Errorf("The role was not found in the instance") + } + return nil, fmt.Errorf("Received %d when getting security credentials for %s", status, roleName) + } + body := make(map[string]interface{}) + + if err := json.Unmarshal(content, &body); err != nil { + return nil, err + } + + accessKeyID, err := extractString(body, "AccessKeyId") + if err != nil { + return nil, err + } + accessKeySecret, err := extractString(body, "AccessKeySecret") + if err != nil { + return nil, err + } + securityToken, err := extractString(body, "SecurityToken") + if err != nil { + return nil, err + } + + return credentials.NewStsTokenCredential(accessKeyID, accessKeySecret, securityToken), nil +} + +func get(url string) (status int, content []byte, err error) { + httpClient := http.DefaultClient + httpClient.Timeout = time.Second * 1 + resp, err := httpClient.Get(url) + if err != nil { + return + } + defer resp.Body.Close() + content, err = ioutil.ReadAll(resp.Body) + return resp.StatusCode, content, err +} + +func extractString(m map[string]interface{}, key string) (string, error) { + raw, ok := m[key] + if !ok { + return "", fmt.Errorf("%s not in map", key) + } + str, ok := raw.(string) + if !ok { + return "", fmt.Errorf("%s is not a string in map", key) + } + return str, nil +} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider/profile_credentials.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider/profile_credentials.go new file mode 100644 index 000000000000..8d525c37adb5 --- /dev/null +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider/profile_credentials.go @@ -0,0 +1,158 @@ +package provider + +import ( + "bufio" + "errors" + "os" + "runtime" + "strings" + + "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth" + "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials" + + ini "gopkg.in/ini.v1" +) + +type ProfileProvider struct { + Profile string +} + +var ProviderProfile = NewProfileProvider() + +// NewProfileProvider receive zero or more parameters, +// when length of name is 0, the value of field Profile will be "default", +// and when there are multiple inputs, the function will take the +// first one and discard the other values. +func NewProfileProvider(name ...string) Provider { + p := new(ProfileProvider) + if len(name) == 0 { + p.Profile = "default" + } else { + p.Profile = name[0] + } + return p +} + +// Resolve implements the Provider interface +// when credential type is rsa_key_pair, the content of private_key file +// must be able to be parsed directly into the required string +// that NewRsaKeyPairCredential function needed +func (p *ProfileProvider) Resolve() (auth.Credential, error) { + path, ok := os.LookupEnv(ENVCredentialFile) + if !ok { + path, err := checkDefaultPath() + if err != nil { + return nil, err + } + if path == "" { + return nil, nil + } + } else if path == "" { + return nil, errors.New("Environment variable '" + ENVCredentialFile + "' cannot be empty") + } + + ini, err := ini.Load(path) + if err != nil { + return nil, errors.New("ERROR: Can not open file" + err.Error()) + } + + section, err := ini.GetSection(p.Profile) + if err != nil { + return nil, errors.New("ERROR: Can not load section" + err.Error()) + } + + value, err := section.GetKey("type") + if err != nil { + return nil, errors.New("ERROR: Can not find credential type" + err.Error()) + } + + switch value.String() { + case "access_key": + value1, err1 := section.GetKey("access_key_id") + value2, err2 := section.GetKey("access_key_secret") + if err1 != nil || err2 != nil { + return nil, errors.New("ERROR: Failed to get value") + } + if value1.String() == "" || value2.String() == "" { + return nil, errors.New("ERROR: Value can't be empty") + } + return credentials.NewAccessKeyCredential(value1.String(), value2.String()), nil + case "ecs_ram_role": + value1, err1 := section.GetKey("role_name") + if err1 != nil { + return nil, errors.New("ERROR: Failed to get value") + } + if value1.String() == "" { + return nil, errors.New("ERROR: Value can't be empty") + } + return credentials.NewEcsRamRoleCredential(value1.String()), nil + case "ram_role_arn": + value1, err1 := section.GetKey("access_key_id") + value2, err2 := section.GetKey("access_key_secret") + value3, err3 := section.GetKey("role_arn") + value4, err4 := section.GetKey("role_session_name") + if err1 != nil || err2 != nil || err3 != nil || err4 != nil { + return nil, errors.New("ERROR: Failed to get value") + } + if value1.String() == "" || value2.String() == "" || value3.String() == "" || value4.String() == "" { + return nil, errors.New("ERROR: Value can't be empty") + } + return credentials.NewRamRoleArnCredential(value1.String(), value2.String(), value3.String(), value4.String(), 3600), nil + case "rsa_key_pair": + value1, err1 := section.GetKey("public_key_id") + value2, err2 := section.GetKey("private_key_file") + if err1 != nil || err2 != nil { + return nil, errors.New("ERROR: Failed to get value") + } + if value1.String() == "" || value2.String() == "" { + return nil, errors.New("ERROR: Value can't be empty") + } + file, err := os.Open(value2.String()) + if err != nil { + return nil, errors.New("ERROR: Can not get private_key") + } + defer file.Close() + var privateKey string + scan := bufio.NewScanner(file) + var data string + for scan.Scan() { + if strings.HasPrefix(scan.Text(), "----") { + continue + } + data += scan.Text() + "\n" + } + return credentials.NewRsaKeyPairCredential(privateKey, value1.String(), 3600), nil + default: + return nil, errors.New("ERROR: Failed to get credential") + } +} + +// GetHomePath return home directory according to the system. +// if the environmental virables does not exist, will return empty +func GetHomePath() string { + if runtime.GOOS == "windows" { + path, ok := os.LookupEnv("USERPROFILE") + if !ok { + return "" + } + return path + } + path, ok := os.LookupEnv("HOME") + if !ok { + return "" + } + return path +} + +func checkDefaultPath() (path string, err error) { + path = GetHomePath() + if path == "" { + return "", errors.New("The default credential file path is invalid") + } + path = strings.Replace("~/.alibabacloud/credentials", "~", path, 1) + _, err = os.Stat(path) + if err != nil { + return "", nil + } + return path, nil +} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider/provider.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider/provider.go new file mode 100644 index 000000000000..ae4e168eb1ae --- /dev/null +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider/provider.go @@ -0,0 +1,19 @@ +package provider + +import ( + "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth" +) + +//Environmental virables that may be used by the provider +const ( + ENVAccessKeyID = "ALIBABA_CLOUD_ACCESS_KEY_ID" + ENVAccessKeySecret = "ALIBABA_CLOUD_ACCESS_KEY_SECRET" + ENVCredentialFile = "ALIBABA_CLOUD_CREDENTIALS_FILE" + ENVEcsMetadata = "ALIBABA_CLOUD_ECS_METADATA" + PATHCredentialFile = "~/.alibabacloud/credentials" +) + +// When you want to customize the provider, you only need to implement the method of the interface. +type Provider interface { + Resolve() (auth.Credential, error) +} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider/provider_chain.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider/provider_chain.go new file mode 100644 index 000000000000..3f9315d138eb --- /dev/null +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider/provider_chain.go @@ -0,0 +1,34 @@ +package provider + +import ( + "errors" + + "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth" +) + +type ProviderChain struct { + Providers []Provider +} + +var defaultproviders = []Provider{ProviderEnv, ProviderProfile, ProviderInstance} +var DefaultChain = NewProviderChain(defaultproviders) + +func NewProviderChain(providers []Provider) Provider { + return &ProviderChain{ + Providers: providers, + } +} + +func (p *ProviderChain) Resolve() (auth.Credential, error) { + for _, provider := range p.Providers { + creds, err := provider.Resolve() + if err != nil { + return nil, err + } else if err == nil && creds == nil { + continue + } + return creds, err + } + return nil, errors.New("No credential found") + +} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/sts_role_arn_credential.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/sts_role_arn_credential.go index 7a9db75d2cc5..27602fd74946 100644 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/sts_role_arn_credential.go +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/sts_role_arn_credential.go @@ -15,6 +15,7 @@ type RamRoleArnCredential struct { RoleArn string RoleSessionName string RoleSessionExpiration int + Policy string } // Deprecated: Use RamRoleArnCredential in this package instead. @@ -47,3 +48,14 @@ func NewRamRoleArnCredential(accessKeyId, accessKeySecret, roleArn, roleSessionN RoleSessionExpiration: roleSessionExpiration, } } + +func NewRamRoleArnWithPolicyCredential(accessKeyId, accessKeySecret, roleArn, roleSessionName, policy string, roleSessionExpiration int) *RamRoleArnCredential { + return &RamRoleArnCredential{ + AccessKeyId: accessKeyId, + AccessKeySecret: accessKeySecret, + RoleArn: roleArn, + RoleSessionName: roleSessionName, + RoleSessionExpiration: roleSessionExpiration, + Policy: policy, + } +} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/roa_signature_composer.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/roa_signature_composer.go index 19498b13f3d6..77fcec231e3c 100644 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/roa_signature_composer.go +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/roa_signature_composer.go @@ -62,7 +62,10 @@ func completeROASignParams(request requests.AcsRequest, signer Signer, regionId headerParams["x-acs-security-token"] = value continue } - + if key == "BearerToken" { + headerParams["x-acs-bearer-token"] = value + continue + } queryParams[key] = value } } diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signer.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signer.go index cbc5f5659c66..cbbc3cef7de9 100644 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signer.go +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signer.go @@ -44,6 +44,10 @@ func NewSignerWithCredential(credential Credential, commonApi func(request *requ { signer = signers.NewStsTokenSigner(instance) } + case *credentials.BearerTokenCredential: + { + signer = signers.NewBearerTokenSigner(instance) + } case *credentials.RamRoleArnCredential: { signer, err = signers.NewRamRoleArnSigner(instance, commonApi) diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/algorithms.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/algorithms.go index 404006c56caa..887f502094e9 100644 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/algorithms.go +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/algorithms.go @@ -34,6 +34,7 @@ func ShaHmac1(source, secret string) string { } func Sha256WithRsa(source, secret string) string { + // block, _ := pem.Decode([]byte(secret)) decodeString, err := base64.StdEncoding.DecodeString(secret) if err != nil { panic(err) diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/credential_updater.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/credential_updater.go index e6da3b18af4c..ba291a41e888 100644 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/credential_updater.go +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/credential_updater.go @@ -21,7 +21,7 @@ import ( "github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses" ) -const defaultInAdvanceScale = 0.8 +const defaultInAdvanceScale = 0.95 type credentialUpdater struct { credentialExpiration int diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_bearer_token.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_bearer_token.go new file mode 100644 index 000000000000..75b78433adbb --- /dev/null +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_bearer_token.go @@ -0,0 +1,35 @@ +package signers + +import ( + "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials" +) + +type BearerTokenSigner struct { + credential *credentials.BearerTokenCredential +} + +func NewBearerTokenSigner(credential *credentials.BearerTokenCredential) *BearerTokenSigner { + return &BearerTokenSigner{ + credential: credential, + } +} + +func (signer *BearerTokenSigner) GetExtraParam() map[string]string { + return map[string]string{"BearerToken": signer.credential.BearerToken} +} + +func (*BearerTokenSigner) GetName() string { + return "" +} +func (*BearerTokenSigner) GetType() string { + return "BEARERTOKEN" +} +func (*BearerTokenSigner) GetVersion() string { + return "1.0" +} +func (signer *BearerTokenSigner) GetAccessKeyId() (accessKeyId string, err error) { + return "", nil +} +func (signer *BearerTokenSigner) Sign(stringToSign, secretSuffix string) string { + return "" +} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_ecs_ram_role.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_ecs_ram_role.go index e37c65745b11..73788429e9b2 100644 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_ecs_ram_role.go +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_ecs_ram_role.go @@ -24,7 +24,7 @@ import ( "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials" "github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests" "github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses" - "github.com/jmespath/go-jmespath" + jmespath "github.com/jmespath/go-jmespath" ) var securityCredURL = "http://100.100.100.200/latest/meta-data/ram/security-credentials/" @@ -88,7 +88,7 @@ func (signer *EcsRamRoleSigner) GetExtraParam() map[string]string { } func (signer *EcsRamRoleSigner) Sign(stringToSign, secretSuffix string) string { - secret := signer.sessionCredential.AccessKeyId + secretSuffix + secret := signer.sessionCredential.AccessKeySecret + secretSuffix return ShaHmac1(stringToSign, secret) } diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_key_pair.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_key_pair.go index 8ed184fc0e9b..19273d5a69df 100644 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_key_pair.go +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_key_pair.go @@ -24,7 +24,7 @@ import ( "github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors" "github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests" "github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses" - "github.com/jmespath/go-jmespath" + jmespath "github.com/jmespath/go-jmespath" ) type SignerKeyPair struct { @@ -97,7 +97,7 @@ func (signer *SignerKeyPair) GetExtraParam() map[string]string { } func (signer *SignerKeyPair) Sign(stringToSign, secretSuffix string) string { - secret := signer.sessionCredential.AccessKeyId + secretSuffix + secret := signer.sessionCredential.AccessKeySecret + secretSuffix return ShaHmac1(stringToSign, secret) } @@ -107,6 +107,7 @@ func (signer *SignerKeyPair) buildCommonRequest() (request *requests.CommonReque request.Version = "2015-04-01" request.ApiName = "GenerateSessionAccessKey" request.Scheme = requests.HTTPS + request.SetDomain("sts.ap-northeast-1.aliyuncs.com") request.QueryParams["PublicKeyId"] = signer.credential.PublicKeyId request.QueryParams["DurationSeconds"] = strconv.Itoa(signer.credentialExpiration) return diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_ram_role_arn.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_ram_role_arn.go index 8fd859a98c91..c945c8aeb34b 100644 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_ram_role_arn.go +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers/signer_ram_role_arn.go @@ -25,7 +25,7 @@ import ( "github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors" "github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests" "github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses" - "github.com/jmespath/go-jmespath" + jmespath "github.com/jmespath/go-jmespath" ) const ( @@ -119,6 +119,9 @@ func (signer *RamRoleArnSigner) buildCommonRequest() (request *requests.CommonRe request.ApiName = "AssumeRole" request.Scheme = requests.HTTPS request.QueryParams["RoleArn"] = signer.credential.RoleArn + if signer.credential.Policy != "" { + request.QueryParams["Policy"] = signer.credential.Policy + } request.QueryParams["RoleSessionName"] = signer.credential.RoleSessionName request.QueryParams["DurationSeconds"] = strconv.Itoa(signer.credentialExpiration) return diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/client.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/client.go index bc88a88537e8..b58629fa32b2 100644 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/client.go +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/client.go @@ -15,12 +15,20 @@ package sdk import ( + "context" + "crypto/tls" "fmt" + "net" "net/http" + "net/url" + "os" "runtime" "strconv" "strings" "sync" + "time" + + "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider" "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth" "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials" @@ -39,6 +47,8 @@ func init() { // Version this value will be replaced while build: -ldflags="-X sdk.version=x.x.x" var Version = "0.0.1" +var defaultConnectTimeout = 5 * time.Second +var defaultReadTimeout = 10 * time.Second var DefaultUserAgent = fmt.Sprintf("AlibabaCloud (%s; %s) Golang/%s Core/%s", runtime.GOOS, runtime.GOARCH, strings.Trim(runtime.Version(), "go"), Version) @@ -48,12 +58,18 @@ var hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req * // Client the type Client type Client struct { + isInsecure bool regionId string config *Config + httpProxy string + httpsProxy string + noProxy string userAgent map[string]string signer auth.Signer httpClient *http.Client asyncTaskQueue chan func() + readTimeout time.Duration + connectTimeout time.Duration debug bool isRunning bool @@ -65,6 +81,51 @@ func (client *Client) Init() (err error) { panic("not support yet") } +func (client *Client) SetHTTPSInsecure(isInsecure bool) { + client.isInsecure = isInsecure +} + +func (client *Client) GetHTTPSInsecure() bool { + return client.isInsecure +} + +func (client *Client) SetHttpsProxy(httpsProxy string) { + client.httpsProxy = httpsProxy +} + +func (client *Client) GetHttpsProxy() string { + return client.httpsProxy +} + +func (client *Client) SetHttpProxy(httpProxy string) { + client.httpProxy = httpProxy +} + +func (client *Client) GetHttpProxy() string { + return client.httpProxy +} + +func (client *Client) SetNoProxy(noProxy string) { + client.noProxy = noProxy +} + +func (client *Client) GetNoProxy() string { + return client.noProxy +} + +// InitWithProviderChain will get credential from the providerChain, +// the RsaKeyPairCredential Only applicable to regionID `ap-northeast-1`, +// if your providerChain may return a credential type with RsaKeyPairCredential, +// please ensure your regionID is `ap-northeast-1`. +func (client *Client) InitWithProviderChain(regionId string, provider provider.Provider) (err error) { + config := client.InitClientConfig() + credential, err := provider.Resolve() + if err != nil { + return + } + return client.InitWithOptions(regionId, config, credential) +} + func (client *Client) InitWithOptions(regionId string, config *Config, credential auth.Credential) (err error) { client.isRunning = true client.asyncChanLock = new(sync.RWMutex) @@ -89,6 +150,57 @@ func (client *Client) InitWithOptions(regionId string, config *Config, credentia return } +func (client *Client) SetReadTimeout(readTimeout time.Duration) { + client.readTimeout = readTimeout +} + +func (client *Client) SetConnectTimeout(connectTimeout time.Duration) { + client.connectTimeout = connectTimeout +} + +func (client *Client) GetReadTimeout() time.Duration { + return client.readTimeout +} + +func (client *Client) GetConnectTimeout() time.Duration { + return client.connectTimeout +} + +func (client *Client) getHttpProxy(scheme string) (proxy *url.URL, err error) { + if scheme == "https" { + if client.GetHttpsProxy() != "" { + proxy, err = url.Parse(client.httpsProxy) + } else if rawurl := os.Getenv("HTTPS_PROXY"); rawurl != "" { + proxy, err = url.Parse(rawurl) + } else if rawurl := os.Getenv("https_proxy"); rawurl != "" { + proxy, err = url.Parse(rawurl) + } + } else { + if client.GetHttpProxy() != "" { + proxy, err = url.Parse(client.httpProxy) + } else if rawurl := os.Getenv("HTTP_PROXY"); rawurl != "" { + proxy, err = url.Parse(rawurl) + } else if rawurl := os.Getenv("http_proxy"); rawurl != "" { + proxy, err = url.Parse(rawurl) + } + } + + return proxy, err +} + +func (client *Client) getNoProxy(scheme string) []string { + var urls []string + if client.GetNoProxy() != "" { + urls = strings.Split(client.noProxy, ",") + } else if rawurl := os.Getenv("NO_PROXY"); rawurl != "" { + urls = strings.Split(rawurl, ",") + } else if rawurl := os.Getenv("no_proxy"); rawurl != "" { + urls = strings.Split(rawurl, ",") + } + + return urls +} + // EnableAsync enable the async task queue func (client *Client) EnableAsync(routinePoolSize, maxTaskQueueSize int) { client.asyncTaskQueue = make(chan func(), maxTaskQueueSize) @@ -136,6 +248,18 @@ func (client *Client) InitWithRamRoleArn(regionId, accessKeyId, accessKeySecret, return client.InitWithOptions(regionId, config, credential) } +func (client *Client) InitWithRamRoleArnAndPolicy(regionId, accessKeyId, accessKeySecret, roleArn, roleSessionName, policy string) (err error) { + config := client.InitClientConfig() + credential := &credentials.RamRoleArnCredential{ + AccessKeyId: accessKeyId, + AccessKeySecret: accessKeySecret, + RoleArn: roleArn, + RoleSessionName: roleSessionName, + Policy: policy, + } + return client.InitWithOptions(regionId, config, credential) +} + func (client *Client) InitWithRsaKeyPair(regionId, publicKeyId, privateKey string, sessionExpiration int) (err error) { config := client.InitClientConfig() credential := &credentials.RsaKeyPairCredential{ @@ -154,6 +278,14 @@ func (client *Client) InitWithEcsRamRole(regionId, roleName string) (err error) return client.InitWithOptions(regionId, config, credential) } +func (client *Client) InitWithBearerToken(regionId, bearerToken string) (err error) { + config := client.InitClientConfig() + credential := &credentials.BearerTokenCredential{ + BearerToken: bearerToken, + } + return client.InitWithOptions(regionId, config, credential) +} + func (client *Client) InitClientConfig() (config *Config) { if client.config != nil { return client.config @@ -260,13 +392,103 @@ func (client *Client) BuildRequestWithSigner(request requests.AcsRequest, signer return } +func (client *Client) getTimeout(request requests.AcsRequest) (time.Duration, time.Duration) { + readTimeout := defaultReadTimeout + connectTimeout := defaultConnectTimeout + + reqReadTimeout := request.GetReadTimeout() + reqConnectTimeout := request.GetConnectTimeout() + if reqReadTimeout != 0*time.Millisecond { + readTimeout = reqReadTimeout + } else if client.readTimeout != 0*time.Millisecond { + readTimeout = client.readTimeout + } + + if reqConnectTimeout != 0*time.Millisecond { + connectTimeout = reqConnectTimeout + } else if client.connectTimeout != 0*time.Millisecond { + connectTimeout = client.connectTimeout + } + return readTimeout, connectTimeout +} + +func Timeout(connectTimeout, readTimeout time.Duration) func(cxt context.Context, net, addr string) (c net.Conn, err error) { + return func(ctx context.Context, network, address string) (net.Conn, error) { + conn, err := (&net.Dialer{ + Timeout: connectTimeout, + KeepAlive: 0 * time.Second, + DualStack: true, + }).DialContext(ctx, network, address) + + if err == nil { + conn.SetDeadline(time.Now().Add(readTimeout)) + } + + return conn, err + } +} + +func (client *Client) setTimeout(request requests.AcsRequest) { + readTimeout, connectTimeout := client.getTimeout(request) + if trans, ok := client.httpClient.Transport.(*http.Transport); ok && trans != nil { + trans.DialContext = Timeout(connectTimeout, readTimeout) + client.httpClient.Transport = trans + } else { + client.httpClient.Transport = &http.Transport{ + DialContext: Timeout(connectTimeout, readTimeout), + } + } +} + +func (client *Client) getHTTPSInsecure(request requests.AcsRequest) (insecure bool) { + if request.GetHTTPSInsecure() != nil { + insecure = *request.GetHTTPSInsecure() + } else { + insecure = client.GetHTTPSInsecure() + } + return insecure +} + func (client *Client) DoActionWithSigner(request requests.AcsRequest, response responses.AcsResponse, signer auth.Signer) (err error) { httpRequest, err := client.buildRequestWithSigner(request, signer) if err != nil { return } + client.setTimeout(request) + proxy, err := client.getHttpProxy(httpRequest.URL.Scheme) + if err != nil { + return err + } + + noProxy := client.getNoProxy(httpRequest.URL.Scheme) + + var flag bool + for _, value := range noProxy { + if value == httpRequest.Host { + flag = true + break + } + } + + // Set whether to ignore certificate validation. + // Default InsecureSkipVerify is false. + if trans, ok := client.httpClient.Transport.(*http.Transport); ok && trans != nil { + trans.TLSClientConfig = &tls.Config{ + InsecureSkipVerify: client.getHTTPSInsecure(request), + } + if proxy != nil && !flag { + trans.Proxy = http.ProxyURL(proxy) + } + client.httpClient.Transport = trans + } + var httpResponse *http.Response for retryTimes := 0; retryTimes <= client.config.MaxRetryTime; retryTimes++ { + if proxy != nil && proxy.User != nil{ + if password, passwordSet := proxy.User.Password(); passwordSet { + httpRequest.SetBasicAuth(proxy.User.Username(), password) + } + } debug("> %s %s %s", httpRequest.Method, httpRequest.URL.RequestURI(), httpRequest.Proto) debug("> Host: %s", httpRequest.Host) for key, value := range httpRequest.Header { @@ -287,13 +509,19 @@ func (client *Client) DoActionWithSigner(request requests.AcsRequest, response r return } else if retryTimes >= client.config.MaxRetryTime { // timeout but reached the max retry times, return - timeoutErrorMsg := fmt.Sprintf(errors.TimeoutErrorMessage, strconv.Itoa(retryTimes+1), strconv.Itoa(retryTimes+1)) + var timeoutErrorMsg string + if strings.Contains(err.Error(), "read tcp") { + timeoutErrorMsg = fmt.Sprintf(errors.TimeoutErrorMessage, strconv.Itoa(retryTimes+1), strconv.Itoa(retryTimes+1)) + " Read timeout. Please set a valid ReadTimeout." + } else { + timeoutErrorMsg = fmt.Sprintf(errors.TimeoutErrorMessage, strconv.Itoa(retryTimes+1), strconv.Itoa(retryTimes+1)) + " Connect timeout. Please set a valid ConnectTimeout." + } err = errors.NewClientError(errors.TimeoutErrorCode, timeoutErrorMsg, err) return } } // if status code >= 500 or timeout, will trigger retry if client.config.AutoRetry && (err != nil || isServerError(httpResponse)) { + client.setTimeout(request) // rewrite signatureNonce and signature httpRequest, err = client.buildRequestWithSigner(request, signer) // buildHttpRequest(request, finalSigner, regionId) @@ -304,6 +532,7 @@ func (client *Client) DoActionWithSigner(request requests.AcsRequest, response r } break } + err = responses.Unmarshal(response, httpResponse, request.GetAcceptFormat()) // wrap server errors if serverErr, ok := err.(*errors.ServerError); ok { @@ -368,6 +597,18 @@ func NewClient() (client *Client, err error) { return } +func NewClientWithProvider(regionId string, providers ...provider.Provider) (client *Client, err error) { + client = &Client{} + var pc provider.Provider + if len(providers) == 0 { + pc = provider.DefaultChain + } else { + pc = provider.NewProviderChain(providers) + } + err = client.InitWithProviderChain(regionId, pc) + return +} + func NewClientWithOptions(regionId string, config *Config, credential auth.Credential) (client *Client, err error) { client = &Client{} err = client.InitWithOptions(regionId, config, credential) @@ -392,6 +633,12 @@ func NewClientWithRamRoleArn(regionId string, accessKeyId, accessKeySecret, role return } +func NewClientWithRamRoleArnAndPolicy(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName, policy string) (client *Client, err error) { + client = &Client{} + err = client.InitWithRamRoleArnAndPolicy(regionId, accessKeyId, accessKeySecret, roleArn, roleSessionName, policy) + return +} + func NewClientWithEcsRamRole(regionId string, roleName string) (client *Client, err error) { client = &Client{} err = client.InitWithEcsRamRole(regionId, roleName) @@ -404,14 +651,10 @@ func NewClientWithRsaKeyPair(regionId string, publicKeyId, privateKey string, se return } -// Deprecated: Use NewClientWithRamRoleArn in this package instead. -func NewClientWithStsRoleArn(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName string) (client *Client, err error) { - return NewClientWithRamRoleArn(regionId, accessKeyId, accessKeySecret, roleArn, roleSessionName) -} - -// Deprecated: Use NewClientWithEcsRamRole in this package instead. -func NewClientWithStsRoleNameOnEcs(regionId string, roleName string) (client *Client, err error) { - return NewClientWithEcsRamRole(regionId, roleName) +func NewClientWithBearerToken(regionId, bearerToken string) (client *Client, err error) { + client = &Client{} + err = client.InitWithBearerToken(regionId, bearerToken) + return } func (client *Client) ProcessCommonRequest(request *requests.CommonRequest) (response *responses.CommonResponse, err error) { @@ -440,3 +683,13 @@ func (client *Client) Shutdown() { } client.isRunning = false } + +// Deprecated: Use NewClientWithRamRoleArn in this package instead. +func NewClientWithStsRoleArn(regionId string, accessKeyId, accessKeySecret, roleArn, roleSessionName string) (client *Client, err error) { + return NewClientWithRamRoleArn(regionId, accessKeyId, accessKeySecret, roleArn, roleSessionName) +} + +// Deprecated: Use NewClientWithEcsRamRole in this package instead. +func NewClientWithStsRoleNameOnEcs(regionId string, roleName string) (client *Client, err error) { + return NewClientWithEcsRamRole(regionId, roleName) +} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/client_test.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/client_test.go deleted file mode 100644 index 361bcf64c419..000000000000 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/client_test.go +++ /dev/null @@ -1,409 +0,0 @@ -/* - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package sdk - -import ( - "bytes" - "io/ioutil" - "net/http" - "strconv" - "testing" - "time" - - "github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses" - - "github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials" - "github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests" - - "github.com/stretchr/testify/assert" -) - -type signertest struct { - name string -} - -func (s *signertest) GetName() string { - return "" -} - -func (s *signertest) GetType() string { - return "" -} - -func (s *signertest) GetVersion() string { - return "" -} - -func (s *signertest) GetAccessKeyId() (string, error) { - return "", nil -} - -func (s *signertest) GetExtraParam() map[string]string { - return nil -} - -func (s *signertest) Sign(stringToSign, secretSuffix string) string { - return "" -} - -func Test_Client(t *testing.T) { - defer func() { - err := recover() - assert.NotNil(t, err) - assert.Equal(t, "not support yet", err) - }() - NewClient() -} - -func Test_NewClientWithOptions(t *testing.T) { - c := NewConfig() - c.HttpTransport = &http.Transport{ - IdleConnTimeout: time.Duration(10 * time.Second), - } - c.EnableAsync = true - c.GoRoutinePoolSize = 1 - c.MaxTaskQueueSize = 1 - credential := credentials.NewAccessKeyCredential("acesskeyid", "accesskeysecret") - client, err := NewClientWithOptions("regionid", c, credential) - assert.Nil(t, err) - assert.NotNil(t, client) -} - -func Test_NewClientWithAccessKey(t *testing.T) { - client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") - assert.Nil(t, err) - assert.NotNil(t, client) -} - -func Test_NewClientWithStsToken(t *testing.T) { - client, err := NewClientWithStsToken("regionid", "acesskeyid", "accesskeysecret", "token") - assert.Nil(t, err) - assert.NotNil(t, client) -} - -func Test_NewClientWithRamRoleArn(t *testing.T) { - client, err := NewClientWithRamRoleArn("regionid", "acesskeyid", "accesskeysecret", "roleArn", "roleSessionName") - assert.Nil(t, err) - assert.NotNil(t, client) - config := client.InitClientConfig() - assert.NotNil(t, config) -} - -func Test_NewClientWithEcsRamRole(t *testing.T) { - client, err := NewClientWithEcsRamRole("regionid", "roleName") - assert.Nil(t, err) - assert.NotNil(t, client) -} - -func Test_NewClientWithRsaKeyPair(t *testing.T) { - client, err := NewClientWithRsaKeyPair("regionid", "publicKey", "privateKey", 3600) - assert.Nil(t, err) - assert.NotNil(t, client) -} - -func mockResponse(statusCode int, content string) (res *http.Response, err error) { - status := strconv.Itoa(statusCode) - res = &http.Response{ - Proto: "HTTP/1.1", - ProtoMajor: 1, - Header: make(http.Header), - StatusCode: statusCode, - Status: status + " " + http.StatusText(statusCode), - } - res.Body = ioutil.NopCloser(bytes.NewReader([]byte(content))) - return -} - -func Test_DoAction(t *testing.T) { - client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") - assert.Nil(t, err) - assert.NotNil(t, client) - assert.Equal(t, true, client.isRunning) - request := requests.NewCommonRequest() - request.Domain = "ecs.aliyuncs.com" - request.Version = "2014-05-26" - request.ApiName = "DescribeInstanceStatus" - - request.QueryParams["PageNumber"] = "1" - request.QueryParams["PageSize"] = "30" - request.TransToAcsRequest() - response := responses.NewCommonResponse() - origTestHookDo := hookDo - defer func() { hookDo = origTestHookDo }() - hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) { - return func(req *http.Request) (*http.Response, error) { - return mockResponse(200, "") - } - } - err = client.DoAction(request, response) - assert.Nil(t, err) - assert.Equal(t, 200, response.GetHttpStatus()) - assert.Equal(t, "", response.GetHttpContentString()) - client.Shutdown() - assert.Equal(t, false, client.isRunning) -} - -func Test_DoAction_Timeout(t *testing.T) { - client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") - assert.Nil(t, err) - assert.NotNil(t, client) - assert.Equal(t, true, client.isRunning) - request := requests.NewCommonRequest() - request.Domain = "ecs.aliyuncs.com" - request.Version = "2014-05-26" - request.ApiName = "DescribeInstanceStatus" - - request.QueryParams["PageNumber"] = "1" - request.QueryParams["PageSize"] = "30" - request.TransToAcsRequest() - response := responses.NewCommonResponse() - origTestHookDo := hookDo - defer func() { hookDo = origTestHookDo }() - hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) { - return func(req *http.Request) (*http.Response, error) { - return mockResponse(200, "") - } - } - err = client.DoAction(request, response) - assert.Nil(t, err) - assert.Equal(t, 200, response.GetHttpStatus()) - assert.Equal(t, "", response.GetHttpContentString()) - client.Shutdown() - assert.Equal(t, false, client.isRunning) -} - -func Test_ProcessCommonRequest(t *testing.T) { - client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") - assert.Nil(t, err) - assert.NotNil(t, client) - - request := requests.NewCommonRequest() - request.Domain = "ecs.aliyuncs.com" - request.Version = "2014-05-26" - request.ApiName = "DescribeInstanceStatus" - - request.QueryParams["PageNumber"] = "1" - request.QueryParams["PageSize"] = "30" - - origTestHookDo := hookDo - defer func() { hookDo = origTestHookDo }() - hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) { - return func(req *http.Request) (*http.Response, error) { - return mockResponse(200, "") - } - } - response, err := client.ProcessCommonRequest(request) - assert.Nil(t, err) - assert.Equal(t, 200, response.GetHttpStatus()) - assert.Equal(t, "", response.GetHttpContentString()) -} - -func Test_DoAction_With500(t *testing.T) { - client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") - assert.Nil(t, err) - assert.NotNil(t, client) - assert.Equal(t, true, client.isRunning) - request := requests.NewCommonRequest() - request.Domain = "ecs.aliyuncs.com" - request.Version = "2014-05-26" - request.ApiName = "DescribeInstanceStatus" - - request.QueryParams["PageNumber"] = "1" - request.QueryParams["PageSize"] = "30" - request.TransToAcsRequest() - response := responses.NewCommonResponse() - origTestHookDo := hookDo - defer func() { hookDo = origTestHookDo }() - hookDo = func(fn func(req *http.Request) (*http.Response, error)) func(req *http.Request) (*http.Response, error) { - return func(req *http.Request) (*http.Response, error) { - return mockResponse(500, "Server Internel Error") - } - } - err = client.DoAction(request, response) - assert.NotNil(t, err) - assert.Equal(t, "SDK.ServerError\nErrorCode: \nRecommend: \nRequestId: \nMessage: Server Internel Error", err.Error()) - assert.Equal(t, 500, response.GetHttpStatus()) - assert.Equal(t, "Server Internel Error", response.GetHttpContentString()) -} - -func TestClient_BuildRequestWithSigner(t *testing.T) { - client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") - assert.Nil(t, err) - assert.NotNil(t, client) - assert.Equal(t, true, client.isRunning) - request := requests.NewCommonRequest() - request.Domain = "ecs.aliyuncs.com" - request.Version = "2014-05-26" - request.ApiName = "DescribeInstanceStatus" - - request.QueryParams["PageNumber"] = "1" - request.QueryParams["PageSize"] = "30" - request.RegionId = "regionid" - request.TransToAcsRequest() - client.config.UserAgent = "user_agent" - err = client.BuildRequestWithSigner(request, nil) - assert.Nil(t, err) -} - -func TestClient_BuildRequestWithSigner1(t *testing.T) { - client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") - assert.Nil(t, err) - assert.NotNil(t, client) - assert.Equal(t, true, client.isRunning) - request := requests.NewCommonRequest() - request.Domain = "ecs.aliyuncs.com" - request.Version = "2014-05-26" - request.ApiName = "DescribeInstanceStatus" - - request.QueryParams["PageNumber"] = "1" - request.QueryParams["PageSize"] = "30" - request.RegionId = "regionid" - request.TransToAcsRequest() - signer := &signertest{ - name: "signer", - } - err = client.BuildRequestWithSigner(request, signer) - assert.Nil(t, err) -} - -func TestClient_ProcessCommonRequestWithSigner(t *testing.T) { - client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") - assert.Nil(t, err) - assert.NotNil(t, client) - assert.Equal(t, true, client.isRunning) - request := requests.NewCommonRequest() - request.Domain = "ecs.aliyuncs.com" - request.Version = "2014-05-26" - request.ApiName = "DescribeInstanceStatus" - - request.QueryParams["PageNumber"] = "1" - request.QueryParams["PageSize"] = "30" - request.RegionId = "regionid" - signer := &signertest{ - name: "signer", - } - _, err = client.ProcessCommonRequestWithSigner(request, signer) - assert.NotNil(t, err) -} - -func TestClient_AppendUserAgent(t *testing.T) { - client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") - assert.Nil(t, err) - assert.NotNil(t, client) - assert.Equal(t, true, client.isRunning) - request := requests.NewCommonRequest() - request.Domain = "ecs.aliyuncs.com" - request.Version = "2014-05-26" - request.ApiName = "DescribeInstanceStatus" - - request.RegionId = "regionid" - signer := &signertest{ - name: "signer", - } - request.TransToAcsRequest() - httpRequest, err := client.buildRequestWithSigner(request, signer) - assert.Nil(t, err) - assert.Equal(t, DefaultUserAgent, httpRequest.Header.Get("User-Agent")) - - client.AppendUserAgent("test", "1.01") - httpRequest, err = client.buildRequestWithSigner(request, signer) - assert.Equal(t, DefaultUserAgent+" test/1.01", httpRequest.Header.Get("User-Agent")) - - request.AppendUserAgent("test", "2.01") - httpRequest, err = client.buildRequestWithSigner(request, signer) - assert.Equal(t, DefaultUserAgent+" test/2.01", httpRequest.Header.Get("User-Agent")) - - request.AppendUserAgent("test", "2.02") - httpRequest, err = client.buildRequestWithSigner(request, signer) - assert.Equal(t, DefaultUserAgent+" test/2.02", httpRequest.Header.Get("User-Agent")) - - client.AppendUserAgent("test", "2.01") - httpRequest, err = client.buildRequestWithSigner(request, signer) - assert.Equal(t, DefaultUserAgent+" test/2.02", httpRequest.Header.Get("User-Agent")) - - client.AppendUserAgent("core", "1.01") - httpRequest, err = client.buildRequestWithSigner(request, signer) - assert.Equal(t, DefaultUserAgent+" test/2.02", httpRequest.Header.Get("User-Agent")) - - request.AppendUserAgent("core", "1.01") - httpRequest, err = client.buildRequestWithSigner(request, signer) - assert.Equal(t, DefaultUserAgent+" test/2.02", httpRequest.Header.Get("User-Agent")) - - request1 := requests.NewCommonRequest() - request1.Domain = "ecs.aliyuncs.com" - request1.Version = "2014-05-26" - request1.ApiName = "DescribeRegions" - request1.RegionId = "regionid" - request1.AppendUserAgent("sys", "1.01") - request1.TransToAcsRequest() - httpRequest, err = client.buildRequestWithSigner(request1, signer) - assert.Nil(t, err) - assert.Equal(t, DefaultUserAgent+" test/2.01 sys/1.01", httpRequest.Header.Get("User-Agent")) -} - -func TestClient_ProcessCommonRequestWithSigner_Error(t *testing.T) { - client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") - assert.Nil(t, err) - assert.NotNil(t, client) - assert.Equal(t, true, client.isRunning) - request := requests.NewCommonRequest() - request.Domain = "ecs.aliyuncs.com" - request.Version = "2014-05-26" - request.ApiName = "DescribeInstanceStatus" - - request.QueryParams["PageNumber"] = "1" - request.QueryParams["PageSize"] = "30" - request.RegionId = "regionid" - defer func() { - err := recover() - assert.NotNil(t, err) - }() - _, err = client.ProcessCommonRequestWithSigner(request, nil) - assert.NotNil(t, err) -} - -func TestClient_NewClientWithStsRoleNameOnEcs(t *testing.T) { - client, err := NewClientWithStsRoleNameOnEcs("regionid", "rolename") - assert.Nil(t, err) - assert.NotNil(t, client) - assert.Equal(t, true, client.isRunning) - config := client.GetConfig() - assert.NotNil(t, config) - err = client.AddAsyncTask(nil) - assert.NotNil(t, err) -} - -func TestClient_NewClientWithStsRoleArn(t *testing.T) { - client, err := NewClientWithStsRoleArn("regionid", "acesskeyid", "accesskeysecret", "rolearn", "rolesessionname") - assert.Nil(t, err) - assert.NotNil(t, client) - assert.Equal(t, true, client.isRunning) - task := func() {} - client.asyncTaskQueue = make(chan func(), 1) - err = client.AddAsyncTask(task) - assert.Nil(t, err) - client.Shutdown() - assert.Equal(t, false, client.isRunning) -} - -//func Test_EnableAsync(t *testing.T) { -// client, err := NewClientWithAccessKey("regionid", "acesskeyid", "accesskeysecret") -// assert.Nil(t, err) -// assert.NotNil(t, client) -// assert.Equal(t, true, client.isRunning) -// client.EnableAsync(2, 8) -// client.Shutdown() -// assert.Equal(t, false, client.isRunning) -//} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/config_test.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/config_test.go deleted file mode 100644 index b613821e364f..000000000000 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/config_test.go +++ /dev/null @@ -1,52 +0,0 @@ -package sdk - -import ( - "net/http" - "testing" - "time" - - "github.com/stretchr/testify/assert" -) - -func Test_Config(t *testing.T) { - config := NewConfig() - assert.NotNil(t, config, "NewConfig failed") - assert.Equal(t, true, config.AutoRetry, "Default AutoRetry should be true") - assert.Equal(t, 3, config.MaxRetryTime, "Default MaxRetryTime should be 3") - assert.Equal(t, "", config.UserAgent, "Default UserAgent should be empty") - assert.Equal(t, false, config.Debug, "Default AutoRetry should be false") - assert.Equal(t, time.Duration(10000000000), config.Timeout, "Default Timeout should be 10000000000") - assert.Equal(t, (*http.Transport)(nil), config.HttpTransport, "Default HttpTransport should be nil") - assert.Equal(t, false, config.EnableAsync, "Default EnableAsync should be false") - assert.Equal(t, 1000, config.MaxTaskQueueSize, "Default MaxTaskQueueSize should be 1000") - assert.Equal(t, 5, config.GoRoutinePoolSize, "Default GoRoutinePoolSize should be 5") - assert.Equal(t, "HTTP", config.Scheme, "Default Scheme should be HTTP") - - transport := &http.Transport{ - MaxIdleConns: 10, - IdleConnTimeout: 30 * time.Second, - DisableCompression: true, - } - config. - WithAutoRetry(false). - WithMaxRetryTime(0). - WithUserAgent("new user agent"). - WithDebug(true). - WithTimeout(time.Duration(500000)). - WithHttpTransport(transport). - WithEnableAsync(true). - WithMaxTaskQueueSize(1). - WithGoRoutinePoolSize(10). - WithScheme("HTTPS") - - assert.Equal(t, 0, config.MaxRetryTime) - assert.Equal(t, false, config.AutoRetry) - assert.Equal(t, "new user agent", config.UserAgent) - assert.Equal(t, true, config.Debug) - assert.Equal(t, time.Duration(500000), config.Timeout) - assert.Equal(t, transport, config.HttpTransport) - assert.Equal(t, true, config.EnableAsync) - assert.Equal(t, 1, config.MaxTaskQueueSize) - assert.Equal(t, 10, config.GoRoutinePoolSize) - assert.Equal(t, "HTTPS", config.Scheme) -} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/endpoints/endpoints_config.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/endpoints/endpoints_config.go index 6c0e498700e8..60adf7d459ce 100644 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/endpoints/endpoints_config.go +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/endpoints/endpoints_config.go @@ -1,3 +1,4 @@ + package endpoints import ( @@ -6,491 +7,1655 @@ import ( "sync" ) -const endpointsJson = "{" + - " \"products\":[" + - " {" + - " \"code\": \"aegis\"," + - " \"document_id\": \"28449\"," + - " \"location_service_code\": \"vipaegis\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"aegis.cn-hangzhou.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"alidns\"," + - " \"document_id\": \"29739\"," + - " \"location_service_code\": \"alidns\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"alidns.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"arms\"," + - " \"document_id\": \"42924\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": [ {" + - " \"region\": \"ap-southeast-1\"," + - " \"endpoint\": \"arms.ap-southeast-1.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-beijing\"," + - " \"endpoint\": \"arms.cn-beijing.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-hangzhou\"," + - " \"endpoint\": \"arms.cn-hangzhou.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-hongkong\"," + - " \"endpoint\": \"arms.cn-hongkong.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-qingdao\"," + - " \"endpoint\": \"arms.cn-qingdao.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-shanghai\"," + - " \"endpoint\": \"arms.cn-shanghai.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-shenzhen\"," + - " \"endpoint\": \"arms.cn-shenzhen.aliyuncs.com\"" + - " }]," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"arms.[RegionId].aliyuncs.com\"" + - " }," + - " {" + - " \"code\": \"batchcompute\"," + - " \"document_id\": \"44717\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": [ {" + - " \"region\": \"ap-southeast-1\"," + - " \"endpoint\": \"batchcompute.ap-southeast-1.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-beijing\"," + - " \"endpoint\": \"batchcompute.cn-beijing.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-hangzhou\"," + - " \"endpoint\": \"batchcompute.cn-hangzhou.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-huhehaote\"," + - " \"endpoint\": \"batchcompute.cn-huhehaote.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-qingdao\"," + - " \"endpoint\": \"batchcompute.cn-qingdao.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-shanghai\"," + - " \"endpoint\": \"batchcompute.cn-shanghai.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-shenzhen\"," + - " \"endpoint\": \"batchcompute.cn-shenzhen.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-zhangjiakou\"," + - " \"endpoint\": \"batchcompute.cn-zhangjiakou.aliyuncs.com\"" + - " }, {" + - " \"region\": \"us-west-1\"," + - " \"endpoint\": \"batchcompute.us-west-1.aliyuncs.com\"" + - " }]," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"batchcompute.[RegionId].aliyuncs.com\"" + - " }," + - " {" + - " \"code\": \"ccc\"," + - " \"document_id\": \"63027\"," + - " \"location_service_code\": \"ccc\"," + - " \"regional_endpoints\": [ {" + - " \"region\": \"cn-hangzhou\"," + - " \"endpoint\": \"ccc.cn-hangzhou.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-shanghai\"," + - " \"endpoint\": \"ccc.cn-shanghai.aliyuncs.com\"" + - " }]," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"ccc.[RegionId].aliyuncs.com\"" + - " }," + - " {" + - " \"code\": \"cdn\"," + - " \"document_id\": \"27148\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"cdn.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"cds\"," + - " \"document_id\": \"62887\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"cds.cn-beijing.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"chatbot\"," + - " \"document_id\": \"60760\"," + - " \"location_service_code\": \"beebot\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"chatbot.[RegionId].aliyuncs.com\"" + - " }," + - " {" + - " \"code\": \"cloudapi\"," + - " \"document_id\": \"43590\"," + - " \"location_service_code\": \"apigateway\"," + - " \"regional_endpoints\": [ {" + - " \"region\": \"ap-northeast-1\"," + - " \"endpoint\": \"apigateway.ap-northeast-1.aliyuncs.com\"" + - " }, {" + - " \"region\": \"us-west-1\"," + - " \"endpoint\": \"apigateway.us-west-1.aliyuncs.com\"" + - " }]," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"apigateway.[RegionId].aliyuncs.com\"" + - " }," + - " {" + - " \"code\": \"cloudauth\"," + - " \"document_id\": \"60687\"," + - " \"location_service_code\": \"cloudauth\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"cloudauth.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"cloudphoto\"," + - " \"document_id\": \"59902\"," + - " \"location_service_code\": \"cloudphoto\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"cloudphoto.[RegionId].aliyuncs.com\"" + - " }," + - " {" + - " \"code\": \"cloudwf\"," + - " \"document_id\": \"58111\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"cloudwf.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"cms\"," + - " \"document_id\": \"28615\"," + - " \"location_service_code\": \"cms\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"cr\"," + - " \"document_id\": \"60716\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"cr.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"cs\"," + - " \"document_id\": \"26043\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"cs.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"csb\"," + - " \"document_id\": \"64837\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": [ {" + - " \"region\": \"cn-beijing\"," + - " \"endpoint\": \"csb.cn-beijing.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-hangzhou\"," + - " \"endpoint\": \"csb.cn-hangzhou.aliyuncs.com\"" + - " }]," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"csb.[RegionId].aliyuncs.com\"" + - " }," + - " {" + - " \"code\": \"dds\"," + - " \"document_id\": \"61715\"," + - " \"location_service_code\": \"dds\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"mongodb.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"mongodb.[RegionId].aliyuncs.com\"" + - " }," + - " {" + - " \"code\": \"dm\"," + - " \"document_id\": \"29434\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": [ {" + - " \"region\": \"ap-southeast-1\"," + - " \"endpoint\": \"dm.aliyuncs.com\"" + - " }, {" + - " \"region\": \"ap-southeast-2\"," + - " \"endpoint\": \"dm.ap-southeast-2.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-beijing\"," + - " \"endpoint\": \"dm.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-hangzhou\"," + - " \"endpoint\": \"dm.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-hongkong\"," + - " \"endpoint\": \"dm.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-qingdao\"," + - " \"endpoint\": \"dm.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-shanghai\"," + - " \"endpoint\": \"dm.aliyuncs.com\"" + - " }, {" + - " \"region\": \"cn-shenzhen\"," + - " \"endpoint\": \"dm.aliyuncs.com\"" + - " }, {" + - " \"region\": \"us-east-1\"," + - " \"endpoint\": \"dm.aliyuncs.com\"" + - " }, {" + - " \"region\": \"us-west-1\"," + - " \"endpoint\": \"dm.aliyuncs.com\"" + - " }]," + - " \"global_endpoint\": \"dm.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"dm.[RegionId].aliyuncs.com\"" + - " }," + - " {" + - " \"code\": \"domain\"," + - " \"document_id\": \"42875\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"domain.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"domain.aliyuncs.com\"" + - " }," + - " {" + - " \"code\": \"domain-intl\"," + - " \"document_id\": \"\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"domain-intl.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"domain-intl.aliyuncs.com\"" + - " }," + - " {" + - " \"code\": \"drds\"," + - " \"document_id\": \"51111\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"drds.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"drds.aliyuncs.com\"" + - " }," + - " {" + - " \"code\": \"ecs\"," + - " \"document_id\": \"25484\"," + - " \"location_service_code\": \"ecs\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"emr\"," + - " \"document_id\": \"28140\"," + - " \"location_service_code\": \"emr\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"emr.[RegionId].aliyuncs.com\"" + - " }," + - " {" + - " \"code\": \"ess\"," + - " \"document_id\": \"25925\"," + - " \"location_service_code\": \"ess\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"ess.[RegionId].aliyuncs.com\"" + - " }," + - " {" + - " \"code\": \"green\"," + - " \"document_id\": \"28427\"," + - " \"location_service_code\": \"green\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"green.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"hpc\"," + - " \"document_id\": \"35201\"," + - " \"location_service_code\": \"hpc\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"hpc.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"httpdns\"," + - " \"document_id\": \"52679\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"httpdns-api.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"iot\"," + - " \"document_id\": \"30557\"," + - " \"location_service_code\": \"iot\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"iot.[RegionId].aliyuncs.com\"" + - " }," + - " {" + - " \"code\": \"itaas\"," + - " \"document_id\": \"55759\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"itaas.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"jaq\"," + - " \"document_id\": \"35037\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"jaq.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"live\"," + - " \"document_id\": \"48207\"," + - " \"location_service_code\": \"live\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"live.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"mts\"," + - " \"document_id\": \"29212\"," + - " \"location_service_code\": \"mts\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"nas\"," + - " \"document_id\": \"62598\"," + - " \"location_service_code\": \"nas\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"ons\"," + - " \"document_id\": \"44416\"," + - " \"location_service_code\": \"ons\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"polardb\"," + - " \"document_id\": \"58764\"," + - " \"location_service_code\": \"polardb\"," + - " \"regional_endpoints\": [ {" + - " \"region\": \"ap-south-1\"," + - " \"endpoint\": \"polardb.ap-south-1.aliyuncs.com\"" + - " }, {" + - " \"region\": \"ap-southeast-5\"," + - " \"endpoint\": \"polardb.ap-southeast-5.aliyuncs.com\"" + - " }]," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"polardb.aliyuncs.com\"" + - " }," + - " {" + - " \"code\": \"push\"," + - " \"document_id\": \"30074\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"cloudpush.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"qualitycheck\"," + - " \"document_id\": \"50807\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": [ {" + - " \"region\": \"cn-hangzhou\"," + - " \"endpoint\": \"qualitycheck.cn-hangzhou.aliyuncs.com\"" + - " }]," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"r-kvstore\"," + - " \"document_id\": \"60831\"," + - " \"location_service_code\": \"redisa\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"ram\"," + - " \"document_id\": \"28672\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"ram.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"rds\"," + - " \"document_id\": \"26223\"," + - " \"location_service_code\": \"rds\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"ros\"," + - " \"document_id\": \"28899\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"ros.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"sas-api\"," + - " \"document_id\": \"28498\"," + - " \"location_service_code\": \"sas\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"slb\"," + - " \"document_id\": \"27565\"," + - " \"location_service_code\": \"slb\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"sts\"," + - " \"document_id\": \"28756\"," + - " \"location_service_code\": \"\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"sts.aliyuncs.com\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"vod\"," + - " \"document_id\": \"60574\"," + - " \"location_service_code\": \"vod\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"vpc\"," + - " \"document_id\": \"34962\"," + - " \"location_service_code\": \"vpc\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }," + - " {" + - " \"code\": \"waf\"," + - " \"document_id\": \"62847\"," + - " \"location_service_code\": \"waf\"," + - " \"regional_endpoints\": []," + - " \"global_endpoint\": \"\"," + - " \"regional_endpoint_pattern\": \"\"" + - " }]" + - "}" - +const endpointsJson =`{ + "products": [ + { + "code": "ecs", + "document_id": "25484", + "location_service_code": "ecs", + "regional_endpoints": [ + { + "region": "cn-shanghai", + "endpoint": "ecs-cn-hangzhou.aliyuncs.com" + }, + { + "region": "eu-west-1", + "endpoint": "ecs.eu-west-1.aliyuncs.com" + }, + { + "region": "cn-huhehaote", + "endpoint": "ecs.cn-huhehaote.aliyuncs.com" + }, + { + "region": "me-east-1", + "endpoint": "ecs.me-east-1.aliyuncs.com" + }, + { + "region": "ap-southeast-3", + "endpoint": "ecs.ap-southeast-3.aliyuncs.com" + }, + { + "region": "ap-southeast-2", + "endpoint": "ecs.ap-southeast-2.aliyuncs.com" + }, + { + "region": "ap-south-1", + "endpoint": "ecs.ap-south-1.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "ecs-cn-hangzhou.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "ecs-cn-hangzhou.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "ecs-cn-hangzhou.aliyuncs.com" + }, + { + "region": "ap-northeast-1", + "endpoint": "ecs.ap-northeast-1.aliyuncs.com" + }, + { + "region": "ap-southeast-5", + "endpoint": "ecs.ap-southeast-5.aliyuncs.com" + }, + { + "region": "eu-central-1", + "endpoint": "ecs.eu-central-1.aliyuncs.com" + }, + { + "region": "cn-zhangjiakou", + "endpoint": "ecs.cn-zhangjiakou.aliyuncs.com" + }, + { + "region": "cn-qingdao", + "endpoint": "ecs-cn-hangzhou.aliyuncs.com" + }, + { + "region": "cn-hongkong", + "endpoint": "ecs-cn-hangzhou.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "ecs-cn-hangzhou.aliyuncs.com" + }, + { + "region": "us-west-1", + "endpoint": "ecs-cn-hangzhou.aliyuncs.com" + }, + { + "region": "us-east-1", + "endpoint": "ecs-cn-hangzhou.aliyuncs.com" + } + ], + "global_endpoint": "ecs-cn-hangzhou.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "chatbot", + "document_id": "60760", + "location_service_code": "beebot", + "regional_endpoints": [ + { + "region": "cn-shanghai", + "endpoint": "chatbot.cn-shanghai.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "chatbot.cn-hangzhou.aliyuncs.com" + } + ], + "global_endpoint": "", + "regional_endpoint_pattern": "chatbot.[RegionId].aliyuncs.com" + }, + { + "code": "alidns", + "document_id": "29739", + "location_service_code": "alidns", + "regional_endpoints": [ + { + "region": "cn-hangzhou", + "endpoint": "alidns.aliyuncs.com" + } + ], + "global_endpoint": "alidns.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "itaas", + "document_id": "55759", + "location_service_code": "itaas", + "regional_endpoints": null, + "global_endpoint": "itaas.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "csb", + "document_id": "64837", + "location_service_code": "csb", + "regional_endpoints": [ + { + "region": "cn-hangzhou", + "endpoint": "csb.cn-hangzhou.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "csb.cn-beijing.aliyuncs.com" + } + ], + "global_endpoint": "", + "regional_endpoint_pattern": "csb.[RegionId].aliyuncs.com" + }, + { + "code": "slb", + "document_id": "27565", + "location_service_code": "slb", + "regional_endpoints": [ + { + "region": "cn-hongkong", + "endpoint": "slb.aliyuncs.com" + }, + { + "region": "me-east-1", + "endpoint": "slb.me-east-1.aliyuncs.com" + }, + { + "region": "ap-southeast-5", + "endpoint": "slb.ap-southeast-5.aliyuncs.com" + }, + { + "region": "ap-southeast-2", + "endpoint": "slb.ap-southeast-2.aliyuncs.com" + }, + { + "region": "ap-south-1", + "endpoint": "slb.ap-south-1.aliyuncs.com" + }, + { + "region": "eu-central-1", + "endpoint": "slb.eu-central-1.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "slb.aliyuncs.com" + }, + { + "region": "eu-west-1", + "endpoint": "slb.eu-west-1.aliyuncs.com" + }, + { + "region": "cn-huhehaote", + "endpoint": "slb.cn-huhehaote.aliyuncs.com" + }, + { + "region": "us-west-1", + "endpoint": "slb.aliyuncs.com" + }, + { + "region": "cn-zhangjiakou", + "endpoint": "slb.cn-zhangjiakou.aliyuncs.com" + }, + { + "region": "cn-qingdao", + "endpoint": "slb.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "slb.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "slb.aliyuncs.com" + }, + { + "region": "us-east-1", + "endpoint": "slb.aliyuncs.com" + }, + { + "region": "ap-southeast-3", + "endpoint": "slb.ap-southeast-3.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "slb.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "slb.aliyuncs.com" + }, + { + "region": "ap-northeast-1", + "endpoint": "slb.ap-northeast-1.aliyuncs.com" + } + ], + "global_endpoint": "slb.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "cloudwf", + "document_id": "58111", + "location_service_code": "cloudwf", + "regional_endpoints": null, + "global_endpoint": "cloudwf.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "cloudphoto", + "document_id": "59902", + "location_service_code": "cloudphoto", + "regional_endpoints": [ + { + "region": "cn-shanghai", + "endpoint": "cloudphoto.cn-shanghai.aliyuncs.com" + } + ], + "global_endpoint": "", + "regional_endpoint_pattern": "cloudphoto.[RegionId].aliyuncs.com" + }, + { + "code": "dds", + "document_id": "61715", + "location_service_code": "dds", + "regional_endpoints": [ + { + "region": "ap-southeast-5", + "endpoint": "mongodb.ap-southeast-5.aliyuncs.com" + }, + { + "region": "cn-qingdao", + "endpoint": "mongodb.aliyuncs.com" + }, + { + "region": "cn-hongkong", + "endpoint": "mongodb.aliyuncs.com" + }, + { + "region": "eu-west-1", + "endpoint": "mongodb.eu-west-1.aliyuncs.com" + }, + { + "region": "us-west-1", + "endpoint": "mongodb.aliyuncs.com" + }, + { + "region": "us-east-1", + "endpoint": "mongodb.aliyuncs.com" + }, + { + "region": "me-east-1", + "endpoint": "mongodb.me-east-1.aliyuncs.com" + }, + { + "region": "cn-zhangjiakou", + "endpoint": "mongodb.cn-zhangjiakou.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "mongodb.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "mongodb.aliyuncs.com" + }, + { + "region": "ap-northeast-1", + "endpoint": "mongodb.ap-northeast-1.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "mongodb.aliyuncs.com" + }, + { + "region": "ap-southeast-2", + "endpoint": "mongodb.ap-southeast-2.aliyuncs.com" + }, + { + "region": "ap-southeast-3", + "endpoint": "mongodb.ap-southeast-3.aliyuncs.com" + }, + { + "region": "ap-south-1", + "endpoint": "mongodb.ap-south-1.aliyuncs.com" + }, + { + "region": "eu-central-1", + "endpoint": "mongodb.eu-central-1.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "mongodb.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "mongodb.aliyuncs.com" + }, + { + "region": "cn-huhehaote", + "endpoint": "mongodb.cn-huhehaote.aliyuncs.com" + } + ], + "global_endpoint": "mongodb.aliyuncs.com", + "regional_endpoint_pattern": "mongodb.[RegionId].aliyuncs.com" + }, + { + "code": "dm", + "document_id": "29434", + "location_service_code": "dm", + "regional_endpoints": [ + { + "region": "ap-southeast-2", + "endpoint": "dm.ap-southeast-2.aliyuncs.com" + } + ], + "global_endpoint": "dm.aliyuncs.com", + "regional_endpoint_pattern": "dm.[RegionId].aliyuncs.com" + }, + { + "code": "ons", + "document_id": "44416", + "location_service_code": "ons", + "regional_endpoints": [ + { + "region": "cn-zhangjiakou", + "endpoint": "ons.cn-zhangjiakou.aliyuncs.com" + }, + { + "region": "us-west-1", + "endpoint": "ons.us-west-1.aliyuncs.com" + }, + { + "region": "me-east-1", + "endpoint": "ons.me-east-1.aliyuncs.com" + }, + { + "region": "us-east-1", + "endpoint": "ons.us-east-1.aliyuncs.com" + }, + { + "region": "ap-northeast-1", + "endpoint": "ons.ap-northeast-1.aliyuncs.com" + }, + { + "region": "ap-southeast-2", + "endpoint": "ons.ap-southeast-2.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "ons.ap-southeast-1.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "ons.cn-shanghai.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "ons.cn-shenzhen.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "ons.cn-hangzhou.aliyuncs.com" + }, + { + "region": "ap-south-1", + "endpoint": "ons.cn-hangzhou.aliyuncs.com" + }, + { + "region": "eu-central-1", + "endpoint": "ons.eu-central-1.aliyuncs.com" + }, + { + "region": "eu-west-1", + "endpoint": "ons.eu-west-1.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "ons.cn-beijing.aliyuncs.com" + }, + { + "region": "ap-southeast-3", + "endpoint": "ons.ap-southeast-3.aliyuncs.com" + }, + { + "region": "cn-huhehaote", + "endpoint": "ons.cn-huhehaote.aliyuncs.com" + }, + { + "region": "cn-hongkong", + "endpoint": "ons.cn-hongkong.aliyuncs.com" + }, + { + "region": "cn-qingdao", + "endpoint": "ons.cn-qingdao.aliyuncs.com" + } + ], + "global_endpoint": "", + "regional_endpoint_pattern": "" + }, + { + "code": "polardb", + "document_id": "58764", + "location_service_code": "polardb", + "regional_endpoints": [ + { + "region": "cn-qingdao", + "endpoint": "polardb.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "polardb.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "polardb.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "polardb.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "polardb.aliyuncs.com" + }, + { + "region": "cn-huhehaote", + "endpoint": "polardb.cn-huhehaote.aliyuncs.com" + }, + { + "region": "ap-southeast-5", + "endpoint": "polardb.ap-southeast-5.aliyuncs.com" + }, + { + "region": "ap-south-1", + "endpoint": "polardb.ap-south-1.aliyuncs.com" + }, + { + "region": "cn-hongkong", + "endpoint": "polardb.aliyuncs.com" + } + ], + "global_endpoint": "", + "regional_endpoint_pattern": "polardb.aliyuncs.com" + }, + { + "code": "batchcompute", + "document_id": "44717", + "location_service_code": "batchcompute", + "regional_endpoints": [ + { + "region": "us-west-1", + "endpoint": "batchcompute.us-west-1.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "batchcompute.cn-beijing.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "batchcompute.cn-hangzhou.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "batchcompute.cn-shanghai.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "batchcompute.ap-southeast-1.aliyuncs.com" + }, + { + "region": "cn-huhehaote", + "endpoint": "batchcompute.cn-huhehaote.aliyuncs.com" + }, + { + "region": "cn-qingdao", + "endpoint": "batchcompute.cn-qingdao.aliyuncs.com" + }, + { + "region": "cn-zhangjiakou", + "endpoint": "batchcompute.cn-zhangjiakou.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "batchcompute.cn-shenzhen.aliyuncs.com" + } + ], + "global_endpoint": "", + "regional_endpoint_pattern": "batchcompute.[RegionId].aliyuncs.com" + }, + { + "code": "cloudauth", + "document_id": "60687", + "location_service_code": "cloudauth", + "regional_endpoints": [ + { + "region": "cn-hangzhou", + "endpoint": "cloudauth.aliyuncs.com" + } + ], + "global_endpoint": "cloudauth.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "vod", + "document_id": "60574", + "location_service_code": "vod", + "regional_endpoints": [ + { + "region": "cn-beijing", + "endpoint": "vod.cn-shanghai.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "vod.ap-southeast-1.aliyuncs.com" + }, + { + "region": "eu-central-1", + "endpoint": "vod.eu-central-1.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "vod.cn-shanghai.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "vod.cn-shanghai.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "vod.cn-shanghai.aliyuncs.com" + } + ], + "global_endpoint": "", + "regional_endpoint_pattern": "" + }, + { + "code": "ram", + "document_id": "28672", + "location_service_code": "ram", + "regional_endpoints": null, + "global_endpoint": "ram.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "ess", + "document_id": "25925", + "location_service_code": "ess", + "regional_endpoints": [ + { + "region": "me-east-1", + "endpoint": "ess.me-east-1.aliyuncs.com" + }, + { + "region": "ap-northeast-1", + "endpoint": "ess.ap-northeast-1.aliyuncs.com" + }, + { + "region": "ap-south-1", + "endpoint": "ess.ap-south-1.aliyuncs.com" + }, + { + "region": "eu-central-1", + "endpoint": "ess.eu-central-1.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "ess.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "ess.aliyuncs.com" + }, + { + "region": "cn-huhehaote", + "endpoint": "ess.cn-huhehaote.aliyuncs.com" + }, + { + "region": "ap-southeast-2", + "endpoint": "ess.ap-southeast-2.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "ess.aliyuncs.com" + }, + { + "region": "cn-hongkong", + "endpoint": "ess.aliyuncs.com" + }, + { + "region": "us-west-1", + "endpoint": "ess.aliyuncs.com" + }, + { + "region": "us-east-1", + "endpoint": "ess.aliyuncs.com" + }, + { + "region": "ap-southeast-5", + "endpoint": "ess.ap-southeast-5.aliyuncs.com" + }, + { + "region": "cn-qingdao", + "endpoint": "ess.aliyuncs.com" + }, + { + "region": "ap-southeast-3", + "endpoint": "ess.ap-southeast-3.aliyuncs.com" + }, + { + "region": "cn-zhangjiakou", + "endpoint": "ess.cn-zhangjiakou.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "ess.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "ess.aliyuncs.com" + }, + { + "region": "eu-west-1", + "endpoint": "ess.eu-west-1.aliyuncs.com" + } + ], + "global_endpoint": "ess.aliyuncs.com", + "regional_endpoint_pattern": "ess.[RegionId].aliyuncs.com" + }, + { + "code": "live", + "document_id": "48207", + "location_service_code": "live", + "regional_endpoints": [ + { + "region": "cn-beijing", + "endpoint": "live.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "live.aliyuncs.com" + }, + { + "region": "ap-northeast-1", + "endpoint": "live.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "live.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "live.aliyuncs.com" + }, + { + "region": "eu-central-1", + "endpoint": "live.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "live.aliyuncs.com" + } + ], + "global_endpoint": "live.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "hpc", + "document_id": "35201", + "location_service_code": "hpc", + "regional_endpoints": [ + { + "region": "cn-hangzhou", + "endpoint": "hpc.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "hpc.aliyuncs.com" + } + ], + "global_endpoint": "hpc.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "rds", + "document_id": "26223", + "location_service_code": "rds", + "regional_endpoints": [ + { + "region": "me-east-1", + "endpoint": "rds.me-east-1.aliyuncs.com" + }, + { + "region": "ap-south-1", + "endpoint": "rds.ap-south-1.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "rds.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "rds.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "rds.aliyuncs.com" + }, + { + "region": "ap-southeast-3", + "endpoint": "rds.ap-southeast-3.aliyuncs.com" + }, + { + "region": "ap-southeast-2", + "endpoint": "rds.ap-southeast-2.aliyuncs.com" + }, + { + "region": "cn-zhangjiakou", + "endpoint": "rds.cn-zhangjiakou.aliyuncs.com" + }, + { + "region": "cn-qingdao", + "endpoint": "rds.aliyuncs.com" + }, + { + "region": "us-west-1", + "endpoint": "rds.aliyuncs.com" + }, + { + "region": "us-east-1", + "endpoint": "rds.aliyuncs.com" + }, + { + "region": "ap-southeast-5", + "endpoint": "rds.ap-southeast-5.aliyuncs.com" + }, + { + "region": "eu-central-1", + "endpoint": "rds.eu-central-1.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "rds.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "rds.aliyuncs.com" + }, + { + "region": "eu-west-1", + "endpoint": "rds.eu-west-1.aliyuncs.com" + }, + { + "region": "cn-huhehaote", + "endpoint": "rds.cn-huhehaote.aliyuncs.com" + }, + { + "region": "ap-northeast-1", + "endpoint": "rds.ap-northeast-1.aliyuncs.com" + }, + { + "region": "cn-hongkong", + "endpoint": "rds.aliyuncs.com" + } + ], + "global_endpoint": "rds.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "cloudapi", + "document_id": "43590", + "location_service_code": "apigateway", + "regional_endpoints": [ + { + "region": "cn-beijing", + "endpoint": "apigateway.cn-beijing.aliyuncs.com" + }, + { + "region": "ap-southeast-2", + "endpoint": "apigateway.ap-southeast-2.aliyuncs.com" + }, + { + "region": "ap-south-1", + "endpoint": "apigateway.ap-south-1.aliyuncs.com" + }, + { + "region": "us-east-1", + "endpoint": "apigateway.us-east-1.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "apigateway.cn-shanghai.aliyuncs.com" + }, + { + "region": "us-west-1", + "endpoint": "apigateway.us-west-1.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "apigateway.ap-southeast-1.aliyuncs.com" + }, + { + "region": "eu-central-1", + "endpoint": "apigateway.eu-central-1.aliyuncs.com" + }, + { + "region": "cn-qingdao", + "endpoint": "apigateway.cn-qingdao.aliyuncs.com" + }, + { + "region": "cn-zhangjiakou", + "endpoint": "apigateway.cn-zhangjiakou.aliyuncs.com" + }, + { + "region": "cn-huhehaote", + "endpoint": "apigateway.cn-huhehaote.aliyuncs.com" + }, + { + "region": "eu-west-1", + "endpoint": "apigateway.eu-west-1.aliyuncs.com" + }, + { + "region": "me-east-1", + "endpoint": "apigateway.me-east-1.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "apigateway.cn-hangzhou.aliyuncs.com" + }, + { + "region": "ap-northeast-1", + "endpoint": "apigateway.ap-northeast-1.aliyuncs.com" + }, + { + "region": "ap-southeast-5", + "endpoint": "apigateway.ap-southeast-5.aliyuncs.com" + }, + { + "region": "cn-hongkong", + "endpoint": "apigateway.cn-hongkong.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "apigateway.cn-shenzhen.aliyuncs.com" + }, + { + "region": "ap-southeast-3", + "endpoint": "apigateway.ap-southeast-3.aliyuncs.com" + } + ], + "global_endpoint": "", + "regional_endpoint_pattern": "apigateway.[RegionId].aliyuncs.com" + }, + { + "code": "sas-api", + "document_id": "28498", + "location_service_code": "sas", + "regional_endpoints": [ + { + "region": "cn-hangzhou", + "endpoint": "sas.aliyuncs.com" + } + ], + "global_endpoint": "", + "regional_endpoint_pattern": "" + }, + { + "code": "cs", + "document_id": "26043", + "location_service_code": "cs", + "regional_endpoints": null, + "global_endpoint": "cs.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "jaq", + "document_id": "35037", + "location_service_code": "jaq", + "regional_endpoints": null, + "global_endpoint": "jaq.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "r-kvstore", + "document_id": "60831", + "location_service_code": "redisa", + "regional_endpoints": [ + { + "region": "cn-huhehaote", + "endpoint": "r-kvstore.cn-huhehaote.aliyuncs.com" + }, + { + "region": "cn-zhangjiakou", + "endpoint": "r-kvstore.cn-zhangjiakou.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "r-kvstore.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "r-kvstore.aliyuncs.com" + }, + { + "region": "ap-south-1", + "endpoint": "r-kvstore.ap-south-1.aliyuncs.com" + }, + { + "region": "eu-central-1", + "endpoint": "r-kvstore.eu-central-1.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "r-kvstore.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "r-kvstore.aliyuncs.com" + }, + { + "region": "me-east-1", + "endpoint": "r-kvstore.me-east-1.aliyuncs.com" + }, + { + "region": "ap-northeast-1", + "endpoint": "r-kvstore.ap-northeast-1.aliyuncs.com" + }, + { + "region": "cn-hongkong", + "endpoint": "r-kvstore.cn-hongkong.aliyuncs.com" + }, + { + "region": "ap-southeast-2", + "endpoint": "r-kvstore.ap-southeast-2.aliyuncs.com" + }, + { + "region": "eu-west-1", + "endpoint": "r-kvstore.eu-west-1.aliyuncs.com" + }, + { + "region": "ap-southeast-5", + "endpoint": "r-kvstore.ap-southeast-5.aliyuncs.com" + }, + { + "region": "us-west-1", + "endpoint": "r-kvstore.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "r-kvstore.ap-southeast-1.aliyuncs.com" + }, + { + "region": "ap-southeast-3", + "endpoint": "r-kvstore.ap-southeast-3.aliyuncs.com" + }, + { + "region": "cn-qingdao", + "endpoint": "r-kvstore.aliyuncs.com" + }, + { + "region": "us-east-1", + "endpoint": "r-kvstore.aliyuncs.com" + } + ], + "global_endpoint": "r-kvstore.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "drds", + "document_id": "51111", + "location_service_code": "drds", + "regional_endpoints": [ + { + "region": "ap-southeast-1", + "endpoint": "drds.ap-southeast-1.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "drds.cn-hangzhou.aliyuncs.com" + } + ], + "global_endpoint": "drds.aliyuncs.com", + "regional_endpoint_pattern": "drds.aliyuncs.com" + }, + { + "code": "waf", + "document_id": "62847", + "location_service_code": "waf", + "regional_endpoints": [ + { + "region": "cn-hangzhou", + "endpoint": "wafopenapi.cn-hangzhou.aliyuncs.com" + } + ], + "global_endpoint": "", + "regional_endpoint_pattern": "" + }, + { + "code": "sts", + "document_id": "28756", + "location_service_code": "sts", + "regional_endpoints": null, + "global_endpoint": "sts.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "cr", + "document_id": "60716", + "location_service_code": "cr", + "regional_endpoints": null, + "global_endpoint": "cr.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "arms", + "document_id": "42924", + "location_service_code": "arms", + "regional_endpoints": [ + { + "region": "cn-hangzhou", + "endpoint": "arms.cn-hangzhou.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "arms.cn-shanghai.aliyuncs.com" + }, + { + "region": "cn-hongkong", + "endpoint": "arms.cn-hongkong.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "arms.ap-southeast-1.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "arms.cn-shenzhen.aliyuncs.com" + }, + { + "region": "cn-qingdao", + "endpoint": "arms.cn-qingdao.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "arms.cn-beijing.aliyuncs.com" + } + ], + "global_endpoint": "", + "regional_endpoint_pattern": "arms.[RegionId].aliyuncs.com" + }, + { + "code": "iot", + "document_id": "30557", + "location_service_code": "iot", + "regional_endpoints": [ + { + "region": "us-east-1", + "endpoint": "iot.us-east-1.aliyuncs.com" + }, + { + "region": "ap-northeast-1", + "endpoint": "iot.ap-northeast-1.aliyuncs.com" + }, + { + "region": "us-west-1", + "endpoint": "iot.us-west-1.aliyuncs.com" + }, + { + "region": "eu-central-1", + "endpoint": "iot.eu-central-1.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "iot.cn-shanghai.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "iot.ap-southeast-1.aliyuncs.com" + } + ], + "global_endpoint": "", + "regional_endpoint_pattern": "iot.[RegionId].aliyuncs.com" + }, + { + "code": "vpc", + "document_id": "34962", + "location_service_code": "vpc", + "regional_endpoints": [ + { + "region": "us-west-1", + "endpoint": "vpc.aliyuncs.com" + }, + { + "region": "us-east-1", + "endpoint": "vpc.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "vpc.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "vpc.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "vpc.aliyuncs.com" + }, + { + "region": "cn-huhehaote", + "endpoint": "vpc.cn-huhehaote.aliyuncs.com" + }, + { + "region": "me-east-1", + "endpoint": "vpc.me-east-1.aliyuncs.com" + }, + { + "region": "ap-northeast-1", + "endpoint": "vpc.ap-northeast-1.aliyuncs.com" + }, + { + "region": "ap-southeast-3", + "endpoint": "vpc.ap-southeast-3.aliyuncs.com" + }, + { + "region": "eu-central-1", + "endpoint": "vpc.eu-central-1.aliyuncs.com" + }, + { + "region": "ap-southeast-5", + "endpoint": "vpc.ap-southeast-5.aliyuncs.com" + }, + { + "region": "ap-south-1", + "endpoint": "vpc.ap-south-1.aliyuncs.com" + }, + { + "region": "cn-zhangjiakou", + "endpoint": "vpc.cn-zhangjiakou.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "vpc.aliyuncs.com" + }, + { + "region": "ap-southeast-2", + "endpoint": "vpc.ap-southeast-2.aliyuncs.com" + }, + { + "region": "cn-qingdao", + "endpoint": "vpc.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "vpc.aliyuncs.com" + }, + { + "region": "cn-hongkong", + "endpoint": "vpc.aliyuncs.com" + }, + { + "region": "eu-west-1", + "endpoint": "vpc.eu-west-1.aliyuncs.com" + } + ], + "global_endpoint": "vpc.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "aegis", + "document_id": "28449", + "location_service_code": "vipaegis", + "regional_endpoints": [ + { + "region": "ap-southeast-3", + "endpoint": "aegis.ap-southeast-3.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "aegis.cn-hangzhou.aliyuncs.com" + } + ], + "global_endpoint": "aegis.cn-hangzhou.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "domain", + "document_id": "42875", + "location_service_code": "domain", + "regional_endpoints": [ + { + "region": "cn-hangzhou", + "endpoint": "domain.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "domain-intl.aliyuncs.com" + } + ], + "global_endpoint": "domain.aliyuncs.com", + "regional_endpoint_pattern": "domain.aliyuncs.com" + }, + { + "code": "cdn", + "document_id": "27148", + "location_service_code": "cdn", + "regional_endpoints": [ + { + "region": "cn-hangzhou", + "endpoint": "cdn.aliyuncs.com" + } + ], + "global_endpoint": "cdn.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "qualitycheck", + "document_id": "50807", + "location_service_code": "qualitycheck", + "regional_endpoints": [ + { + "region": "cn-hangzhou", + "endpoint": "qualitycheck.cn-hangzhou.aliyuncs.com" + } + ], + "global_endpoint": "", + "regional_endpoint_pattern": "" + }, + { + "code": "emr", + "document_id": "28140", + "location_service_code": "emr", + "regional_endpoints": [ + { + "region": "us-east-1", + "endpoint": "emr.us-east-1.aliyuncs.com" + }, + { + "region": "ap-southeast-5", + "endpoint": "emr.ap-southeast-5.aliyuncs.com" + }, + { + "region": "eu-central-1", + "endpoint": "emr.eu-central-1.aliyuncs.com" + }, + { + "region": "eu-west-1", + "endpoint": "emr.eu-west-1.aliyuncs.com" + }, + { + "region": "us-west-1", + "endpoint": "emr.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "emr.aliyuncs.com" + }, + { + "region": "ap-south-1", + "endpoint": "emr.ap-south-1.aliyuncs.com" + }, + { + "region": "me-east-1", + "endpoint": "emr.me-east-1.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "emr.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "emr.aliyuncs.com" + }, + { + "region": "cn-hongkong", + "endpoint": "emr.cn-hongkong.aliyuncs.com" + }, + { + "region": "cn-huhehaote", + "endpoint": "emr.cn-huhehaote.aliyuncs.com" + }, + { + "region": "ap-northeast-1", + "endpoint": "emr.ap-northeast-1.aliyuncs.com" + }, + { + "region": "ap-southeast-3", + "endpoint": "emr.ap-southeast-3.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "emr.aliyuncs.com" + }, + { + "region": "ap-southeast-2", + "endpoint": "emr.ap-southeast-2.aliyuncs.com" + }, + { + "region": "cn-zhangjiakou", + "endpoint": "emr.cn-zhangjiakou.aliyuncs.com" + }, + { + "region": "cn-qingdao", + "endpoint": "emr.cn-qingdao.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "emr.aliyuncs.com" + } + ], + "global_endpoint": "emr.aliyuncs.com", + "regional_endpoint_pattern": "emr.[RegionId].aliyuncs.com" + }, + { + "code": "httpdns", + "document_id": "52679", + "location_service_code": "httpdns", + "regional_endpoints": null, + "global_endpoint": "httpdns-api.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "push", + "document_id": "30074", + "location_service_code": "push", + "regional_endpoints": null, + "global_endpoint": "cloudpush.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "cms", + "document_id": "28615", + "location_service_code": "cms", + "regional_endpoints": [ + { + "region": "cn-qingdao", + "endpoint": "metrics.cn-hangzhou.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "metrics.cn-hangzhou.aliyuncs.com" + }, + { + "region": "eu-west-1", + "endpoint": "metrics.eu-west-1.aliyuncs.com" + }, + { + "region": "eu-central-1", + "endpoint": "metrics.cn-hangzhou.aliyuncs.com" + }, + { + "region": "ap-northeast-1", + "endpoint": "metrics.ap-northeast-1.aliyuncs.com" + }, + { + "region": "ap-south-1", + "endpoint": "metrics.ap-south-1.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "metrics.cn-hangzhou.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "metrics.cn-hangzhou.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "metrics.cn-hangzhou.aliyuncs.com" + }, + { + "region": "ap-southeast-2", + "endpoint": "metrics.cn-hangzhou.aliyuncs.com" + }, + { + "region": "ap-southeast-5", + "endpoint": "metrics.ap-southeast-5.aliyuncs.com" + }, + { + "region": "cn-huhehaote", + "endpoint": "metrics.cn-huhehaote.aliyuncs.com" + }, + { + "region": "cn-zhangjiakou", + "endpoint": "metrics.cn-hangzhou.aliyuncs.com" + }, + { + "region": "me-east-1", + "endpoint": "metrics.cn-hangzhou.aliyuncs.com" + }, + { + "region": "ap-southeast-3", + "endpoint": "metrics.ap-southeast-3.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "metrics.cn-hangzhou.aliyuncs.com" + }, + { + "region": "cn-hongkong", + "endpoint": "metrics.cn-hangzhou.aliyuncs.com" + }, + { + "region": "us-west-1", + "endpoint": "metrics.cn-hangzhou.aliyuncs.com" + }, + { + "region": "us-east-1", + "endpoint": "metrics.cn-hangzhou.aliyuncs.com" + } + ], + "global_endpoint": "metrics.cn-hangzhou.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "nas", + "document_id": "62598", + "location_service_code": "nas", + "regional_endpoints": [ + { + "region": "ap-southeast-5", + "endpoint": "nas.ap-southeast-5.aliyuncs.com" + }, + { + "region": "ap-south-1", + "endpoint": "nas.ap-south-1.aliyuncs.com" + }, + { + "region": "us-west-1", + "endpoint": "nas.us-west-1.aliyuncs.com" + }, + { + "region": "ap-southeast-3", + "endpoint": "nas.ap-southeast-3.aliyuncs.com" + }, + { + "region": "cn-zhangjiakou", + "endpoint": "nas.cn-zhangjiakou.aliyuncs.com" + }, + { + "region": "ap-northeast-1", + "endpoint": "nas.ap-northeast-1.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "nas.cn-hangzhou.aliyuncs.com" + }, + { + "region": "cn-qingdao", + "endpoint": "nas.cn-qingdao.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "nas.cn-beijing.aliyuncs.com" + }, + { + "region": "ap-southeast-2", + "endpoint": "nas.ap-southeast-2.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "nas.cn-shenzhen.aliyuncs.com" + }, + { + "region": "eu-central-1", + "endpoint": "nas.eu-central-1.aliyuncs.com" + }, + { + "region": "cn-huhehaote", + "endpoint": "nas.cn-huhehaote.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "nas.cn-shanghai.aliyuncs.com" + }, + { + "region": "cn-hongkong", + "endpoint": "nas.cn-hongkong.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "nas.ap-southeast-1.aliyuncs.com" + }, + { + "region": "us-east-1", + "endpoint": "nas.us-east-1.aliyuncs.com" + } + ], + "global_endpoint": "", + "regional_endpoint_pattern": "" + }, + { + "code": "cds", + "document_id": "62887", + "location_service_code": "codepipeline", + "regional_endpoints": [ + { + "region": "cn-beijing", + "endpoint": "cds.cn-beijing.aliyuncs.com" + } + ], + "global_endpoint": "cds.cn-beijing.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "green", + "document_id": "28427", + "location_service_code": "green", + "regional_endpoints": [ + { + "region": "us-west-1", + "endpoint": "green.us-west-1.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "green.cn-beijing.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "green.ap-southeast-1.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "green.cn-shanghai.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "green.cn-hangzhou.aliyuncs.com" + } + ], + "global_endpoint": "green.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "ccc", + "document_id": "63027", + "location_service_code": "ccc", + "regional_endpoints": [ + { + "region": "cn-shanghai", + "endpoint": "ccc.cn-shanghai.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "ccc.cn-hangzhou.aliyuncs.com" + } + ], + "global_endpoint": "", + "regional_endpoint_pattern": "ccc.[RegionId].aliyuncs.com" + }, + { + "code": "ros", + "document_id": "28899", + "location_service_code": "ros", + "regional_endpoints": [ + { + "region": "cn-hangzhou", + "endpoint": "ros.aliyuncs.com" + } + ], + "global_endpoint": "ros.aliyuncs.com", + "regional_endpoint_pattern": "" + }, + { + "code": "mts", + "document_id": "29212", + "location_service_code": "mts", + "regional_endpoints": [ + { + "region": "ap-northeast-1", + "endpoint": "mts.ap-northeast-1.aliyuncs.com" + }, + { + "region": "cn-shanghai", + "endpoint": "mts.cn-shanghai.aliyuncs.com" + }, + { + "region": "cn-hongkong", + "endpoint": "mts.cn-hongkong.aliyuncs.com" + }, + { + "region": "cn-shenzhen", + "endpoint": "mts.cn-shenzhen.aliyuncs.com" + }, + { + "region": "us-west-1", + "endpoint": "mts.us-west-1.aliyuncs.com" + }, + { + "region": "cn-zhangjiakou", + "endpoint": "mts.cn-zhangjiakou.aliyuncs.com" + }, + { + "region": "eu-west-1", + "endpoint": "mts.eu-west-1.aliyuncs.com" + }, + { + "region": "ap-south-1", + "endpoint": "mts.ap-south-1.aliyuncs.com" + }, + { + "region": "cn-beijing", + "endpoint": "mts.cn-beijing.aliyuncs.com" + }, + { + "region": "cn-hangzhou", + "endpoint": "mts.cn-hangzhou.aliyuncs.com" + }, + { + "region": "ap-southeast-1", + "endpoint": "mts.ap-southeast-1.aliyuncs.com" + }, + { + "region": "eu-central-1", + "endpoint": "mts.eu-central-1.aliyuncs.com" + } + ], + "global_endpoint": "", + "regional_endpoint_pattern": "" + } + ] +}` var initOnce sync.Once var data interface{} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors/signature_does_not_match_wrapper.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors/signature_does_not_match_wrapper.go index c2f19e245e9d..4b09d7d71c99 100644 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors/signature_does_not_match_wrapper.go +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors/signature_does_not_match_wrapper.go @@ -7,7 +7,8 @@ import ( ) const SignatureDostNotMatchErrorCode = "SignatureDoesNotMatch" -const MessagePrefix = "Specified signature is not matched with our calculation. server string to sign is:" +const IncompleteSignatureErrorCode = "IncompleteSignature" +const MessageContain = "server string to sign is:" var debug utils.Debug @@ -20,14 +21,15 @@ type SignatureDostNotMatchWrapper struct { func (*SignatureDostNotMatchWrapper) tryWrap(error *ServerError, wrapInfo map[string]string) (ok bool) { clientStringToSign := wrapInfo["StringToSign"] - if error.errorCode == SignatureDostNotMatchErrorCode && clientStringToSign != "" { + if (error.errorCode == SignatureDostNotMatchErrorCode || error.errorCode == IncompleteSignatureErrorCode) && clientStringToSign != "" { message := error.message - if strings.HasPrefix(message, MessagePrefix) { - serverStringToSign := message[len(MessagePrefix):] + if strings.Contains(message, MessageContain) { + str := strings.Split(message, MessageContain) + serverStringToSign := str[1] if clientStringToSign == serverStringToSign { // user secret is error - error.recommend = "Please check you AccessKeySecret" + error.recommend = "InvalidAccessKeySecret: Please check you AccessKeySecret" } else { debug("Client StringToSign: %s", clientStringToSign) debug("Server StringToSign: %s", serverStringToSign) diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/acs_request.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/acs_request.go index 54aa3c962a75..ad961c8fd2ce 100644 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/acs_request.go +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/acs_request.go @@ -20,6 +20,7 @@ import ( "reflect" "strconv" "strings" + "time" "github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors" ) @@ -72,6 +73,12 @@ type AcsRequest interface { GetAcceptFormat() string GetLocationServiceCode() string GetLocationEndpointType() string + GetReadTimeout() time.Duration + GetConnectTimeout() time.Duration + SetReadTimeout(readTimeout time.Duration) + SetConnectTimeout(connectTimeout time.Duration) + SetHTTPSInsecure(isInsecure bool) + GetHTTPSInsecure() *bool GetUserAgent() map[string]string @@ -92,11 +99,14 @@ type AcsRequest interface { // base class type baseRequest struct { - Scheme string - Method string - Domain string - Port string - RegionId string + Scheme string + Method string + Domain string + Port string + RegionId string + ReadTimeout time.Duration + ConnectTimeout time.Duration + isInsecure *bool userAgent map[string]string product string @@ -127,6 +137,30 @@ func (request *baseRequest) GetFormParams() map[string]string { return request.FormParams } +func (request *baseRequest) GetReadTimeout() time.Duration { + return request.ReadTimeout +} + +func (request *baseRequest) GetConnectTimeout() time.Duration { + return request.ConnectTimeout +} + +func (request *baseRequest) SetReadTimeout(readTimeout time.Duration) { + request.ReadTimeout = readTimeout +} + +func (request *baseRequest) SetConnectTimeout(connectTimeout time.Duration) { + request.ConnectTimeout = connectTimeout +} + +func (request *baseRequest) GetHTTPSInsecure() *bool { + return request.isInsecure +} + +func (request *baseRequest) SetHTTPSInsecure(isInsecure bool) { + request.isInsecure = &isInsecure +} + func (request *baseRequest) GetContent() []byte { return request.Content } @@ -294,7 +328,7 @@ func flatRepeatedList(dataValue reflect.Value, request AcsRequest, position, pre for m := 0; m < repeatedFieldValue.Len(); m++ { elementValue := repeatedFieldValue.Index(m) key := prefix + name + "." + strconv.Itoa(m+1) - if elementValue.Type().String() == "string" { + if elementValue.Type().Kind().String() == "string" { value := elementValue.String() err = addParam(request, fieldPosition, key, value) if err != nil { diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/acs_request_test.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/acs_request_test.go deleted file mode 100644 index aeb9b8672a8f..000000000000 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/acs_request_test.go +++ /dev/null @@ -1,148 +0,0 @@ -package requests - -import ( - "bytes" - "io" - "testing" - - "github.com/stretchr/testify/assert" -) - -func Test_AcsRequest(t *testing.T) { - r := defaultBaseRequest() - assert.NotNil(t, r) - - // query params - query := r.GetQueryParams() - assert.Equal(t, 0, len(query)) - r.addQueryParam("key", "value") - assert.Equal(t, 1, len(query)) - assert.Equal(t, "value", query["key"]) - - // form params - form := r.GetFormParams() - assert.Equal(t, 0, len(form)) - r.addFormParam("key", "value") - assert.Equal(t, 1, len(form)) - assert.Equal(t, "value", form["key"]) - - // getter/setter for stringtosign - assert.Equal(t, "", r.GetStringToSign()) - r.SetStringToSign("s2s") - assert.Equal(t, "s2s", r.GetStringToSign()) - - // content type - _, contains := r.GetContentType() - assert.False(t, contains) - r.SetContentType("application/json") - ct, contains := r.GetContentType() - assert.Equal(t, "application/json", ct) - assert.True(t, contains) - - // default 3 headers & content-type - headers := r.GetHeaders() - assert.Equal(t, 4, len(headers)) - r.addHeaderParam("x-key", "x-key-value") - assert.Equal(t, 5, len(headers)) - assert.Equal(t, "x-key-value", headers["x-key"]) - - // GetVersion - assert.Equal(t, "", r.GetVersion()) - // GetActionName - assert.Equal(t, "", r.GetActionName()) - - // GetMethod - assert.Equal(t, "GET", r.GetMethod()) - r.Method = "POST" - assert.Equal(t, "POST", r.GetMethod()) - - // Domain - assert.Equal(t, "", r.GetDomain()) - r.SetDomain("ecs.aliyuncs.com") - assert.Equal(t, "ecs.aliyuncs.com", r.GetDomain()) - - // Region - assert.Equal(t, "", r.GetRegionId()) - r.RegionId = "cn-hangzhou" - assert.Equal(t, "cn-hangzhou", r.GetRegionId()) - - // AcceptFormat - assert.Equal(t, "JSON", r.GetAcceptFormat()) - r.AcceptFormat = "XML" - assert.Equal(t, "XML", r.GetAcceptFormat()) - - // GetLocationServiceCode - assert.Equal(t, "", r.GetLocationServiceCode()) - - // GetLocationEndpointType - assert.Equal(t, "", r.GetLocationEndpointType()) - - // GetProduct - assert.Equal(t, "", r.GetProduct()) - - // GetScheme - assert.Equal(t, "", r.GetScheme()) - r.SetScheme("HTTPS") - assert.Equal(t, "HTTPS", r.GetScheme()) - - // GetPort - assert.Equal(t, "", r.GetPort()) - - // GetUserAgent - r.AppendUserAgent("cli", "1.01") - assert.Equal(t, "1.01", r.GetUserAgent()["cli"]) - // Content - assert.Equal(t, []byte(nil), r.GetContent()) - r.SetContent([]byte("The Content")) - assert.True(t, bytes.Equal([]byte("The Content"), r.GetContent())) -} - -type AcsRequestTest struct { - *baseRequest - Ontology AcsRequest - Query string `position:"Query" name:"Query"` - Header string `position:"Header" name:"Header"` - Path string `position:"Path" name:"Path"` - Body string `position:"Body" name:"Body"` - TypeAcs *[]string `position:"type" name:"type" type:"Repeated"` -} - -func (r AcsRequestTest) BuildQueries() string { - return "" -} - -func (r AcsRequestTest) BuildUrl() string { - return "" -} - -func (r AcsRequestTest) GetBodyReader() io.Reader { - return nil -} - -func (r AcsRequestTest) GetStyle() string { - return "" -} - -func (r AcsRequestTest) addPathParam(key, value string) { - return -} - -func Test_AcsRequest_InitParams(t *testing.T) { - r := &AcsRequestTest{ - baseRequest: defaultBaseRequest(), - Query: "query value", - Header: "header value", - Path: "path value", - Body: "body value", - } - tmp := []string{r.Query, r.Header} - r.TypeAcs = &tmp - r.addQueryParam("qkey", "qvalue") - InitParams(r) - - queries := r.GetQueryParams() - assert.Equal(t, "query value", queries["Query"]) - headers := r.GetHeaders() - assert.Equal(t, "header value", headers["Header"]) - // TODO: check the body & path -} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/common_request_test.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/common_request_test.go deleted file mode 100644 index 7d3a13c78b4f..000000000000 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/common_request_test.go +++ /dev/null @@ -1,82 +0,0 @@ -package requests - -import ( - "io/ioutil" - "testing" - - "github.com/stretchr/testify/assert" -) - -func Test_NewCommonRequest(t *testing.T) { - r := NewCommonRequest() - assert.NotNil(t, r) - - assert.Equal(t, "common", r.GetHeaders()["x-sdk-invoke-type"]) - assert.Equal(t, 0, len(r.PathParams)) - - r.addPathParam("name", "value") - assert.Equal(t, "value", r.PathParams["name"]) -} - -func Test_CommonRequest_TransToAcsRequest(t *testing.T) { - r := NewCommonRequest() - assert.NotNil(t, r) - r.TransToAcsRequest() - - assert.Equal(t, "RPC", r.GetStyle()) - - r2 := NewCommonRequest() - assert.NotNil(t, r2) - r2.PathPattern = "/users/[user]" - r2.TransToAcsRequest() - - assert.Equal(t, "ROA", r2.GetStyle()) -} - -func Test_CommonRequest_String(t *testing.T) { - r := NewCommonRequest() - assert.NotNil(t, r) - r.SetDomain("domain") - - expected := `GET /? /1.1 -Host: domain -Accept-Encoding: identity -x-sdk-client: golang/1.0.0 -x-sdk-invoke-type: common - -` - assert.Equal(t, expected, r.String()) - - r.SetContent([]byte("content")) - - expected = `GET /? /1.1 -Host: domain -Accept-Encoding: identity -x-sdk-client: golang/1.0.0 -x-sdk-invoke-type: common - -content -` - assert.Equal(t, expected, r.String()) -} - -func Test_CommonRequest_BuildUrl(t *testing.T) { - r := NewCommonRequest() - assert.NotNil(t, r) - r.SetDomain("host") - r.SetScheme("http") - - r.TransToAcsRequest() - - assert.Equal(t, "http://host/?", r.BuildUrl()) - r.Port = "8080" - assert.Equal(t, "http://host:8080/?", r.BuildUrl()) -} - -func Test_CommonRequest_GetBodyReader(t *testing.T) { - r := NewCommonRequest() - r.TransToAcsRequest() - reader := r.GetBodyReader() - b, _ := ioutil.ReadAll(reader) - assert.Equal(t, "", string(b)) -} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/roa_request.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/roa_request.go index d03cbfa3197c..12e02cc4f517 100644 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/roa_request.go +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/roa_request.go @@ -134,7 +134,7 @@ func (request *RoaRequest) InitWithApiInfo(product, version, action, uriPattern, request.pathPattern = uriPattern request.locationServiceCode = serviceCode request.locationEndpointType = endpointType - //request.product = product + request.product = product //request.version = version //request.actionName = action } @@ -142,7 +142,7 @@ func (request *RoaRequest) InitWithApiInfo(product, version, action, uriPattern, func (request *RoaRequest) initWithCommonRequest(commonRequest *CommonRequest) { request.baseRequest = commonRequest.baseRequest request.PathParams = commonRequest.PathParams - //request.product = commonRequest.Product + request.product = commonRequest.Product //request.version = commonRequest.Version request.Headers["x-acs-version"] = commonRequest.Version //request.actionName = commonRequest.ApiName diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/roa_request_test.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/roa_request_test.go deleted file mode 100644 index 5ee21f83b87b..000000000000 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/roa_request_test.go +++ /dev/null @@ -1,116 +0,0 @@ -package requests - -import ( - "io/ioutil" - "testing" - - "github.com/stretchr/testify/assert" -) - -func Test_RoaRequest(t *testing.T) { - r := &RoaRequest{} - r.InitWithApiInfo("product", "version", "action", "/", "serviceCode", "endpointType") - assert.NotNil(t, r) - - assert.Equal(t, "GET", r.GetMethod()) - assert.Equal(t, "ROA", r.GetStyle()) - // assert.Equal(t, "version", r.GetVersion()) - // assert.Equal(t, "action", r.GetActionName()) - assert.Equal(t, "serviceCode", r.GetLocationServiceCode()) - assert.Equal(t, "endpointType", r.GetLocationEndpointType()) -} - -func Test_RoaRequest_initWithCommonRequest(t *testing.T) { - r := &RoaRequest{} - common := NewCommonRequest() - r.initWithCommonRequest(common) - assert.NotNil(t, r) - - assert.Equal(t, "GET", r.GetMethod()) - assert.Equal(t, "ROA", r.GetStyle()) - assert.Equal(t, "common", r.Headers["x-sdk-invoke-type"]) - // assert.Equal(t, "version", r.GetVersion()) - // assert.Equal(t, "action", r.GetActionName()) -} - -func Test_RoaRequest_BuildQueries(t *testing.T) { - // url - r := &RoaRequest{} - r.InitWithApiInfo("product", "version", "action", "/", "serviceCode", "endpointType") - assert.Equal(t, "/", r.BuildQueries()) - r.addQueryParam("key", "value") - assert.Equal(t, "/?key=value", r.BuildQueries()) - r.addQueryParam("key2", "value2") - assert.Equal(t, "/?key=value&key2=value2", r.BuildQueries()) - // assert.Equal(t, "/?key=https%3A%2F%2Fdomain%2F%3Fq%3Dv", r.BuildQueries()) -} - -func Test_RoaRequest_BuildUrl(t *testing.T) { - r := &RoaRequest{} - r.InitWithApiInfo("product", "version", "action", "/", "serviceCode", "endpointType") - r.Domain = "domain.com" - r.Scheme = "http" - r.Port = "80" - assert.Equal(t, "http://domain.com:80/", r.BuildUrl()) - r.addQueryParam("key", "value") - assert.Equal(t, "http://domain.com:80/?key=value", r.BuildUrl()) - r.addQueryParam("key", "https://domain/?q=v") - assert.Equal(t, "http://domain.com:80/?key=https%3A%2F%2Fdomain%2F%3Fq%3Dv", r.BuildUrl()) - r.addQueryParam("url", "https://domain/?q1=v1&q2=v2") - assert.Equal(t, "http://domain.com:80/?key=https%3A%2F%2Fdomain%2F%3Fq%3Dv&url=https%3A%2F%2Fdomain%2F%3Fq1%3Dv1%26q2%3Dv2", r.BuildUrl()) -} - -func Test_RoaRequest_BuildUrl2(t *testing.T) { - r := &RoaRequest{} - r.InitWithApiInfo("product", "version", "action", "/", "serviceCode", "endpointType") - r.Domain = "domain.com" - r.Scheme = "http" - r.Port = "80" - assert.Equal(t, "http://domain.com:80/", r.BuildUrl()) - r.addPathParam("key", "value") - assert.Equal(t, "http://domain.com:80/", r.BuildUrl()) - - r = &RoaRequest{} - r.InitWithApiInfo("product", "version", "action", "/users/[user]", "serviceCode", "endpointType") - r.Domain = "domain.com" - r.Scheme = "http" - r.Port = "80" - r.addPathParam("user", "name") - assert.Equal(t, "http://domain.com:80/users/name", r.BuildUrl()) - r.addQueryParam("key", "value") - assert.Equal(t, "http://domain.com:80/users/name?key=value", r.BuildUrl()) -} - -func Test_RoaRequest_GetBodyReader_Nil(t *testing.T) { - r := &RoaRequest{} - r.InitWithApiInfo("product", "version", "action", "/", "serviceCode", "endpointType") - - reader := r.GetBodyReader() - assert.Nil(t, reader) -} - -func Test_RoaRequest_GetBodyReader_Form(t *testing.T) { - r := &RoaRequest{} - r.InitWithApiInfo("product", "version", "action", "/", "serviceCode", "endpointType") - - r.addFormParam("key", "value") - reader := r.GetBodyReader() - b, _ := ioutil.ReadAll(reader) - assert.Equal(t, "key=value", string(b)) -} - -func Test_RoaRequest_GetBodyReader_Content(t *testing.T) { - r := &RoaRequest{} - r.InitWithApiInfo("product", "version", "action", "/", "serviceCode", "endpointType") - - r.SetContent([]byte("Hello world")) - reader := r.GetBodyReader() - b, _ := ioutil.ReadAll(reader) - assert.Equal(t, "Hello world", string(b)) -} - -// func Test_RoaRequest_addPathParam(t *testing.T) { -// r := &RoaRequest{} -// r.InitWithApiInfo("product", "version", "action", "/", "serviceCode", "endpointType") -// r.addPathParam("key", "value") -// } diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/rpc_request_test.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/rpc_request_test.go deleted file mode 100644 index 33ac0a0aa4aa..000000000000 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/rpc_request_test.go +++ /dev/null @@ -1,70 +0,0 @@ -package requests - -import ( - "io/ioutil" - "testing" - - "github.com/stretchr/testify/assert" -) - -func Test_RpcRequest(t *testing.T) { - r := &RpcRequest{} - r.InitWithApiInfo("product", "version", "action", "serviceCode", "endpointType") - assert.NotNil(t, r) - - assert.Equal(t, "POST", r.GetMethod()) - assert.Equal(t, "RPC", r.GetStyle()) - assert.Equal(t, "product", r.GetProduct()) - assert.Equal(t, "version", r.GetVersion()) - assert.Equal(t, "action", r.GetActionName()) - assert.Equal(t, "serviceCode", r.GetLocationServiceCode()) - assert.Equal(t, "endpointType", r.GetLocationEndpointType()) -} - -func Test_RpcRequest_BuildQueries(t *testing.T) { - // url - r := &RpcRequest{} - r.InitWithApiInfo("product", "version", "action", "serviceCode", "endpointType") - assert.Equal(t, "/?", r.BuildQueries()) - r.addQueryParam("key", "value") - assert.Equal(t, "/?key=value", r.BuildQueries()) - r.addQueryParam("key", "https://domain/?q=v") - assert.Equal(t, "/?key=https%3A%2F%2Fdomain%2F%3Fq%3Dv", r.BuildQueries()) -} - -func Test_RpcRequest_BuildUrl(t *testing.T) { - r := &RpcRequest{} - r.InitWithApiInfo("product", "version", "action", "serviceCode", "endpointType") - r.Domain = "domain.com" - r.Scheme = "http" - r.Port = "80" - assert.Equal(t, "http://domain.com:80/?", r.BuildUrl()) - r.addQueryParam("key", "value") - assert.Equal(t, "http://domain.com:80/?key=value", r.BuildUrl()) - r.addQueryParam("key", "https://domain/?q=v") - assert.Equal(t, "http://domain.com:80/?key=https%3A%2F%2Fdomain%2F%3Fq%3Dv", r.BuildUrl()) -} - -func Test_RpcRequest_GetBodyReader(t *testing.T) { - r := &RpcRequest{} - r.InitWithApiInfo("product", "version", "action", "serviceCode", "endpointType") - - reader := r.GetBodyReader() - b, _ := ioutil.ReadAll(reader) - assert.Equal(t, "", string(b)) - r.addFormParam("key", "value") - reader = r.GetBodyReader() - b, _ = ioutil.ReadAll(reader) - assert.Equal(t, "key=value", string(b)) -} - -func Test_RpcRequest_addPathParam(t *testing.T) { - defer func() { //进行异常捕捉 - err := recover() - assert.NotNil(t, err) - assert.Equal(t, "not support", err) - }() - r := &RpcRequest{} - r.InitWithApiInfo("product", "version", "action", "serviceCode", "endpointType") - r.addPathParam("key", "value") -} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/types_test.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/types_test.go deleted file mode 100644 index 0f0f05f26253..000000000000 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests/types_test.go +++ /dev/null @@ -1,51 +0,0 @@ -package requests - -import ( - "testing" - - "github.com/stretchr/testify/assert" -) - -func TestNewInteger(t *testing.T) { - integer := NewInteger(123123) - assert.True(t, integer.HasValue()) - value, err := integer.GetValue() - assert.Nil(t, err) - assert.Equal(t, 123123, value) - var expected Integer - expected = "123123" - assert.Equal(t, expected, integer) -} - -func TestNewInteger64(t *testing.T) { - long := NewInteger64(123123123123123123) - assert.True(t, long.HasValue()) - value, err := long.GetValue64() - assert.Nil(t, err) - assert.Equal(t, int64(123123123123123123), value) - var expected Integer - expected = "123123123123123123" - assert.Equal(t, expected, long) -} - -func TestNewBoolean(t *testing.T) { - boolean := NewBoolean(false) - assert.True(t, boolean.HasValue()) - value, err := boolean.GetValue() - assert.Nil(t, err) - assert.Equal(t, false, value) - var expected Boolean - expected = "false" - assert.Equal(t, expected, boolean) -} - -func TestNewFloat(t *testing.T) { - float := NewFloat(123123.123123) - assert.True(t, float.HasValue()) - value, err := float.GetValue() - assert.Nil(t, err) - assert.Equal(t, 123123.123123, value) - var expected Float - expected = "123123.123123" - assert.Equal(t, expected, float) -} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/resource/tzdata.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/resource/tzdata.go deleted file mode 100644 index 58f353988548..000000000000 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/resource/tzdata.go +++ /dev/null @@ -1,6 +0,0 @@ -package resource - -func GetTZData(name string) ([]byte, bool) { - data, ok := files["zoneinfo/"+name] - return data, ok -} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/resource/zoneinfo.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/resource/zoneinfo.go deleted file mode 100644 index e0fe9d39b4d1..000000000000 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/resource/zoneinfo.go +++ /dev/null @@ -1,1190 +0,0 @@ -package resource - -var fileNames = []string{"zoneinfo/Africa/Abidjan", "zoneinfo/Africa/Accra", "zoneinfo/Africa/Addis_Ababa", "zoneinfo/Africa/Algiers", "zoneinfo/Africa/Asmara", "zoneinfo/Africa/Asmera", "zoneinfo/Africa/Bamako", "zoneinfo/Africa/Bangui", "zoneinfo/Africa/Banjul", "zoneinfo/Africa/Bissau", "zoneinfo/Africa/Blantyre", "zoneinfo/Africa/Brazzaville", "zoneinfo/Africa/Bujumbura", "zoneinfo/Africa/Cairo", "zoneinfo/Africa/Casablanca", "zoneinfo/Africa/Ceuta", "zoneinfo/Africa/Conakry", "zoneinfo/Africa/Dakar", "zoneinfo/Africa/Dar_es_Salaam", "zoneinfo/Africa/Djibouti", "zoneinfo/Africa/Douala", "zoneinfo/Africa/El_Aaiun", "zoneinfo/Africa/Freetown", "zoneinfo/Africa/Gaborone", "zoneinfo/Africa/Harare", "zoneinfo/Africa/Johannesburg", "zoneinfo/Africa/Juba", "zoneinfo/Africa/Kampala", "zoneinfo/Africa/Khartoum", "zoneinfo/Africa/Kigali", "zoneinfo/Africa/Kinshasa", "zoneinfo/Africa/Lagos", "zoneinfo/Africa/Libreville", "zoneinfo/Africa/Lome", "zoneinfo/Africa/Luanda", "zoneinfo/Africa/Lubumbashi", "zoneinfo/Africa/Lusaka", "zoneinfo/Africa/Malabo", "zoneinfo/Africa/Maputo", "zoneinfo/Africa/Maseru", "zoneinfo/Africa/Mbabane", "zoneinfo/Africa/Mogadishu", "zoneinfo/Africa/Monrovia", "zoneinfo/Africa/Nairobi", "zoneinfo/Africa/Ndjamena", "zoneinfo/Africa/Niamey", "zoneinfo/Africa/Nouakchott", "zoneinfo/Africa/Ouagadougou", "zoneinfo/Africa/Porto-Novo", "zoneinfo/Africa/Sao_Tome", "zoneinfo/Africa/Timbuktu", "zoneinfo/Africa/Tripoli", "zoneinfo/Africa/Tunis", "zoneinfo/Africa/Windhoek", "zoneinfo/America/Adak", "zoneinfo/America/Anchorage", "zoneinfo/America/Anguilla", "zoneinfo/America/Antigua", "zoneinfo/America/Araguaina", "zoneinfo/America/Argentina/Buenos_Aires", "zoneinfo/America/Argentina/Catamarca", "zoneinfo/America/Argentina/ComodRivadavia", "zoneinfo/America/Argentina/Cordoba", "zoneinfo/America/Argentina/Jujuy", "zoneinfo/America/Argentina/La_Rioja", "zoneinfo/America/Argentina/Mendoza", "zoneinfo/America/Argentina/Rio_Gallegos", "zoneinfo/America/Argentina/Salta", "zoneinfo/America/Argentina/San_Juan", "zoneinfo/America/Argentina/San_Luis", "zoneinfo/America/Argentina/Tucuman", "zoneinfo/America/Argentina/Ushuaia", "zoneinfo/America/Aruba", "zoneinfo/America/Asuncion", "zoneinfo/America/Atikokan", "zoneinfo/America/Atka", "zoneinfo/America/Bahia", "zoneinfo/America/Bahia_Banderas", "zoneinfo/America/Barbados", "zoneinfo/America/Belem", "zoneinfo/America/Belize", "zoneinfo/America/Blanc-Sablon", "zoneinfo/America/Boa_Vista", "zoneinfo/America/Bogota", "zoneinfo/America/Boise", "zoneinfo/America/Buenos_Aires", "zoneinfo/America/Cambridge_Bay", "zoneinfo/America/Campo_Grande", "zoneinfo/America/Cancun", "zoneinfo/America/Caracas", "zoneinfo/America/Catamarca", "zoneinfo/America/Cayenne", "zoneinfo/America/Cayman", "zoneinfo/America/Chicago", "zoneinfo/America/Chihuahua", "zoneinfo/America/Coral_Harbour", "zoneinfo/America/Cordoba", "zoneinfo/America/Costa_Rica", "zoneinfo/America/Creston", "zoneinfo/America/Cuiaba", "zoneinfo/America/Curacao", "zoneinfo/America/Danmarkshavn", "zoneinfo/America/Dawson", "zoneinfo/America/Dawson_Creek", "zoneinfo/America/Denver", "zoneinfo/America/Detroit", "zoneinfo/America/Dominica", "zoneinfo/America/Edmonton", "zoneinfo/America/Eirunepe", "zoneinfo/America/El_Salvador", "zoneinfo/America/Ensenada", "zoneinfo/America/Fort_Nelson", "zoneinfo/America/Fort_Wayne", "zoneinfo/America/Fortaleza", "zoneinfo/America/Glace_Bay", "zoneinfo/America/Godthab", "zoneinfo/America/Goose_Bay", "zoneinfo/America/Grand_Turk", "zoneinfo/America/Grenada", "zoneinfo/America/Guadeloupe", "zoneinfo/America/Guatemala", "zoneinfo/America/Guayaquil", "zoneinfo/America/Guyana", "zoneinfo/America/Halifax", "zoneinfo/America/Havana", "zoneinfo/America/Hermosillo", "zoneinfo/America/Indiana/Indianapolis", "zoneinfo/America/Indiana/Knox", "zoneinfo/America/Indiana/Marengo", "zoneinfo/America/Indiana/Petersburg", "zoneinfo/America/Indiana/Tell_City", "zoneinfo/America/Indiana/Vevay", "zoneinfo/America/Indiana/Vincennes", "zoneinfo/America/Indiana/Winamac", "zoneinfo/America/Indianapolis", "zoneinfo/America/Inuvik", "zoneinfo/America/Iqaluit", "zoneinfo/America/Jamaica", "zoneinfo/America/Jujuy", "zoneinfo/America/Juneau", "zoneinfo/America/Kentucky/Louisville", "zoneinfo/America/Kentucky/Monticello", "zoneinfo/America/Knox_IN", "zoneinfo/America/Kralendijk", "zoneinfo/America/La_Paz", "zoneinfo/America/Lima", "zoneinfo/America/Los_Angeles", "zoneinfo/America/Louisville", "zoneinfo/America/Lower_Princes", "zoneinfo/America/Maceio", "zoneinfo/America/Managua", "zoneinfo/America/Manaus", "zoneinfo/America/Marigot", "zoneinfo/America/Martinique", "zoneinfo/America/Matamoros", "zoneinfo/America/Mazatlan", "zoneinfo/America/Mendoza", "zoneinfo/America/Menominee", "zoneinfo/America/Merida", "zoneinfo/America/Metlakatla", "zoneinfo/America/Mexico_City", "zoneinfo/America/Miquelon", "zoneinfo/America/Moncton", "zoneinfo/America/Monterrey", "zoneinfo/America/Montevideo", "zoneinfo/America/Montreal", "zoneinfo/America/Montserrat", "zoneinfo/America/Nassau", "zoneinfo/America/New_York", "zoneinfo/America/Nipigon", "zoneinfo/America/Nome", "zoneinfo/America/Noronha", "zoneinfo/America/North_Dakota/Beulah", "zoneinfo/America/North_Dakota/Center", "zoneinfo/America/North_Dakota/New_Salem", "zoneinfo/America/Ojinaga", "zoneinfo/America/Panama", "zoneinfo/America/Pangnirtung", "zoneinfo/America/Paramaribo", "zoneinfo/America/Phoenix", "zoneinfo/America/Port-au-Prince", "zoneinfo/America/Port_of_Spain", "zoneinfo/America/Porto_Acre", "zoneinfo/America/Porto_Velho", "zoneinfo/America/Puerto_Rico", "zoneinfo/America/Punta_Arenas", "zoneinfo/America/Rainy_River", "zoneinfo/America/Rankin_Inlet", "zoneinfo/America/Recife", "zoneinfo/America/Regina", "zoneinfo/America/Resolute", "zoneinfo/America/Rio_Branco", "zoneinfo/America/Rosario", "zoneinfo/America/Santa_Isabel", "zoneinfo/America/Santarem", "zoneinfo/America/Santiago", "zoneinfo/America/Santo_Domingo", "zoneinfo/America/Sao_Paulo", "zoneinfo/America/Scoresbysund", "zoneinfo/America/Shiprock", "zoneinfo/America/Sitka", "zoneinfo/America/St_Barthelemy", "zoneinfo/America/St_Johns", "zoneinfo/America/St_Kitts", "zoneinfo/America/St_Lucia", "zoneinfo/America/St_Thomas", "zoneinfo/America/St_Vincent", "zoneinfo/America/Swift_Current", "zoneinfo/America/Tegucigalpa", "zoneinfo/America/Thule", "zoneinfo/America/Thunder_Bay", "zoneinfo/America/Tijuana", "zoneinfo/America/Toronto", "zoneinfo/America/Tortola", "zoneinfo/America/Vancouver", "zoneinfo/America/Virgin", "zoneinfo/America/Whitehorse", "zoneinfo/America/Winnipeg", "zoneinfo/America/Yakutat", "zoneinfo/America/Yellowknife", "zoneinfo/Antarctica/Casey", "zoneinfo/Antarctica/Davis", "zoneinfo/Antarctica/DumontDUrville", "zoneinfo/Antarctica/Macquarie", "zoneinfo/Antarctica/Mawson", "zoneinfo/Antarctica/McMurdo", "zoneinfo/Antarctica/Palmer", "zoneinfo/Antarctica/Rothera", "zoneinfo/Antarctica/South_Pole", "zoneinfo/Antarctica/Syowa", "zoneinfo/Antarctica/Troll", "zoneinfo/Antarctica/Vostok", "zoneinfo/Arctic/Longyearbyen", "zoneinfo/Asia/Aden", "zoneinfo/Asia/Almaty", "zoneinfo/Asia/Amman", "zoneinfo/Asia/Anadyr", "zoneinfo/Asia/Aqtau", "zoneinfo/Asia/Aqtobe", "zoneinfo/Asia/Ashgabat", "zoneinfo/Asia/Ashkhabad", "zoneinfo/Asia/Atyrau", "zoneinfo/Asia/Baghdad", "zoneinfo/Asia/Bahrain", "zoneinfo/Asia/Baku", "zoneinfo/Asia/Bangkok", "zoneinfo/Asia/Barnaul", "zoneinfo/Asia/Beirut", "zoneinfo/Asia/Bishkek", "zoneinfo/Asia/Brunei", "zoneinfo/Asia/Calcutta", "zoneinfo/Asia/Chita", "zoneinfo/Asia/Choibalsan", "zoneinfo/Asia/Chongqing", "zoneinfo/Asia/Chungking", "zoneinfo/Asia/Colombo", "zoneinfo/Asia/Dacca", "zoneinfo/Asia/Damascus", "zoneinfo/Asia/Dhaka", "zoneinfo/Asia/Dili", "zoneinfo/Asia/Dubai", "zoneinfo/Asia/Dushanbe", "zoneinfo/Asia/Famagusta", "zoneinfo/Asia/Gaza", "zoneinfo/Asia/Harbin", "zoneinfo/Asia/Hebron", "zoneinfo/Asia/Ho_Chi_Minh", "zoneinfo/Asia/Hong_Kong", "zoneinfo/Asia/Hovd", "zoneinfo/Asia/Irkutsk", "zoneinfo/Asia/Istanbul", "zoneinfo/Asia/Jakarta", "zoneinfo/Asia/Jayapura", "zoneinfo/Asia/Jerusalem", "zoneinfo/Asia/Kabul", "zoneinfo/Asia/Kamchatka", "zoneinfo/Asia/Karachi", "zoneinfo/Asia/Kashgar", "zoneinfo/Asia/Kathmandu", "zoneinfo/Asia/Katmandu", "zoneinfo/Asia/Khandyga", "zoneinfo/Asia/Kolkata", "zoneinfo/Asia/Krasnoyarsk", "zoneinfo/Asia/Kuala_Lumpur", "zoneinfo/Asia/Kuching", "zoneinfo/Asia/Kuwait", "zoneinfo/Asia/Macao", "zoneinfo/Asia/Macau", "zoneinfo/Asia/Magadan", "zoneinfo/Asia/Makassar", "zoneinfo/Asia/Manila", "zoneinfo/Asia/Muscat", "zoneinfo/Asia/Nicosia", "zoneinfo/Asia/Novokuznetsk", "zoneinfo/Asia/Novosibirsk", "zoneinfo/Asia/Omsk", "zoneinfo/Asia/Oral", "zoneinfo/Asia/Phnom_Penh", "zoneinfo/Asia/Pontianak", "zoneinfo/Asia/Pyongyang", "zoneinfo/Asia/Qatar", "zoneinfo/Asia/Qyzylorda", "zoneinfo/Asia/Rangoon", "zoneinfo/Asia/Riyadh", "zoneinfo/Asia/Saigon", "zoneinfo/Asia/Sakhalin", "zoneinfo/Asia/Samarkand", "zoneinfo/Asia/Seoul", "zoneinfo/Asia/Shanghai", "zoneinfo/Asia/Singapore", "zoneinfo/Asia/Srednekolymsk", "zoneinfo/Asia/Taipei", "zoneinfo/Asia/Tashkent", "zoneinfo/Asia/Tbilisi", "zoneinfo/Asia/Tehran", "zoneinfo/Asia/Tel_Aviv", "zoneinfo/Asia/Thimbu", "zoneinfo/Asia/Thimphu", "zoneinfo/Asia/Tokyo", "zoneinfo/Asia/Tomsk", "zoneinfo/Asia/Ujung_Pandang", "zoneinfo/Asia/Ulaanbaatar", "zoneinfo/Asia/Ulan_Bator", "zoneinfo/Asia/Urumqi", "zoneinfo/Asia/Ust-Nera", "zoneinfo/Asia/Vientiane", "zoneinfo/Asia/Vladivostok", "zoneinfo/Asia/Yakutsk", "zoneinfo/Asia/Yangon", "zoneinfo/Asia/Yekaterinburg", "zoneinfo/Asia/Yerevan", "zoneinfo/Atlantic/Azores", "zoneinfo/Atlantic/Bermuda", "zoneinfo/Atlantic/Canary", "zoneinfo/Atlantic/Cape_Verde", "zoneinfo/Atlantic/Faeroe", "zoneinfo/Atlantic/Faroe", "zoneinfo/Atlantic/Jan_Mayen", "zoneinfo/Atlantic/Madeira", "zoneinfo/Atlantic/Reykjavik", "zoneinfo/Atlantic/South_Georgia", "zoneinfo/Atlantic/St_Helena", "zoneinfo/Atlantic/Stanley", "zoneinfo/Australia/ACT", "zoneinfo/Australia/Adelaide", "zoneinfo/Australia/Brisbane", "zoneinfo/Australia/Broken_Hill", "zoneinfo/Australia/Canberra", "zoneinfo/Australia/Currie", "zoneinfo/Australia/Darwin", "zoneinfo/Australia/Eucla", "zoneinfo/Australia/Hobart", "zoneinfo/Australia/LHI", "zoneinfo/Australia/Lindeman", "zoneinfo/Australia/Lord_Howe", "zoneinfo/Australia/Melbourne", "zoneinfo/Australia/NSW", "zoneinfo/Australia/North", "zoneinfo/Australia/Perth", "zoneinfo/Australia/Queensland", "zoneinfo/Australia/South", "zoneinfo/Australia/Sydney", "zoneinfo/Australia/Tasmania", "zoneinfo/Australia/Victoria", "zoneinfo/Australia/West", "zoneinfo/Australia/Yancowinna", "zoneinfo/Brazil/Acre", "zoneinfo/Brazil/DeNoronha", "zoneinfo/Brazil/East", "zoneinfo/Brazil/West", "zoneinfo/CET", "zoneinfo/CST6CDT", "zoneinfo/Canada/Atlantic", "zoneinfo/Canada/Central", "zoneinfo/Canada/Eastern", "zoneinfo/Canada/Mountain", "zoneinfo/Canada/Newfoundland", "zoneinfo/Canada/Pacific", "zoneinfo/Canada/Saskatchewan", "zoneinfo/Canada/Yukon", "zoneinfo/Chile/Continental", "zoneinfo/Chile/EasterIsland", "zoneinfo/Cuba", "zoneinfo/EET", "zoneinfo/EST", "zoneinfo/EST5EDT", "zoneinfo/Egypt", "zoneinfo/Eire", "zoneinfo/Etc/GMT", "zoneinfo/Etc/GMT+0", "zoneinfo/Etc/GMT+1", "zoneinfo/Etc/GMT+10", "zoneinfo/Etc/GMT+11", "zoneinfo/Etc/GMT+12", "zoneinfo/Etc/GMT+2", "zoneinfo/Etc/GMT+3", "zoneinfo/Etc/GMT+4", "zoneinfo/Etc/GMT+5", "zoneinfo/Etc/GMT+6", "zoneinfo/Etc/GMT+7", "zoneinfo/Etc/GMT+8", "zoneinfo/Etc/GMT+9", "zoneinfo/Etc/GMT-0", "zoneinfo/Etc/GMT-1", "zoneinfo/Etc/GMT-10", "zoneinfo/Etc/GMT-11", "zoneinfo/Etc/GMT-12", "zoneinfo/Etc/GMT-13", "zoneinfo/Etc/GMT-14", "zoneinfo/Etc/GMT-2", "zoneinfo/Etc/GMT-3", "zoneinfo/Etc/GMT-4", "zoneinfo/Etc/GMT-5", "zoneinfo/Etc/GMT-6", "zoneinfo/Etc/GMT-7", "zoneinfo/Etc/GMT-8", "zoneinfo/Etc/GMT-9", "zoneinfo/Etc/GMT0", "zoneinfo/Etc/Greenwich", "zoneinfo/Etc/UCT", "zoneinfo/Etc/UTC", "zoneinfo/Etc/Universal", "zoneinfo/Etc/Zulu", "zoneinfo/Europe/Amsterdam", "zoneinfo/Europe/Andorra", "zoneinfo/Europe/Astrakhan", "zoneinfo/Europe/Athens", "zoneinfo/Europe/Belfast", "zoneinfo/Europe/Belgrade", "zoneinfo/Europe/Berlin", "zoneinfo/Europe/Bratislava", "zoneinfo/Europe/Brussels", "zoneinfo/Europe/Bucharest", "zoneinfo/Europe/Budapest", "zoneinfo/Europe/Busingen", "zoneinfo/Europe/Chisinau", "zoneinfo/Europe/Copenhagen", "zoneinfo/Europe/Dublin", "zoneinfo/Europe/Gibraltar", "zoneinfo/Europe/Guernsey", "zoneinfo/Europe/Helsinki", "zoneinfo/Europe/Isle_of_Man", "zoneinfo/Europe/Istanbul", "zoneinfo/Europe/Jersey", "zoneinfo/Europe/Kaliningrad", "zoneinfo/Europe/Kiev", "zoneinfo/Europe/Kirov", "zoneinfo/Europe/Lisbon", "zoneinfo/Europe/Ljubljana", "zoneinfo/Europe/London", "zoneinfo/Europe/Luxembourg", "zoneinfo/Europe/Madrid", "zoneinfo/Europe/Malta", "zoneinfo/Europe/Mariehamn", "zoneinfo/Europe/Minsk", "zoneinfo/Europe/Monaco", "zoneinfo/Europe/Moscow", "zoneinfo/Europe/Nicosia", "zoneinfo/Europe/Oslo", "zoneinfo/Europe/Paris", "zoneinfo/Europe/Podgorica", "zoneinfo/Europe/Prague", "zoneinfo/Europe/Riga", "zoneinfo/Europe/Rome", "zoneinfo/Europe/Samara", "zoneinfo/Europe/San_Marino", "zoneinfo/Europe/Sarajevo", "zoneinfo/Europe/Saratov", "zoneinfo/Europe/Simferopol", "zoneinfo/Europe/Skopje", "zoneinfo/Europe/Sofia", "zoneinfo/Europe/Stockholm", "zoneinfo/Europe/Tallinn", "zoneinfo/Europe/Tirane", "zoneinfo/Europe/Tiraspol", "zoneinfo/Europe/Ulyanovsk", "zoneinfo/Europe/Uzhgorod", "zoneinfo/Europe/Vaduz", "zoneinfo/Europe/Vatican", "zoneinfo/Europe/Vienna", "zoneinfo/Europe/Vilnius", "zoneinfo/Europe/Volgograd", "zoneinfo/Europe/Warsaw", "zoneinfo/Europe/Zagreb", "zoneinfo/Europe/Zaporozhye", "zoneinfo/Europe/Zurich", "zoneinfo/Factory", "zoneinfo/GB", "zoneinfo/GB-Eire", "zoneinfo/GMT", "zoneinfo/GMT+0", "zoneinfo/GMT-0", "zoneinfo/GMT0", "zoneinfo/Greenwich", "zoneinfo/HST", "zoneinfo/Hongkong", "zoneinfo/Iceland", "zoneinfo/Indian/Antananarivo", "zoneinfo/Indian/Chagos", "zoneinfo/Indian/Christmas", "zoneinfo/Indian/Cocos", "zoneinfo/Indian/Comoro", "zoneinfo/Indian/Kerguelen", "zoneinfo/Indian/Mahe", "zoneinfo/Indian/Maldives", "zoneinfo/Indian/Mauritius", "zoneinfo/Indian/Mayotte", "zoneinfo/Indian/Reunion", "zoneinfo/Iran", "zoneinfo/Israel", "zoneinfo/Jamaica", "zoneinfo/Japan", "zoneinfo/Kwajalein", "zoneinfo/Libya", "zoneinfo/MET", "zoneinfo/MST", "zoneinfo/MST7MDT", "zoneinfo/Mexico/BajaNorte", "zoneinfo/Mexico/BajaSur", "zoneinfo/Mexico/General", "zoneinfo/NZ", "zoneinfo/NZ-CHAT", "zoneinfo/Navajo", "zoneinfo/PRC", "zoneinfo/PST8PDT", "zoneinfo/Pacific/Apia", "zoneinfo/Pacific/Auckland", "zoneinfo/Pacific/Bougainville", "zoneinfo/Pacific/Chatham", "zoneinfo/Pacific/Chuuk", "zoneinfo/Pacific/Easter", "zoneinfo/Pacific/Efate", "zoneinfo/Pacific/Enderbury", "zoneinfo/Pacific/Fakaofo", "zoneinfo/Pacific/Fiji", "zoneinfo/Pacific/Funafuti", "zoneinfo/Pacific/Galapagos", "zoneinfo/Pacific/Gambier", "zoneinfo/Pacific/Guadalcanal", "zoneinfo/Pacific/Guam", "zoneinfo/Pacific/Honolulu", "zoneinfo/Pacific/Johnston", "zoneinfo/Pacific/Kiritimati", "zoneinfo/Pacific/Kosrae", "zoneinfo/Pacific/Kwajalein", "zoneinfo/Pacific/Majuro", "zoneinfo/Pacific/Marquesas", "zoneinfo/Pacific/Midway", "zoneinfo/Pacific/Nauru", "zoneinfo/Pacific/Niue", "zoneinfo/Pacific/Norfolk", "zoneinfo/Pacific/Noumea", "zoneinfo/Pacific/Pago_Pago", "zoneinfo/Pacific/Palau", "zoneinfo/Pacific/Pitcairn", "zoneinfo/Pacific/Pohnpei", "zoneinfo/Pacific/Ponape", "zoneinfo/Pacific/Port_Moresby", "zoneinfo/Pacific/Rarotonga", "zoneinfo/Pacific/Saipan", "zoneinfo/Pacific/Samoa", "zoneinfo/Pacific/Tahiti", "zoneinfo/Pacific/Tarawa", "zoneinfo/Pacific/Tongatapu", "zoneinfo/Pacific/Truk", "zoneinfo/Pacific/Wake", "zoneinfo/Pacific/Wallis", "zoneinfo/Pacific/Yap", "zoneinfo/Poland", "zoneinfo/Portugal", "zoneinfo/ROC", "zoneinfo/ROK", "zoneinfo/Singapore", "zoneinfo/Turkey", "zoneinfo/UCT", "zoneinfo/US/Alaska", "zoneinfo/US/Aleutian", "zoneinfo/US/Arizona", "zoneinfo/US/Central", "zoneinfo/US/East-Indiana", "zoneinfo/US/Eastern", "zoneinfo/US/Hawaii", "zoneinfo/US/Indiana-Starke", "zoneinfo/US/Michigan", "zoneinfo/US/Mountain", "zoneinfo/US/Pacific", "zoneinfo/US/Samoa", "zoneinfo/UTC", "zoneinfo/Universal", "zoneinfo/W-SU", "zoneinfo/WET", "zoneinfo/Zulu"} - -var files = map[string][]byte{ - - "zoneinfo/Africa/Abidjan": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 146, 230, 146, 72, 0, 1, 255, 255, 252, 56, 0, 0, 0, 0, 0, 0, 0, 4, 76, 77, 84, 0, 71, 77, 84, 0, 0, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Africa/Accra": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 48, 0, 0, 0, 3, 0, 0, 0, 14, 128, 0, 0, 0, 158, 48, 102, 180, 163, 52, 123, 128, 163, 211, 252, 80, 165, 21, 175, 0, 165, 181, 47, 208, 166, 246, 226, 128, 167, 150, 99, 80, 168, 216, 22, 0, 169, 119, 150, 208, 170, 186, 155, 0, 171, 90, 27, 208, 172, 155, 206, 128, 173, 59, 79, 80, 174, 125, 2, 0, 175, 28, 130, 208, 176, 94, 53, 128, 176, 253, 182, 80, 178, 64, 186, 128, 178, 224, 59, 80, 180, 33, 238, 0, 180, 193, 110, 208, 182, 3, 33, 128, 182, 162, 162, 80, 183, 228, 85, 0, 184, 131, 213, 208, 185, 198, 218, 0, 186, 102, 90, 208, 187, 168, 13, 128, 188, 71, 142, 80, 189, 137, 65, 0, 190, 40, 193, 208, 191, 106, 116, 128, 192, 9, 245, 80, 193, 76, 249, 128, 193, 236, 122, 80, 195, 46, 45, 0, 195, 205, 173, 208, 197, 15, 96, 128, 197, 174, 225, 80, 198, 240, 148, 0, 199, 144, 20, 208, 200, 211, 25, 0, 201, 114, 153, 208, 202, 180, 76, 128, 203, 83, 205, 80, 204, 149, 128, 0, 205, 53, 0, 208, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 255, 204, 0, 0, 0, 0, 4, 176, 1, 4, 0, 0, 0, 0, 0, 10, 76, 77, 84, 0, 43, 48, 48, 50, 48, 0, 71, 77, 84, 0, 0, 0, 0, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Africa/Addis_Ababa": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 177, 238, 218, 252, 180, 194, 154, 208, 199, 145, 71, 216, 237, 47, 225, 212, 0, 1, 2, 3, 1, 0, 0, 34, 132, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 35, 40, 0, 8, 0, 0, 38, 172, 0, 14, 0, 0, 42, 48, 0, 4, 76, 77, 84, 0, 69, 65, 84, 0, 43, 48, 50, 51, 48, 0, 43, 48, 50, 52, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 65, 84, 45, 51, 10}, - - "zoneinfo/Africa/Algiers": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 34, 0, 0, 0, 8, 0, 0, 0, 26, 128, 0, 0, 0, 145, 96, 80, 79, 155, 71, 120, 240, 155, 215, 44, 112, 156, 188, 145, 112, 157, 192, 72, 240, 158, 137, 254, 112, 159, 160, 42, 240, 160, 96, 165, 240, 161, 128, 12, 240, 162, 46, 18, 240, 163, 122, 76, 240, 164, 53, 129, 240, 164, 184, 6, 112, 198, 255, 6, 112, 199, 88, 186, 128, 199, 218, 9, 160, 207, 146, 52, 16, 208, 138, 0, 0, 209, 114, 22, 16, 210, 78, 36, 112, 212, 75, 7, 112, 229, 206, 211, 0, 243, 92, 176, 240, 2, 120, 193, 240, 3, 67, 200, 240, 13, 207, 215, 0, 14, 173, 68, 240, 15, 120, 90, 0, 16, 104, 89, 16, 18, 118, 67, 112, 19, 102, 66, 128, 20, 95, 124, 16, 21, 79, 95, 0, 1, 4, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 4, 6, 5, 6, 5, 6, 4, 6, 4, 2, 3, 7, 6, 5, 6, 4, 7, 4, 6, 0, 0, 2, 220, 0, 0, 0, 0, 2, 49, 0, 4, 0, 0, 14, 16, 1, 8, 0, 0, 0, 0, 0, 13, 0, 0, 0, 0, 0, 13, 0, 0, 28, 32, 1, 17, 0, 0, 14, 16, 0, 22, 0, 0, 14, 16, 1, 8, 76, 77, 84, 0, 80, 77, 84, 0, 87, 69, 83, 84, 0, 87, 69, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 67, 69, 84, 45, 49, 10}, - - "zoneinfo/Africa/Asmara": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 177, 238, 218, 252, 180, 194, 154, 208, 199, 145, 71, 216, 237, 47, 225, 212, 0, 1, 2, 3, 1, 0, 0, 34, 132, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 35, 40, 0, 8, 0, 0, 38, 172, 0, 14, 0, 0, 42, 48, 0, 4, 76, 77, 84, 0, 69, 65, 84, 0, 43, 48, 50, 51, 48, 0, 43, 48, 50, 52, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 65, 84, 45, 51, 10}, - - "zoneinfo/Africa/Asmera": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 177, 238, 218, 252, 180, 194, 154, 208, 199, 145, 71, 216, 237, 47, 225, 212, 0, 1, 2, 3, 1, 0, 0, 34, 132, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 35, 40, 0, 8, 0, 0, 38, 172, 0, 14, 0, 0, 42, 48, 0, 4, 76, 77, 84, 0, 69, 65, 84, 0, 43, 48, 50, 51, 48, 0, 43, 48, 50, 52, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 65, 84, 45, 51, 10}, - - "zoneinfo/Africa/Bamako": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 146, 230, 146, 72, 0, 1, 255, 255, 252, 56, 0, 0, 0, 0, 0, 0, 0, 4, 76, 77, 84, 0, 71, 77, 84, 0, 0, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Africa/Bangui": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 161, 81, 243, 80, 0, 1, 0, 0, 3, 48, 0, 0, 0, 0, 14, 16, 0, 4, 76, 77, 84, 0, 87, 65, 84, 0, 0, 0, 0, 0, 10, 87, 65, 84, 45, 49, 10}, - - "zoneinfo/Africa/Banjul": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 146, 230, 146, 72, 0, 1, 255, 255, 252, 56, 0, 0, 0, 0, 0, 0, 0, 4, 76, 77, 84, 0, 71, 77, 84, 0, 0, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Africa/Bissau": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 146, 230, 157, 28, 9, 103, 97, 16, 0, 1, 2, 255, 255, 241, 100, 0, 0, 255, 255, 241, 240, 0, 4, 0, 0, 0, 0, 0, 8, 76, 77, 84, 0, 45, 48, 49, 0, 71, 77, 84, 0, 0, 0, 0, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Africa/Blantyre": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 130, 70, 197, 244, 0, 1, 0, 0, 30, 140, 0, 0, 0, 0, 28, 32, 0, 4, 76, 77, 84, 0, 67, 65, 84, 0, 0, 0, 0, 0, 10, 67, 65, 84, 45, 50, 10}, - - "zoneinfo/Africa/Brazzaville": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 161, 81, 243, 80, 0, 1, 0, 0, 3, 48, 0, 0, 0, 0, 14, 16, 0, 4, 76, 77, 84, 0, 87, 65, 84, 0, 0, 0, 0, 0, 10, 87, 65, 84, 45, 49, 10}, - - "zoneinfo/Africa/Bujumbura": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 130, 70, 197, 244, 0, 1, 0, 0, 30, 140, 0, 0, 0, 0, 28, 32, 0, 4, 76, 77, 84, 0, 67, 65, 84, 0, 0, 0, 0, 0, 10, 67, 65, 84, 45, 50, 10}, - - "zoneinfo/Africa/Cairo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 127, 0, 0, 0, 4, 0, 0, 0, 13, 128, 0, 0, 0, 200, 147, 180, 224, 200, 250, 123, 208, 201, 252, 239, 224, 202, 199, 232, 208, 203, 203, 174, 96, 204, 223, 41, 208, 205, 172, 225, 224, 206, 198, 244, 208, 207, 143, 102, 224, 208, 169, 121, 208, 209, 132, 96, 224, 210, 138, 173, 80, 232, 54, 99, 96, 232, 244, 45, 80, 234, 11, 185, 96, 234, 213, 96, 208, 235, 236, 250, 240, 236, 181, 109, 0, 237, 207, 127, 240, 238, 151, 242, 0, 239, 176, 179, 112, 240, 121, 37, 128, 241, 145, 230, 240, 242, 90, 89, 0, 243, 115, 26, 112, 244, 59, 140, 128, 245, 85, 159, 112, 246, 30, 17, 128, 247, 54, 210, 240, 247, 255, 69, 0, 249, 24, 6, 112, 249, 225, 202, 0, 250, 249, 57, 240, 251, 194, 253, 128, 252, 219, 190, 240, 253, 165, 130, 128, 254, 188, 242, 112, 255, 134, 182, 0, 0, 158, 37, 240, 1, 103, 233, 128, 2, 127, 89, 112, 3, 73, 29, 0, 4, 97, 222, 112, 5, 43, 162, 0, 6, 67, 17, 240, 7, 12, 213, 128, 8, 36, 69, 112, 8, 238, 9, 0, 10, 5, 120, 240, 10, 207, 60, 128, 11, 231, 253, 240, 12, 177, 193, 128, 13, 201, 49, 112, 14, 146, 245, 0, 15, 170, 100, 240, 16, 116, 40, 128, 17, 139, 152, 112, 18, 85, 92, 0, 19, 110, 29, 112, 20, 55, 225, 0, 21, 79, 80, 240, 22, 25, 20, 128, 23, 160, 147, 240, 23, 250, 72, 0, 25, 112, 163, 240, 25, 219, 123, 128, 26, 244, 60, 240, 27, 190, 0, 128, 28, 213, 112, 112, 29, 159, 52, 0, 30, 182, 163, 240, 31, 128, 103, 128, 32, 151, 215, 112, 33, 97, 155, 0, 34, 122, 92, 112, 35, 68, 32, 0, 36, 98, 39, 112, 37, 37, 83, 128, 38, 60, 195, 112, 39, 6, 135, 0, 40, 29, 246, 240, 40, 231, 186, 128, 42, 0, 123, 240, 42, 202, 63, 128, 43, 225, 175, 112, 44, 171, 115, 0, 45, 194, 226, 240, 46, 140, 166, 128, 47, 160, 19, 224, 48, 107, 12, 208, 49, 127, 245, 224, 50, 74, 238, 208, 51, 95, 215, 224, 52, 42, 208, 208, 53, 63, 185, 224, 54, 10, 178, 208, 55, 40, 214, 96, 55, 243, 207, 80, 57, 8, 184, 96, 57, 211, 177, 80, 58, 232, 154, 96, 59, 179, 147, 80, 60, 200, 124, 96, 61, 147, 117, 80, 62, 168, 94, 96, 63, 115, 87, 80, 64, 145, 122, 224, 65, 92, 115, 208, 66, 113, 92, 224, 67, 60, 85, 208, 68, 81, 62, 224, 69, 18, 253, 80, 70, 49, 32, 224, 70, 224, 106, 80, 72, 17, 2, 224, 72, 183, 17, 208, 73, 240, 228, 224, 74, 141, 185, 80, 75, 218, 1, 96, 76, 97, 189, 208, 76, 137, 88, 224, 76, 164, 250, 80, 83, 117, 56, 224, 83, 172, 137, 208, 83, 218, 188, 96, 84, 36, 130, 80, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 1, 2, 1, 2, 1, 2, 0, 0, 29, 85, 0, 0, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 9, 0, 0, 42, 48, 1, 4, 76, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 0, 0, 0, 1, 0, 0, 0, 0, 10, 69, 69, 84, 45, 50, 10}, - - "zoneinfo/Africa/Casablanca": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 101, 0, 0, 0, 5, 0, 0, 0, 17, 128, 0, 0, 0, 150, 81, 249, 156, 198, 255, 20, 128, 199, 88, 172, 112, 199, 217, 237, 128, 210, 161, 50, 240, 219, 53, 164, 0, 219, 238, 39, 240, 251, 37, 114, 64, 251, 194, 239, 112, 8, 107, 132, 128, 8, 198, 109, 240, 11, 232, 12, 0, 12, 97, 71, 240, 13, 201, 63, 128, 14, 142, 242, 112, 15, 211, 81, 128, 16, 39, 163, 112, 26, 183, 166, 0, 30, 24, 111, 240, 72, 65, 230, 128, 72, 187, 34, 112, 74, 35, 26, 0, 74, 141, 213, 112, 75, 220, 192, 128, 76, 93, 229, 112, 77, 151, 184, 128, 78, 52, 140, 240, 79, 156, 160, 160, 80, 8, 187, 160, 80, 49, 154, 32, 80, 103, 167, 160, 81, 124, 130, 160, 81, 216, 203, 160, 82, 5, 158, 160, 82, 108, 115, 160, 83, 55, 122, 160, 83, 174, 33, 160, 83, 220, 70, 32, 84, 76, 85, 160, 85, 23, 92, 160, 85, 124, 224, 32, 85, 171, 4, 160, 86, 44, 55, 160, 86, 247, 62, 160, 87, 83, 135, 160, 87, 129, 172, 32, 88, 21, 84, 32, 88, 215, 32, 160, 89, 32, 244, 160, 89, 88, 83, 160, 89, 245, 54, 32, 90, 183, 2, 160, 90, 247, 156, 32, 91, 37, 192, 160, 91, 213, 24, 32, 92, 160, 31, 32, 92, 206, 67, 160, 92, 252, 104, 32, 93, 180, 250, 32, 94, 128, 1, 32, 94, 155, 176, 160, 94, 201, 213, 32, 95, 148, 220, 32, 96, 95, 227, 32, 96, 114, 88, 32, 96, 160, 124, 160, 97, 125, 248, 160, 98, 119, 36, 32, 99, 93, 218, 160, 100, 68, 145, 32, 101, 61, 188, 160, 102, 27, 56, 160, 103, 29, 158, 160, 103, 241, 224, 32, 104, 253, 128, 160, 105, 200, 135, 160, 106, 221, 98, 160, 107, 168, 105, 160, 108, 198, 127, 32, 109, 136, 75, 160, 110, 166, 97, 32, 111, 104, 45, 160, 112, 134, 67, 32, 113, 81, 74, 32, 114, 102, 37, 32, 115, 49, 44, 32, 116, 70, 7, 32, 117, 17, 14, 32, 118, 47, 35, 160, 118, 240, 240, 32, 120, 15, 5, 160, 120, 208, 210, 32, 121, 238, 231, 160, 122, 176, 180, 32, 123, 206, 201, 160, 124, 153, 208, 160, 125, 165, 113, 32, 126, 121, 178, 160, 127, 114, 222, 32, 127, 142, 155, 176, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 255, 255, 248, 228, 0, 0, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 9, 0, 0, 14, 16, 0, 13, 0, 0, 0, 0, 0, 9, 76, 77, 84, 0, 87, 69, 83, 84, 0, 87, 69, 84, 0, 67, 69, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 87, 69, 84, 48, 87, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Africa/Ceuta": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 127, 0, 0, 0, 7, 0, 0, 0, 22, 128, 0, 0, 0, 158, 214, 117, 112, 159, 161, 110, 96, 170, 5, 239, 112, 170, 231, 110, 0, 173, 201, 167, 240, 174, 167, 50, 0, 175, 160, 79, 112, 176, 135, 20, 0, 177, 137, 122, 0, 178, 112, 48, 128, 178, 225, 145, 128, 251, 37, 114, 64, 251, 194, 239, 112, 8, 107, 132, 128, 8, 198, 109, 240, 11, 232, 12, 0, 12, 97, 71, 240, 13, 201, 63, 128, 14, 142, 242, 112, 15, 211, 81, 128, 16, 39, 163, 112, 26, 183, 166, 0, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 2, 1, 2, 3, 2, 3, 2, 3, 2, 3, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 4, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 255, 255, 251, 4, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 14, 16, 1, 8, 0, 0, 0, 0, 0, 4, 0, 0, 14, 16, 0, 13, 0, 0, 28, 32, 1, 17, 0, 0, 14, 16, 0, 13, 76, 77, 84, 0, 87, 69, 84, 0, 87, 69, 83, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Africa/Conakry": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 146, 230, 146, 72, 0, 1, 255, 255, 252, 56, 0, 0, 0, 0, 0, 0, 0, 4, 76, 77, 84, 0, 71, 77, 84, 0, 0, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Africa/Dakar": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 146, 230, 146, 72, 0, 1, 255, 255, 252, 56, 0, 0, 0, 0, 0, 0, 0, 4, 76, 77, 84, 0, 71, 77, 84, 0, 0, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Africa/Dar_es_Salaam": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 177, 238, 218, 252, 180, 194, 154, 208, 199, 145, 71, 216, 237, 47, 225, 212, 0, 1, 2, 3, 1, 0, 0, 34, 132, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 35, 40, 0, 8, 0, 0, 38, 172, 0, 14, 0, 0, 42, 48, 0, 4, 76, 77, 84, 0, 69, 65, 84, 0, 43, 48, 50, 51, 48, 0, 43, 48, 50, 52, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 65, 84, 45, 51, 10}, - - "zoneinfo/Africa/Djibouti": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 177, 238, 218, 252, 180, 194, 154, 208, 199, 145, 71, 216, 237, 47, 225, 212, 0, 1, 2, 3, 1, 0, 0, 34, 132, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 35, 40, 0, 8, 0, 0, 38, 172, 0, 14, 0, 0, 42, 48, 0, 4, 76, 77, 84, 0, 69, 65, 84, 0, 43, 48, 50, 51, 48, 0, 43, 48, 50, 52, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 65, 84, 45, 51, 10}, - - "zoneinfo/Africa/Douala": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 161, 81, 243, 80, 0, 1, 0, 0, 3, 48, 0, 0, 0, 0, 14, 16, 0, 4, 76, 77, 84, 0, 87, 65, 84, 0, 0, 0, 0, 0, 10, 87, 65, 84, 45, 49, 10}, - - "zoneinfo/Africa/El_Aaiun": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 90, 0, 0, 0, 4, 0, 0, 0, 17, 128, 0, 0, 0, 188, 72, 240, 224, 11, 209, 176, 144, 11, 232, 12, 0, 12, 97, 71, 240, 13, 201, 63, 128, 14, 142, 242, 112, 15, 211, 81, 128, 16, 39, 163, 112, 72, 65, 230, 128, 72, 187, 34, 112, 74, 35, 26, 0, 74, 141, 213, 112, 75, 220, 192, 128, 76, 93, 229, 112, 77, 151, 184, 128, 78, 52, 140, 240, 79, 156, 160, 160, 80, 8, 187, 160, 80, 49, 154, 32, 80, 103, 167, 160, 81, 124, 130, 160, 81, 216, 203, 160, 82, 5, 158, 160, 82, 108, 115, 160, 83, 55, 122, 160, 83, 174, 33, 160, 83, 220, 70, 32, 84, 76, 85, 160, 85, 23, 92, 160, 85, 124, 224, 32, 85, 171, 4, 160, 86, 44, 55, 160, 86, 247, 62, 160, 87, 83, 135, 160, 87, 129, 172, 32, 88, 21, 84, 32, 88, 215, 32, 160, 89, 32, 244, 160, 89, 88, 83, 160, 89, 245, 54, 32, 90, 183, 2, 160, 90, 247, 156, 32, 91, 37, 192, 160, 91, 213, 24, 32, 92, 160, 31, 32, 92, 206, 67, 160, 92, 252, 104, 32, 93, 180, 250, 32, 94, 128, 1, 32, 94, 155, 176, 160, 94, 201, 213, 32, 95, 148, 220, 32, 96, 95, 227, 32, 96, 114, 88, 32, 96, 160, 124, 160, 97, 125, 248, 160, 98, 119, 36, 32, 99, 93, 218, 160, 100, 68, 145, 32, 101, 61, 188, 160, 102, 27, 56, 160, 103, 29, 158, 160, 103, 241, 224, 32, 104, 253, 128, 160, 105, 200, 135, 160, 106, 221, 98, 160, 107, 168, 105, 160, 108, 198, 127, 32, 109, 136, 75, 160, 110, 166, 97, 32, 111, 104, 45, 160, 112, 134, 67, 32, 113, 81, 74, 32, 114, 102, 37, 32, 115, 49, 44, 32, 116, 70, 7, 32, 117, 17, 14, 32, 118, 47, 35, 160, 118, 240, 240, 32, 120, 15, 5, 160, 120, 208, 210, 32, 121, 238, 231, 160, 122, 176, 180, 32, 123, 206, 201, 160, 124, 153, 208, 160, 125, 165, 113, 32, 126, 121, 178, 160, 127, 114, 222, 32, 127, 142, 155, 176, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 3, 255, 255, 243, 160, 0, 0, 255, 255, 241, 240, 0, 4, 0, 0, 14, 16, 1, 8, 0, 0, 0, 0, 0, 13, 76, 77, 84, 0, 45, 48, 49, 0, 87, 69, 83, 84, 0, 87, 69, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 87, 69, 84, 48, 87, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Africa/Freetown": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 146, 230, 146, 72, 0, 1, 255, 255, 252, 56, 0, 0, 0, 0, 0, 0, 0, 4, 76, 77, 84, 0, 71, 77, 84, 0, 0, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Africa/Gaborone": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 130, 70, 197, 244, 0, 1, 0, 0, 30, 140, 0, 0, 0, 0, 28, 32, 0, 4, 76, 77, 84, 0, 67, 65, 84, 0, 0, 0, 0, 0, 10, 67, 65, 84, 45, 50, 10}, - - "zoneinfo/Africa/Harare": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 130, 70, 197, 244, 0, 1, 0, 0, 30, 140, 0, 0, 0, 0, 28, 32, 0, 4, 76, 77, 84, 0, 67, 65, 84, 0, 0, 0, 0, 0, 10, 67, 65, 84, 45, 50, 10}, - - "zoneinfo/Africa/Johannesburg": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 9, 128, 0, 0, 0, 130, 70, 207, 104, 204, 174, 140, 128, 205, 158, 111, 112, 206, 142, 110, 128, 207, 126, 81, 112, 1, 3, 2, 3, 2, 3, 0, 0, 26, 64, 0, 0, 0, 0, 21, 24, 0, 4, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 4, 76, 77, 84, 0, 83, 65, 83, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 83, 65, 83, 84, 45, 50, 10}, - - "zoneinfo/Africa/Juba": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 35, 0, 0, 0, 4, 0, 0, 0, 17, 128, 0, 0, 0, 182, 163, 218, 220, 0, 158, 23, 224, 1, 122, 52, 80, 2, 125, 249, 224, 3, 91, 103, 208, 4, 96, 126, 224, 5, 61, 236, 208, 6, 64, 96, 224, 7, 31, 32, 80, 8, 32, 66, 224, 9, 0, 83, 208, 10, 0, 36, 224, 10, 225, 135, 80, 11, 224, 6, 224, 12, 196, 12, 80, 13, 191, 232, 224, 14, 165, 63, 208, 15, 169, 5, 96, 16, 134, 115, 80, 17, 136, 231, 96, 18, 103, 166, 208, 19, 104, 201, 96, 20, 74, 43, 208, 21, 72, 171, 96, 22, 43, 95, 80, 23, 40, 141, 96, 24, 12, 146, 208, 25, 8, 111, 96, 25, 237, 198, 80, 26, 241, 139, 224, 27, 208, 75, 80, 28, 209, 109, 224, 29, 177, 126, 208, 56, 128, 69, 32, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 0, 0, 29, 164, 0, 0, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 9, 0, 0, 42, 48, 0, 13, 76, 77, 84, 0, 67, 65, 83, 84, 0, 67, 65, 84, 0, 69, 65, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 65, 84, 45, 51, 10}, - - "zoneinfo/Africa/Kampala": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 177, 238, 218, 252, 180, 194, 154, 208, 199, 145, 71, 216, 237, 47, 225, 212, 0, 1, 2, 3, 1, 0, 0, 34, 132, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 35, 40, 0, 8, 0, 0, 38, 172, 0, 14, 0, 0, 42, 48, 0, 4, 76, 77, 84, 0, 69, 65, 84, 0, 43, 48, 50, 51, 48, 0, 43, 48, 50, 52, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 65, 84, 45, 51, 10}, - - "zoneinfo/Africa/Khartoum": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 36, 0, 0, 0, 5, 0, 0, 0, 17, 128, 0, 0, 0, 182, 163, 218, 0, 0, 158, 23, 224, 1, 122, 52, 80, 2, 125, 249, 224, 3, 91, 103, 208, 4, 96, 126, 224, 5, 61, 236, 208, 6, 64, 96, 224, 7, 31, 32, 80, 8, 32, 66, 224, 9, 0, 83, 208, 10, 0, 36, 224, 10, 225, 135, 80, 11, 224, 6, 224, 12, 196, 12, 80, 13, 191, 232, 224, 14, 165, 63, 208, 15, 169, 5, 96, 16, 134, 115, 80, 17, 136, 231, 96, 18, 103, 166, 208, 19, 104, 201, 96, 20, 74, 43, 208, 21, 72, 171, 96, 22, 43, 95, 80, 23, 40, 141, 96, 24, 12, 146, 208, 25, 8, 111, 96, 25, 237, 198, 80, 26, 241, 139, 224, 27, 208, 75, 80, 28, 209, 109, 224, 29, 177, 126, 208, 56, 128, 69, 32, 89, 248, 228, 80, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 0, 0, 30, 128, 0, 0, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 9, 0, 0, 42, 48, 0, 13, 0, 0, 28, 32, 0, 9, 76, 77, 84, 0, 67, 65, 83, 84, 0, 67, 65, 84, 0, 69, 65, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 67, 65, 84, 45, 50, 10}, - - "zoneinfo/Africa/Kigali": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 130, 70, 197, 244, 0, 1, 0, 0, 30, 140, 0, 0, 0, 0, 28, 32, 0, 4, 76, 77, 84, 0, 67, 65, 84, 0, 0, 0, 0, 0, 10, 67, 65, 84, 45, 50, 10}, - - "zoneinfo/Africa/Kinshasa": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 161, 81, 243, 80, 0, 1, 0, 0, 3, 48, 0, 0, 0, 0, 14, 16, 0, 4, 76, 77, 84, 0, 87, 65, 84, 0, 0, 0, 0, 0, 10, 87, 65, 84, 45, 49, 10}, - - "zoneinfo/Africa/Lagos": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 161, 81, 243, 80, 0, 1, 0, 0, 3, 48, 0, 0, 0, 0, 14, 16, 0, 4, 76, 77, 84, 0, 87, 65, 84, 0, 0, 0, 0, 0, 10, 87, 65, 84, 45, 49, 10}, - - "zoneinfo/Africa/Libreville": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 161, 81, 243, 80, 0, 1, 0, 0, 3, 48, 0, 0, 0, 0, 14, 16, 0, 4, 76, 77, 84, 0, 87, 65, 84, 0, 0, 0, 0, 0, 10, 87, 65, 84, 45, 49, 10}, - - "zoneinfo/Africa/Lome": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 146, 230, 146, 72, 0, 1, 255, 255, 252, 56, 0, 0, 0, 0, 0, 0, 0, 4, 76, 77, 84, 0, 71, 77, 84, 0, 0, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Africa/Luanda": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 161, 81, 243, 80, 0, 1, 0, 0, 3, 48, 0, 0, 0, 0, 14, 16, 0, 4, 76, 77, 84, 0, 87, 65, 84, 0, 0, 0, 0, 0, 10, 87, 65, 84, 45, 49, 10}, - - "zoneinfo/Africa/Lubumbashi": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 130, 70, 197, 244, 0, 1, 0, 0, 30, 140, 0, 0, 0, 0, 28, 32, 0, 4, 76, 77, 84, 0, 67, 65, 84, 0, 0, 0, 0, 0, 10, 67, 65, 84, 45, 50, 10}, - - "zoneinfo/Africa/Lusaka": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 130, 70, 197, 244, 0, 1, 0, 0, 30, 140, 0, 0, 0, 0, 28, 32, 0, 4, 76, 77, 84, 0, 67, 65, 84, 0, 0, 0, 0, 0, 10, 67, 65, 84, 45, 50, 10}, - - "zoneinfo/Africa/Malabo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 161, 81, 243, 80, 0, 1, 0, 0, 3, 48, 0, 0, 0, 0, 14, 16, 0, 4, 76, 77, 84, 0, 87, 65, 84, 0, 0, 0, 0, 0, 10, 87, 65, 84, 45, 49, 10}, - - "zoneinfo/Africa/Maputo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 130, 70, 197, 244, 0, 1, 0, 0, 30, 140, 0, 0, 0, 0, 28, 32, 0, 4, 76, 77, 84, 0, 67, 65, 84, 0, 0, 0, 0, 0, 10, 67, 65, 84, 45, 50, 10}, - - "zoneinfo/Africa/Maseru": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 9, 128, 0, 0, 0, 130, 70, 207, 104, 204, 174, 140, 128, 205, 158, 111, 112, 206, 142, 110, 128, 207, 126, 81, 112, 1, 3, 2, 3, 2, 3, 0, 0, 26, 64, 0, 0, 0, 0, 21, 24, 0, 4, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 4, 76, 77, 84, 0, 83, 65, 83, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 83, 65, 83, 84, 45, 50, 10}, - - "zoneinfo/Africa/Mbabane": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 9, 128, 0, 0, 0, 130, 70, 207, 104, 204, 174, 140, 128, 205, 158, 111, 112, 206, 142, 110, 128, 207, 126, 81, 112, 1, 3, 2, 3, 2, 3, 0, 0, 26, 64, 0, 0, 0, 0, 21, 24, 0, 4, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 4, 76, 77, 84, 0, 83, 65, 83, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 83, 65, 83, 84, 45, 50, 10}, - - "zoneinfo/Africa/Mogadishu": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 177, 238, 218, 252, 180, 194, 154, 208, 199, 145, 71, 216, 237, 47, 225, 212, 0, 1, 2, 3, 1, 0, 0, 34, 132, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 35, 40, 0, 8, 0, 0, 38, 172, 0, 14, 0, 0, 42, 48, 0, 4, 76, 77, 84, 0, 69, 65, 84, 0, 43, 48, 50, 51, 48, 0, 43, 48, 50, 52, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 65, 84, 45, 51, 10}, - - "zoneinfo/Africa/Monrovia": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 12, 128, 0, 0, 0, 160, 95, 108, 156, 3, 202, 90, 110, 1, 2, 3, 255, 255, 245, 228, 0, 0, 255, 255, 245, 228, 0, 4, 255, 255, 245, 146, 0, 4, 0, 0, 0, 0, 0, 8, 76, 77, 84, 0, 77, 77, 84, 0, 71, 77, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Africa/Nairobi": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 177, 238, 218, 252, 180, 194, 154, 208, 199, 145, 71, 216, 237, 47, 225, 212, 0, 1, 2, 3, 1, 0, 0, 34, 132, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 35, 40, 0, 8, 0, 0, 38, 172, 0, 14, 0, 0, 42, 48, 0, 4, 76, 77, 84, 0, 69, 65, 84, 0, 43, 48, 50, 51, 48, 0, 43, 48, 50, 52, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 65, 84, 45, 51, 10}, - - "zoneinfo/Africa/Ndjamena": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 3, 0, 0, 0, 13, 128, 0, 0, 0, 146, 230, 128, 100, 18, 102, 113, 112, 19, 38, 222, 96, 0, 1, 2, 1, 0, 0, 14, 28, 0, 0, 0, 0, 14, 16, 0, 4, 0, 0, 28, 32, 1, 8, 76, 77, 84, 0, 87, 65, 84, 0, 87, 65, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 87, 65, 84, 45, 49, 10}, - - "zoneinfo/Africa/Niamey": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 161, 81, 243, 80, 0, 1, 0, 0, 3, 48, 0, 0, 0, 0, 14, 16, 0, 4, 76, 77, 84, 0, 87, 65, 84, 0, 0, 0, 0, 0, 10, 87, 65, 84, 45, 49, 10}, - - "zoneinfo/Africa/Nouakchott": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 146, 230, 146, 72, 0, 1, 255, 255, 252, 56, 0, 0, 0, 0, 0, 0, 0, 4, 76, 77, 84, 0, 71, 77, 84, 0, 0, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Africa/Ouagadougou": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 146, 230, 146, 72, 0, 1, 255, 255, 252, 56, 0, 0, 0, 0, 0, 0, 0, 4, 76, 77, 84, 0, 71, 77, 84, 0, 0, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Africa/Porto-Novo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 161, 81, 243, 80, 0, 1, 0, 0, 3, 48, 0, 0, 0, 0, 14, 16, 0, 4, 76, 77, 84, 0, 87, 65, 84, 0, 0, 0, 0, 0, 10, 87, 65, 84, 45, 49, 10}, - - "zoneinfo/Africa/Sao_Tome": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 146, 230, 146, 72, 0, 1, 255, 255, 252, 56, 0, 0, 0, 0, 0, 0, 0, 4, 76, 77, 84, 0, 71, 77, 84, 0, 0, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Africa/Timbuktu": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 146, 230, 146, 72, 0, 1, 255, 255, 252, 56, 0, 0, 0, 0, 0, 0, 0, 4, 76, 77, 84, 0, 71, 77, 84, 0, 0, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Africa/Tripoli": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, 4, 0, 0, 0, 17, 128, 0, 0, 0, 161, 242, 193, 36, 221, 187, 177, 16, 222, 35, 173, 96, 225, 120, 210, 16, 225, 231, 101, 224, 229, 47, 63, 112, 229, 169, 204, 224, 235, 78, 198, 240, 22, 146, 66, 96, 23, 8, 247, 112, 23, 250, 43, 224, 24, 234, 42, 240, 25, 219, 95, 96, 26, 204, 175, 240, 27, 189, 228, 96, 28, 180, 122, 240, 29, 159, 23, 224, 30, 147, 11, 112, 31, 130, 238, 96, 32, 112, 74, 112, 33, 97, 126, 224, 34, 82, 207, 112, 35, 68, 3, 224, 36, 52, 2, 240, 37, 37, 55, 96, 38, 64, 183, 240, 50, 78, 241, 96, 51, 68, 54, 112, 52, 53, 106, 224, 80, 157, 153, 0, 81, 84, 217, 128, 82, 105, 180, 128, 0, 2, 1, 2, 1, 2, 1, 2, 3, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 1, 3, 2, 1, 3, 0, 0, 12, 92, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 0, 13, 76, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 69, 69, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 69, 84, 45, 50, 10}, - - "zoneinfo/Africa/Tunis": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 34, 0, 0, 0, 6, 0, 0, 0, 17, 128, 0, 0, 0, 145, 96, 80, 79, 198, 58, 136, 224, 199, 88, 158, 96, 199, 219, 34, 224, 202, 226, 84, 224, 203, 173, 105, 240, 204, 231, 75, 16, 205, 169, 23, 144, 205, 194, 22, 0, 205, 204, 176, 16, 206, 162, 53, 0, 207, 146, 52, 16, 208, 137, 227, 224, 209, 114, 22, 16, 210, 78, 22, 96, 13, 199, 223, 240, 14, 137, 172, 112, 15, 170, 100, 240, 16, 116, 26, 112, 34, 163, 58, 240, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 10, 240, 38, 60, 195, 112, 39, 5, 39, 112, 66, 116, 13, 240, 67, 60, 128, 0, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 1, 4, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 0, 0, 9, 140, 0, 0, 0, 0, 2, 49, 0, 4, 0, 0, 28, 32, 1, 8, 0, 0, 14, 16, 0, 13, 0, 0, 14, 16, 0, 13, 0, 0, 28, 32, 1, 8, 76, 77, 84, 0, 80, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 10, 67, 69, 84, 45, 49, 10}, - - "zoneinfo/Africa/Windhoek": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 53, 0, 0, 0, 8, 0, 0, 0, 28, 128, 0, 0, 0, 130, 70, 207, 104, 204, 174, 140, 128, 205, 158, 111, 112, 38, 6, 167, 224, 45, 140, 199, 96, 46, 105, 28, 16, 47, 125, 233, 0, 48, 72, 254, 16, 49, 103, 5, 128, 50, 40, 224, 16, 51, 70, 231, 128, 52, 17, 252, 144, 53, 38, 201, 128, 53, 241, 222, 144, 55, 6, 171, 128, 55, 209, 192, 144, 56, 230, 141, 128, 57, 177, 162, 144, 58, 198, 111, 128, 59, 145, 132, 144, 60, 175, 140, 0, 61, 113, 102, 144, 62, 143, 110, 0, 63, 90, 131, 16, 64, 111, 80, 0, 65, 58, 101, 16, 66, 79, 50, 0, 67, 26, 71, 16, 68, 47, 20, 0, 68, 250, 41, 16, 70, 14, 246, 0, 70, 218, 11, 16, 71, 248, 18, 128, 72, 195, 39, 144, 73, 215, 244, 128, 74, 163, 9, 144, 75, 183, 214, 128, 76, 130, 235, 144, 77, 151, 184, 128, 78, 98, 205, 144, 79, 119, 154, 128, 80, 66, 175, 144, 81, 96, 183, 0, 82, 34, 145, 144, 83, 64, 153, 0, 84, 11, 174, 16, 85, 32, 123, 0, 85, 235, 144, 16, 87, 0, 93, 0, 87, 203, 114, 16, 88, 224, 63, 0, 89, 171, 84, 16, 1, 2, 3, 2, 4, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 4, 0, 0, 16, 8, 0, 0, 0, 0, 21, 24, 0, 4, 0, 0, 28, 32, 0, 10, 0, 0, 42, 48, 1, 10, 0, 0, 28, 32, 0, 15, 0, 0, 14, 16, 0, 19, 0, 0, 28, 32, 1, 23, 0, 0, 28, 32, 0, 15, 76, 77, 84, 0, 43, 48, 49, 51, 48, 0, 83, 65, 83, 84, 0, 67, 65, 84, 0, 87, 65, 84, 0, 87, 65, 83, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 67, 65, 84, 45, 50, 10}, - - "zoneinfo/America/Adak": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 144, 0, 0, 0, 9, 0, 0, 0, 33, 128, 0, 0, 0, 203, 137, 68, 208, 210, 35, 244, 112, 210, 97, 80, 64, 250, 210, 85, 176, 254, 184, 113, 80, 255, 168, 84, 64, 0, 152, 83, 80, 1, 136, 54, 64, 2, 120, 53, 80, 3, 113, 82, 192, 4, 97, 81, 208, 5, 81, 52, 192, 6, 65, 51, 208, 7, 49, 22, 192, 7, 141, 109, 208, 9, 16, 248, 192, 9, 173, 233, 80, 10, 240, 218, 192, 11, 224, 217, 208, 12, 217, 247, 64, 13, 192, 187, 208, 14, 185, 217, 64, 15, 169, 216, 80, 16, 153, 187, 64, 17, 137, 186, 80, 18, 121, 157, 64, 19, 105, 156, 80, 20, 89, 127, 64, 21, 73, 126, 80, 22, 57, 97, 64, 23, 41, 96, 80, 24, 34, 125, 192, 25, 9, 66, 80, 26, 2, 95, 192, 26, 43, 34, 32, 26, 242, 80, 192, 27, 226, 51, 176, 28, 210, 50, 192, 29, 194, 21, 176, 30, 178, 20, 192, 31, 161, 247, 176, 32, 118, 71, 64, 33, 129, 217, 176, 34, 86, 41, 64, 35, 106, 246, 48, 36, 54, 11, 64, 37, 74, 216, 48, 38, 21, 237, 64, 39, 42, 186, 48, 39, 255, 9, 192, 41, 10, 156, 48, 41, 222, 235, 192, 42, 234, 126, 48, 43, 190, 205, 192, 44, 211, 154, 176, 45, 158, 175, 192, 46, 179, 124, 176, 47, 126, 145, 192, 48, 147, 94, 176, 49, 103, 174, 64, 50, 115, 64, 176, 51, 71, 144, 64, 52, 83, 34, 176, 53, 39, 114, 64, 54, 51, 4, 176, 55, 7, 84, 64, 56, 28, 33, 48, 56, 231, 54, 64, 57, 252, 3, 48, 58, 199, 24, 64, 59, 219, 229, 48, 60, 176, 52, 192, 61, 187, 199, 48, 62, 144, 22, 192, 63, 155, 169, 48, 64, 111, 248, 192, 65, 132, 197, 176, 66, 79, 218, 192, 67, 100, 167, 176, 68, 47, 188, 192, 69, 68, 137, 176, 69, 243, 239, 64, 71, 45, 166, 48, 71, 211, 209, 64, 73, 13, 136, 48, 73, 179, 179, 64, 74, 237, 106, 48, 75, 156, 207, 192, 76, 214, 134, 176, 77, 124, 177, 192, 78, 182, 104, 176, 79, 92, 147, 192, 80, 150, 74, 176, 81, 60, 117, 192, 82, 118, 44, 176, 83, 28, 87, 192, 84, 86, 14, 176, 84, 252, 57, 192, 86, 53, 240, 176, 86, 229, 86, 64, 88, 31, 13, 48, 88, 197, 56, 64, 89, 254, 239, 48, 90, 165, 26, 64, 91, 222, 209, 48, 92, 132, 252, 64, 93, 190, 179, 48, 94, 100, 222, 64, 95, 158, 149, 48, 96, 77, 250, 192, 97, 135, 177, 176, 98, 45, 220, 192, 99, 103, 147, 176, 100, 13, 190, 192, 101, 71, 117, 176, 101, 237, 160, 192, 103, 39, 87, 176, 103, 205, 130, 192, 105, 7, 57, 176, 105, 173, 100, 192, 106, 231, 27, 176, 107, 150, 129, 64, 108, 208, 56, 48, 109, 118, 99, 64, 110, 176, 26, 48, 111, 86, 69, 64, 112, 143, 252, 48, 113, 54, 39, 64, 114, 111, 222, 48, 115, 22, 9, 64, 116, 79, 192, 48, 116, 255, 37, 192, 118, 56, 220, 176, 118, 223, 7, 192, 120, 24, 190, 176, 120, 190, 233, 192, 121, 248, 160, 176, 122, 158, 203, 192, 123, 216, 130, 176, 124, 126, 173, 192, 125, 184, 100, 176, 126, 94, 143, 192, 127, 152, 70, 176, 1, 2, 3, 1, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 6, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 255, 255, 90, 98, 0, 0, 255, 255, 101, 80, 0, 4, 255, 255, 115, 96, 1, 8, 255, 255, 115, 96, 1, 12, 255, 255, 101, 80, 0, 16, 255, 255, 115, 96, 1, 20, 255, 255, 115, 96, 0, 24, 255, 255, 129, 112, 1, 29, 255, 255, 115, 96, 0, 25, 76, 77, 84, 0, 78, 83, 84, 0, 78, 87, 84, 0, 78, 80, 84, 0, 66, 83, 84, 0, 66, 68, 84, 0, 65, 72, 83, 84, 0, 72, 68, 84, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 10, 72, 83, 84, 49, 48, 72, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Anchorage": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 144, 0, 0, 0, 9, 0, 0, 0, 40, 128, 0, 0, 0, 203, 137, 54, 192, 210, 35, 244, 112, 210, 97, 66, 48, 250, 210, 71, 160, 254, 184, 99, 64, 255, 168, 70, 48, 0, 152, 69, 64, 1, 136, 40, 48, 2, 120, 39, 64, 3, 113, 68, 176, 4, 97, 67, 192, 5, 81, 38, 176, 6, 65, 37, 192, 7, 49, 8, 176, 7, 141, 95, 192, 9, 16, 234, 176, 9, 173, 219, 64, 10, 240, 204, 176, 11, 224, 203, 192, 12, 217, 233, 48, 13, 192, 173, 192, 14, 185, 203, 48, 15, 169, 202, 64, 16, 153, 173, 48, 17, 137, 172, 64, 18, 121, 143, 48, 19, 105, 142, 64, 20, 89, 113, 48, 21, 73, 112, 64, 22, 57, 83, 48, 23, 41, 82, 64, 24, 34, 111, 176, 25, 9, 52, 64, 26, 2, 81, 176, 26, 43, 20, 16, 26, 242, 66, 176, 27, 226, 37, 160, 28, 210, 36, 176, 29, 194, 7, 160, 30, 178, 6, 176, 31, 161, 233, 160, 32, 118, 57, 48, 33, 129, 203, 160, 34, 86, 27, 48, 35, 106, 232, 32, 36, 53, 253, 48, 37, 74, 202, 32, 38, 21, 223, 48, 39, 42, 172, 32, 39, 254, 251, 176, 41, 10, 142, 32, 41, 222, 221, 176, 42, 234, 112, 32, 43, 190, 191, 176, 44, 211, 140, 160, 45, 158, 161, 176, 46, 179, 110, 160, 47, 126, 131, 176, 48, 147, 80, 160, 49, 103, 160, 48, 50, 115, 50, 160, 51, 71, 130, 48, 52, 83, 20, 160, 53, 39, 100, 48, 54, 50, 246, 160, 55, 7, 70, 48, 56, 28, 19, 32, 56, 231, 40, 48, 57, 251, 245, 32, 58, 199, 10, 48, 59, 219, 215, 32, 60, 176, 38, 176, 61, 187, 185, 32, 62, 144, 8, 176, 63, 155, 155, 32, 64, 111, 234, 176, 65, 132, 183, 160, 66, 79, 204, 176, 67, 100, 153, 160, 68, 47, 174, 176, 69, 68, 123, 160, 69, 243, 225, 48, 71, 45, 152, 32, 71, 211, 195, 48, 73, 13, 122, 32, 73, 179, 165, 48, 74, 237, 92, 32, 75, 156, 193, 176, 76, 214, 120, 160, 77, 124, 163, 176, 78, 182, 90, 160, 79, 92, 133, 176, 80, 150, 60, 160, 81, 60, 103, 176, 82, 118, 30, 160, 83, 28, 73, 176, 84, 86, 0, 160, 84, 252, 43, 176, 86, 53, 226, 160, 86, 229, 72, 48, 88, 30, 255, 32, 88, 197, 42, 48, 89, 254, 225, 32, 90, 165, 12, 48, 91, 222, 195, 32, 92, 132, 238, 48, 93, 190, 165, 32, 94, 100, 208, 48, 95, 158, 135, 32, 96, 77, 236, 176, 97, 135, 163, 160, 98, 45, 206, 176, 99, 103, 133, 160, 100, 13, 176, 176, 101, 71, 103, 160, 101, 237, 146, 176, 103, 39, 73, 160, 103, 205, 116, 176, 105, 7, 43, 160, 105, 173, 86, 176, 106, 231, 13, 160, 107, 150, 115, 48, 108, 208, 42, 32, 109, 118, 85, 48, 110, 176, 12, 32, 111, 86, 55, 48, 112, 143, 238, 32, 113, 54, 25, 48, 114, 111, 208, 32, 115, 21, 251, 48, 116, 79, 178, 32, 116, 255, 23, 176, 118, 56, 206, 160, 118, 222, 249, 176, 120, 24, 176, 160, 120, 190, 219, 176, 121, 248, 146, 160, 122, 158, 189, 176, 123, 216, 116, 160, 124, 126, 159, 176, 125, 184, 86, 160, 126, 94, 129, 176, 127, 152, 56, 160, 1, 2, 3, 1, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 6, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 255, 255, 115, 120, 0, 0, 255, 255, 115, 96, 0, 4, 255, 255, 129, 112, 1, 8, 255, 255, 129, 112, 1, 12, 255, 255, 115, 96, 0, 16, 255, 255, 129, 112, 1, 21, 255, 255, 129, 112, 0, 26, 255, 255, 143, 128, 1, 30, 255, 255, 129, 112, 0, 35, 76, 77, 84, 0, 65, 83, 84, 0, 65, 87, 84, 0, 65, 80, 84, 0, 65, 72, 83, 84, 0, 65, 72, 68, 84, 0, 89, 83, 84, 0, 65, 75, 68, 84, 0, 65, 75, 83, 84, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 10, 65, 75, 83, 84, 57, 65, 75, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Anguilla": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 147, 55, 51, 172, 0, 1, 255, 255, 198, 84, 0, 0, 255, 255, 199, 192, 0, 4, 76, 77, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Antigua": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 147, 55, 51, 172, 0, 1, 255, 255, 198, 84, 0, 0, 255, 255, 199, 192, 0, 4, 76, 77, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Araguaina": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 53, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 116, 48, 184, 15, 73, 224, 184, 253, 64, 160, 185, 241, 52, 48, 186, 222, 116, 32, 218, 56, 174, 48, 218, 235, 250, 48, 220, 25, 225, 176, 220, 185, 89, 32, 221, 251, 21, 48, 222, 155, 222, 32, 223, 221, 154, 48, 224, 84, 51, 32, 244, 151, 255, 176, 245, 5, 94, 32, 246, 192, 100, 48, 247, 14, 30, 160, 248, 81, 44, 48, 248, 199, 197, 32, 250, 10, 210, 176, 250, 168, 248, 160, 251, 236, 6, 48, 252, 139, 125, 160, 29, 201, 142, 48, 30, 120, 215, 160, 31, 160, 53, 176, 32, 51, 207, 160, 33, 129, 105, 48, 34, 11, 200, 160, 35, 88, 16, 176, 35, 226, 112, 32, 37, 55, 242, 176, 37, 212, 199, 32, 48, 128, 121, 48, 49, 29, 77, 160, 50, 87, 32, 176, 51, 6, 106, 32, 52, 56, 84, 48, 52, 248, 193, 32, 54, 32, 31, 48, 54, 207, 104, 160, 55, 246, 198, 176, 56, 184, 133, 32, 57, 223, 227, 48, 58, 143, 44, 160, 59, 200, 255, 176, 60, 111, 14, 160, 61, 196, 145, 48, 62, 78, 240, 160, 80, 131, 101, 48, 81, 32, 57, 160, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 255, 255, 210, 208, 0, 0, 255, 255, 227, 224, 1, 4, 255, 255, 213, 208, 0, 8, 76, 77, 84, 0, 45, 48, 50, 0, 45, 48, 51, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Argentina/Buenos_Aires": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 33, 15, 48, 39, 208, 88, 160, 41, 0, 241, 48, 41, 176, 58, 160, 42, 224, 211, 48, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 71, 119, 9, 176, 71, 220, 127, 32, 72, 250, 162, 176, 73, 188, 97, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 3, 5, 4, 5, 4, 5, 5, 255, 255, 201, 52, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Argentina/Catamarca": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 33, 15, 48, 39, 208, 88, 160, 41, 0, 255, 64, 41, 176, 58, 160, 42, 224, 211, 48, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 64, 187, 241, 48, 64, 213, 11, 192, 71, 119, 9, 176, 71, 220, 127, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 5, 4, 2, 4, 5, 4, 5, 3, 5, 2, 5, 4, 5, 5, 255, 255, 194, 84, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Argentina/ComodRivadavia": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 33, 15, 48, 39, 208, 88, 160, 41, 0, 255, 64, 41, 176, 58, 160, 42, 224, 211, 48, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 64, 187, 241, 48, 64, 213, 11, 192, 71, 119, 9, 176, 71, 220, 127, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 5, 4, 2, 4, 5, 4, 5, 3, 5, 2, 5, 4, 5, 5, 255, 255, 194, 84, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Argentina/Cordoba": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 33, 15, 48, 39, 208, 88, 160, 41, 0, 255, 64, 41, 176, 58, 160, 42, 224, 211, 48, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 71, 119, 9, 176, 71, 220, 127, 32, 72, 250, 162, 176, 73, 188, 97, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 5, 4, 2, 4, 5, 4, 5, 3, 5, 4, 5, 4, 5, 5, 255, 255, 195, 208, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Argentina/Jujuy": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 60, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 42, 87, 192, 39, 226, 219, 176, 40, 238, 138, 64, 41, 176, 58, 160, 42, 224, 211, 48, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 71, 119, 9, 176, 71, 220, 127, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 2, 3, 2, 4, 5, 4, 5, 3, 5, 4, 5, 5, 255, 255, 194, 200, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Argentina/La_Rioja": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 63, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 33, 15, 48, 39, 205, 181, 160, 40, 38, 38, 64, 41, 0, 241, 48, 41, 176, 58, 160, 42, 224, 211, 48, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 64, 187, 241, 48, 64, 213, 11, 192, 71, 119, 9, 176, 71, 220, 127, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 5, 4, 2, 5, 4, 5, 4, 5, 3, 5, 2, 5, 4, 5, 5, 255, 255, 193, 84, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Argentina/Mendoza": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 25, 52, 64, 39, 205, 195, 176, 40, 250, 103, 192, 41, 176, 72, 176, 42, 224, 225, 64, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 64, 176, 19, 176, 65, 86, 62, 192, 71, 119, 9, 176, 71, 220, 127, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 2, 3, 2, 3, 2, 4, 5, 3, 5, 2, 5, 4, 5, 5, 255, 255, 191, 124, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Argentina/Rio_Gallegos": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 33, 15, 48, 39, 208, 88, 160, 41, 0, 241, 48, 41, 176, 58, 160, 42, 224, 211, 48, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 64, 187, 241, 48, 64, 213, 11, 192, 71, 119, 9, 176, 71, 220, 127, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 3, 5, 2, 5, 4, 5, 5, 255, 255, 191, 28, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Argentina/Salta": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 60, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 33, 15, 48, 39, 208, 88, 160, 41, 0, 255, 64, 41, 176, 58, 160, 42, 224, 211, 48, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 71, 119, 9, 176, 71, 220, 127, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 5, 4, 2, 4, 5, 4, 5, 3, 5, 4, 5, 5, 255, 255, 194, 172, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Argentina/San_Juan": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 63, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 33, 15, 48, 39, 205, 181, 160, 40, 38, 38, 64, 41, 0, 241, 48, 41, 176, 58, 160, 42, 224, 211, 48, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 64, 186, 159, 176, 65, 3, 48, 64, 71, 119, 9, 176, 71, 220, 127, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 5, 4, 2, 5, 4, 5, 4, 5, 3, 5, 2, 5, 4, 5, 5, 255, 255, 191, 196, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Argentina/San_Luis": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 63, 0, 0, 0, 7, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 253, 165, 160, 39, 25, 52, 64, 39, 205, 195, 176, 40, 71, 27, 192, 55, 246, 198, 176, 56, 191, 42, 176, 64, 186, 159, 176, 65, 3, 48, 64, 71, 119, 9, 176, 71, 147, 252, 160, 71, 211, 82, 176, 72, 241, 118, 64, 73, 179, 52, 176, 74, 209, 88, 64, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 2, 3, 2, 5, 3, 5, 2, 5, 4, 3, 2, 3, 2, 5, 5, 255, 255, 193, 204, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 255, 255, 213, 208, 1, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Argentina/Tucuman": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 64, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 33, 15, 48, 39, 208, 88, 160, 41, 0, 255, 64, 41, 176, 58, 160, 42, 224, 211, 48, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 64, 187, 241, 48, 64, 203, 209, 64, 71, 119, 9, 176, 71, 220, 127, 32, 72, 250, 162, 176, 73, 188, 97, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 5, 4, 2, 4, 5, 4, 5, 3, 5, 2, 5, 4, 5, 4, 5, 5, 255, 255, 194, 220, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Argentina/Ushuaia": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 33, 15, 48, 39, 208, 88, 160, 41, 0, 241, 48, 41, 176, 58, 160, 42, 224, 211, 48, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 64, 185, 78, 48, 64, 213, 11, 192, 71, 119, 9, 176, 71, 220, 127, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 3, 5, 2, 5, 4, 5, 5, 255, 255, 191, 248, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Aruba": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 14, 128, 0, 0, 0, 147, 30, 46, 35, 246, 152, 236, 72, 0, 1, 2, 255, 255, 191, 93, 0, 0, 255, 255, 192, 184, 0, 4, 255, 255, 199, 192, 0, 10, 76, 77, 84, 0, 45, 48, 52, 51, 48, 0, 65, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Asuncion": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 130, 0, 0, 0, 6, 0, 0, 0, 16, 128, 0, 0, 0, 184, 23, 245, 144, 5, 43, 218, 64, 7, 252, 240, 176, 10, 207, 116, 192, 11, 151, 202, 176, 12, 177, 249, 192, 13, 120, 254, 48, 14, 147, 45, 64, 15, 90, 49, 176, 16, 116, 96, 192, 17, 100, 67, 176, 18, 85, 148, 64, 19, 70, 200, 176, 20, 56, 25, 64, 21, 39, 252, 48, 22, 25, 76, 192, 23, 9, 47, 176, 23, 250, 128, 64, 24, 234, 99, 48, 25, 219, 179, 192, 26, 204, 232, 48, 27, 190, 56, 192, 28, 174, 27, 176, 29, 159, 108, 64, 30, 143, 79, 48, 31, 128, 159, 192, 32, 112, 130, 176, 33, 97, 211, 64, 34, 83, 7, 176, 35, 68, 88, 64, 36, 52, 59, 48, 37, 65, 59, 64, 38, 21, 110, 176, 39, 6, 191, 64, 39, 246, 162, 48, 40, 238, 138, 64, 41, 176, 72, 176, 42, 207, 189, 192, 43, 185, 9, 48, 44, 171, 171, 64, 45, 112, 12, 176, 46, 140, 222, 192, 47, 79, 238, 176, 48, 110, 18, 64, 49, 54, 104, 48, 50, 87, 46, 192, 51, 15, 178, 176, 52, 55, 16, 192, 52, 248, 207, 48, 54, 22, 242, 192, 54, 225, 235, 176, 55, 246, 212, 192, 56, 193, 205, 176, 57, 214, 182, 192, 58, 161, 175, 176, 59, 191, 211, 64, 60, 175, 182, 48, 61, 113, 144, 192, 62, 143, 152, 48, 63, 90, 173, 64, 64, 111, 122, 48, 65, 113, 238, 64, 66, 51, 172, 176, 67, 81, 208, 64, 68, 19, 142, 176, 69, 49, 178, 64, 69, 243, 112, 176, 71, 26, 206, 192, 71, 211, 82, 176, 72, 250, 176, 192, 73, 179, 52, 176, 74, 218, 146, 192, 75, 193, 59, 48, 76, 167, 255, 192, 77, 161, 29, 48, 78, 135, 225, 192, 79, 128, 255, 48, 80, 112, 254, 64, 81, 78, 108, 48, 82, 80, 224, 64, 83, 46, 78, 48, 84, 48, 194, 64, 85, 14, 48, 48, 86, 16, 164, 64, 86, 247, 76, 176, 87, 240, 134, 64, 88, 215, 46, 176, 89, 208, 104, 64, 90, 183, 16, 176, 91, 185, 132, 192, 92, 150, 242, 176, 93, 153, 102, 192, 94, 118, 212, 176, 95, 121, 72, 192, 96, 95, 241, 48, 97, 89, 42, 192, 98, 63, 211, 48, 99, 57, 12, 192, 100, 31, 181, 48, 101, 24, 238, 192, 101, 255, 151, 48, 103, 2, 11, 64, 103, 223, 121, 48, 104, 225, 237, 64, 105, 191, 91, 48, 106, 193, 207, 64, 107, 168, 119, 176, 108, 161, 177, 64, 109, 136, 89, 176, 110, 129, 147, 64, 111, 104, 59, 176, 112, 106, 175, 192, 113, 72, 29, 176, 114, 74, 145, 192, 115, 39, 255, 176, 116, 42, 115, 192, 117, 17, 28, 48, 118, 10, 85, 192, 118, 240, 254, 48, 119, 234, 55, 192, 120, 208, 224, 48, 121, 202, 25, 192, 122, 176, 194, 48, 123, 179, 54, 64, 124, 144, 164, 48, 125, 147, 24, 64, 126, 112, 134, 48, 127, 114, 250, 64, 127, 255, 255, 255, 1, 2, 3, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 4, 255, 255, 201, 240, 0, 0, 255, 255, 201, 240, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 0, 12, 255, 255, 213, 208, 1, 12, 255, 255, 199, 192, 0, 8, 76, 77, 84, 0, 65, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 52, 62, 52, 60, 45, 48, 51, 62, 44, 77, 49, 48, 46, 49, 46, 48, 47, 48, 44, 77, 51, 46, 52, 46, 48, 47, 48, 10}, - - "zoneinfo/America/Atikokan": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 6, 0, 0, 0, 24, 128, 0, 0, 0, 158, 184, 161, 128, 159, 186, 249, 112, 200, 248, 87, 96, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 2, 1, 2, 1, 3, 4, 5, 255, 255, 170, 28, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 10, 69, 83, 84, 53, 10}, - - "zoneinfo/America/Atka": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 144, 0, 0, 0, 9, 0, 0, 0, 33, 128, 0, 0, 0, 203, 137, 68, 208, 210, 35, 244, 112, 210, 97, 80, 64, 250, 210, 85, 176, 254, 184, 113, 80, 255, 168, 84, 64, 0, 152, 83, 80, 1, 136, 54, 64, 2, 120, 53, 80, 3, 113, 82, 192, 4, 97, 81, 208, 5, 81, 52, 192, 6, 65, 51, 208, 7, 49, 22, 192, 7, 141, 109, 208, 9, 16, 248, 192, 9, 173, 233, 80, 10, 240, 218, 192, 11, 224, 217, 208, 12, 217, 247, 64, 13, 192, 187, 208, 14, 185, 217, 64, 15, 169, 216, 80, 16, 153, 187, 64, 17, 137, 186, 80, 18, 121, 157, 64, 19, 105, 156, 80, 20, 89, 127, 64, 21, 73, 126, 80, 22, 57, 97, 64, 23, 41, 96, 80, 24, 34, 125, 192, 25, 9, 66, 80, 26, 2, 95, 192, 26, 43, 34, 32, 26, 242, 80, 192, 27, 226, 51, 176, 28, 210, 50, 192, 29, 194, 21, 176, 30, 178, 20, 192, 31, 161, 247, 176, 32, 118, 71, 64, 33, 129, 217, 176, 34, 86, 41, 64, 35, 106, 246, 48, 36, 54, 11, 64, 37, 74, 216, 48, 38, 21, 237, 64, 39, 42, 186, 48, 39, 255, 9, 192, 41, 10, 156, 48, 41, 222, 235, 192, 42, 234, 126, 48, 43, 190, 205, 192, 44, 211, 154, 176, 45, 158, 175, 192, 46, 179, 124, 176, 47, 126, 145, 192, 48, 147, 94, 176, 49, 103, 174, 64, 50, 115, 64, 176, 51, 71, 144, 64, 52, 83, 34, 176, 53, 39, 114, 64, 54, 51, 4, 176, 55, 7, 84, 64, 56, 28, 33, 48, 56, 231, 54, 64, 57, 252, 3, 48, 58, 199, 24, 64, 59, 219, 229, 48, 60, 176, 52, 192, 61, 187, 199, 48, 62, 144, 22, 192, 63, 155, 169, 48, 64, 111, 248, 192, 65, 132, 197, 176, 66, 79, 218, 192, 67, 100, 167, 176, 68, 47, 188, 192, 69, 68, 137, 176, 69, 243, 239, 64, 71, 45, 166, 48, 71, 211, 209, 64, 73, 13, 136, 48, 73, 179, 179, 64, 74, 237, 106, 48, 75, 156, 207, 192, 76, 214, 134, 176, 77, 124, 177, 192, 78, 182, 104, 176, 79, 92, 147, 192, 80, 150, 74, 176, 81, 60, 117, 192, 82, 118, 44, 176, 83, 28, 87, 192, 84, 86, 14, 176, 84, 252, 57, 192, 86, 53, 240, 176, 86, 229, 86, 64, 88, 31, 13, 48, 88, 197, 56, 64, 89, 254, 239, 48, 90, 165, 26, 64, 91, 222, 209, 48, 92, 132, 252, 64, 93, 190, 179, 48, 94, 100, 222, 64, 95, 158, 149, 48, 96, 77, 250, 192, 97, 135, 177, 176, 98, 45, 220, 192, 99, 103, 147, 176, 100, 13, 190, 192, 101, 71, 117, 176, 101, 237, 160, 192, 103, 39, 87, 176, 103, 205, 130, 192, 105, 7, 57, 176, 105, 173, 100, 192, 106, 231, 27, 176, 107, 150, 129, 64, 108, 208, 56, 48, 109, 118, 99, 64, 110, 176, 26, 48, 111, 86, 69, 64, 112, 143, 252, 48, 113, 54, 39, 64, 114, 111, 222, 48, 115, 22, 9, 64, 116, 79, 192, 48, 116, 255, 37, 192, 118, 56, 220, 176, 118, 223, 7, 192, 120, 24, 190, 176, 120, 190, 233, 192, 121, 248, 160, 176, 122, 158, 203, 192, 123, 216, 130, 176, 124, 126, 173, 192, 125, 184, 100, 176, 126, 94, 143, 192, 127, 152, 70, 176, 1, 2, 3, 1, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 6, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 255, 255, 90, 98, 0, 0, 255, 255, 101, 80, 0, 4, 255, 255, 115, 96, 1, 8, 255, 255, 115, 96, 1, 12, 255, 255, 101, 80, 0, 16, 255, 255, 115, 96, 1, 20, 255, 255, 115, 96, 0, 24, 255, 255, 129, 112, 1, 29, 255, 255, 115, 96, 0, 25, 76, 77, 84, 0, 78, 83, 84, 0, 78, 87, 84, 0, 78, 80, 84, 0, 66, 83, 84, 0, 66, 68, 84, 0, 65, 72, 83, 84, 0, 72, 68, 84, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 10, 72, 83, 84, 49, 48, 72, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Bahia": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 63, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 107, 28, 184, 15, 73, 224, 184, 253, 64, 160, 185, 241, 52, 48, 186, 222, 116, 32, 218, 56, 174, 48, 218, 235, 250, 48, 220, 25, 225, 176, 220, 185, 89, 32, 221, 251, 21, 48, 222, 155, 222, 32, 223, 221, 154, 48, 224, 84, 51, 32, 244, 151, 255, 176, 245, 5, 94, 32, 246, 192, 100, 48, 247, 14, 30, 160, 248, 81, 44, 48, 248, 199, 197, 32, 250, 10, 210, 176, 250, 168, 248, 160, 251, 236, 6, 48, 252, 139, 125, 160, 29, 201, 142, 48, 30, 120, 215, 160, 31, 160, 53, 176, 32, 51, 207, 160, 33, 129, 105, 48, 34, 11, 200, 160, 35, 88, 16, 176, 35, 226, 112, 32, 37, 55, 242, 176, 37, 212, 199, 32, 39, 33, 15, 48, 39, 189, 227, 160, 41, 0, 241, 48, 41, 148, 139, 32, 42, 234, 13, 176, 43, 107, 50, 160, 44, 192, 181, 48, 45, 102, 196, 32, 46, 160, 151, 48, 47, 70, 166, 32, 48, 128, 121, 48, 49, 29, 77, 160, 50, 87, 32, 176, 51, 6, 106, 32, 52, 56, 84, 48, 52, 248, 193, 32, 54, 32, 31, 48, 54, 207, 104, 160, 55, 246, 198, 176, 56, 184, 133, 32, 57, 223, 227, 48, 58, 143, 44, 160, 59, 200, 255, 176, 60, 111, 14, 160, 61, 196, 145, 48, 62, 78, 240, 160, 78, 154, 72, 176, 79, 73, 146, 32, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 255, 255, 219, 228, 0, 0, 255, 255, 227, 224, 1, 4, 255, 255, 213, 208, 0, 8, 76, 77, 84, 0, 45, 48, 50, 0, 45, 48, 51, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Bahia_Banderas": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 94, 0, 0, 0, 7, 0, 0, 0, 24, 128, 0, 0, 0, 165, 182, 232, 112, 175, 242, 110, 224, 182, 102, 86, 96, 183, 67, 210, 96, 184, 12, 54, 96, 184, 253, 134, 240, 203, 234, 113, 96, 216, 145, 180, 240, 0, 0, 112, 128, 49, 103, 132, 16, 50, 115, 22, 128, 51, 71, 102, 16, 52, 82, 248, 128, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 231, 12, 16, 57, 251, 217, 0, 58, 245, 18, 144, 59, 182, 209, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 206, 144, 65, 132, 155, 128, 66, 79, 176, 144, 67, 100, 125, 128, 68, 47, 146, 144, 69, 68, 95, 128, 70, 15, 116, 144, 71, 36, 65, 128, 71, 248, 145, 16, 73, 4, 35, 128, 73, 216, 115, 16, 74, 228, 5, 128, 75, 184, 85, 16, 76, 205, 19, 240, 77, 152, 41, 0, 78, 172, 245, 240, 79, 120, 11, 0, 80, 140, 215, 240, 81, 97, 39, 128, 82, 108, 185, 240, 83, 65, 9, 128, 84, 76, 155, 240, 85, 32, 235, 128, 86, 44, 125, 240, 87, 0, 205, 128, 88, 21, 154, 112, 88, 224, 175, 128, 89, 245, 124, 112, 90, 192, 145, 128, 91, 213, 94, 112, 92, 169, 174, 0, 93, 181, 64, 112, 94, 137, 144, 0, 95, 149, 34, 112, 96, 105, 114, 0, 97, 126, 62, 240, 98, 73, 84, 0, 99, 94, 32, 240, 100, 41, 54, 0, 101, 62, 2, 240, 102, 18, 82, 128, 103, 29, 228, 240, 103, 242, 52, 128, 104, 253, 198, 240, 105, 210, 22, 128, 106, 221, 168, 240, 107, 177, 248, 128, 108, 198, 197, 112, 109, 145, 218, 128, 110, 166, 167, 112, 111, 113, 188, 128, 112, 134, 137, 112, 113, 90, 217, 0, 114, 102, 107, 112, 115, 58, 187, 0, 116, 70, 77, 112, 117, 26, 157, 0, 118, 47, 105, 240, 118, 250, 127, 0, 120, 15, 75, 240, 120, 218, 97, 0, 121, 239, 45, 240, 122, 186, 67, 0, 123, 207, 15, 240, 124, 163, 95, 128, 125, 174, 241, 240, 126, 131, 65, 128, 127, 142, 211, 240, 0, 1, 2, 1, 2, 1, 2, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 255, 255, 157, 84, 0, 0, 255, 255, 157, 144, 0, 4, 255, 255, 171, 160, 0, 8, 255, 255, 143, 128, 0, 12, 255, 255, 171, 160, 1, 16, 255, 255, 185, 176, 1, 20, 255, 255, 171, 160, 0, 8, 76, 77, 84, 0, 77, 83, 84, 0, 67, 83, 84, 0, 80, 83, 84, 0, 77, 68, 84, 0, 67, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 52, 46, 49, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/America/Barbados": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 4, 0, 0, 0, 16, 128, 0, 0, 0, 169, 121, 36, 229, 184, 133, 99, 229, 14, 0, 242, 224, 14, 148, 140, 208, 15, 151, 0, 224, 16, 116, 110, 208, 17, 118, 226, 224, 18, 84, 80, 208, 19, 95, 255, 96, 20, 48, 62, 80, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 255, 255, 200, 27, 0, 0, 255, 255, 200, 27, 0, 4, 255, 255, 213, 208, 1, 8, 255, 255, 199, 192, 0, 12, 76, 77, 84, 0, 66, 77, 84, 0, 65, 68, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Belem": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 31, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 116, 116, 184, 15, 73, 224, 184, 253, 64, 160, 185, 241, 52, 48, 186, 222, 116, 32, 218, 56, 174, 48, 218, 235, 250, 48, 220, 25, 225, 176, 220, 185, 89, 32, 221, 251, 21, 48, 222, 155, 222, 32, 223, 221, 154, 48, 224, 84, 51, 32, 244, 151, 255, 176, 245, 5, 94, 32, 246, 192, 100, 48, 247, 14, 30, 160, 248, 81, 44, 48, 248, 199, 197, 32, 250, 10, 210, 176, 250, 168, 248, 160, 251, 236, 6, 48, 252, 139, 125, 160, 29, 201, 142, 48, 30, 120, 215, 160, 31, 160, 53, 176, 32, 51, 207, 160, 33, 129, 105, 48, 34, 11, 200, 160, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 255, 255, 210, 140, 0, 0, 255, 255, 227, 224, 1, 4, 255, 255, 213, 208, 0, 8, 76, 77, 84, 0, 45, 48, 50, 0, 45, 48, 51, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Belize": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 56, 0, 0, 0, 4, 0, 0, 0, 18, 128, 0, 0, 0, 147, 94, 217, 176, 159, 159, 59, 224, 160, 69, 81, 216, 161, 127, 29, 224, 162, 46, 110, 88, 163, 94, 255, 224, 164, 14, 80, 88, 165, 62, 225, 224, 165, 238, 50, 88, 167, 39, 254, 96, 167, 206, 20, 88, 169, 7, 224, 96, 169, 173, 246, 88, 170, 231, 194, 96, 171, 151, 18, 216, 172, 199, 164, 96, 173, 118, 244, 216, 174, 167, 134, 96, 175, 86, 214, 216, 176, 135, 104, 96, 177, 54, 184, 216, 178, 112, 132, 224, 179, 22, 154, 216, 180, 80, 102, 224, 180, 246, 124, 216, 182, 48, 72, 224, 182, 223, 153, 88, 184, 16, 42, 224, 184, 191, 123, 88, 185, 240, 12, 224, 186, 159, 93, 88, 187, 217, 41, 96, 188, 127, 63, 88, 189, 185, 11, 96, 190, 95, 33, 88, 191, 152, 237, 96, 192, 63, 3, 88, 193, 120, 207, 96, 194, 40, 31, 216, 195, 88, 177, 96, 196, 8, 1, 216, 197, 56, 147, 96, 197, 231, 227, 216, 199, 33, 175, 224, 199, 199, 197, 216, 201, 1, 145, 224, 201, 167, 167, 216, 202, 225, 115, 224, 203, 144, 196, 88, 204, 193, 85, 224, 205, 112, 166, 88, 7, 98, 219, 96, 7, 185, 208, 80, 24, 97, 113, 96, 24, 171, 55, 80, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 3, 2, 255, 255, 173, 80, 0, 0, 255, 255, 178, 168, 1, 4, 255, 255, 171, 160, 0, 10, 255, 255, 185, 176, 1, 14, 76, 77, 84, 0, 45, 48, 53, 51, 48, 0, 67, 83, 84, 0, 67, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 54, 10}, - - "zoneinfo/America/Blanc-Sablon": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 158, 184, 133, 96, 159, 186, 221, 80, 203, 136, 226, 96, 210, 35, 244, 112, 210, 96, 237, 208, 2, 1, 2, 3, 4, 2, 255, 255, 202, 116, 0, 0, 255, 255, 213, 208, 1, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 213, 208, 1, 16, 76, 77, 84, 0, 65, 68, 84, 0, 65, 83, 84, 0, 65, 87, 84, 0, 65, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Boa_Vista": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 35, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 127, 224, 184, 15, 87, 240, 184, 253, 78, 176, 185, 241, 66, 64, 186, 222, 130, 48, 218, 56, 188, 64, 218, 236, 8, 64, 220, 25, 239, 192, 220, 185, 103, 48, 221, 251, 35, 64, 222, 155, 236, 48, 223, 221, 168, 64, 224, 84, 65, 48, 244, 152, 13, 192, 245, 5, 108, 48, 246, 192, 114, 64, 247, 14, 44, 176, 248, 81, 58, 64, 248, 199, 211, 48, 250, 10, 224, 192, 250, 169, 6, 176, 251, 236, 20, 64, 252, 139, 139, 176, 29, 201, 156, 64, 30, 120, 229, 176, 31, 160, 67, 192, 32, 51, 221, 176, 33, 129, 119, 64, 34, 11, 214, 176, 55, 246, 212, 192, 56, 184, 147, 48, 57, 223, 241, 64, 57, 233, 29, 176, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 255, 255, 199, 32, 0, 0, 255, 255, 213, 208, 1, 4, 255, 255, 199, 192, 0, 8, 76, 77, 84, 0, 45, 48, 51, 0, 45, 48, 52, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 52, 62, 52, 10}, - - "zoneinfo/America/Bogota": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 4, 0, 0, 0, 16, 128, 0, 0, 0, 152, 88, 85, 112, 42, 3, 115, 80, 43, 190, 93, 64, 127, 255, 255, 255, 1, 3, 2, 3, 3, 255, 255, 186, 144, 0, 0, 255, 255, 186, 144, 0, 4, 255, 255, 199, 192, 1, 8, 255, 255, 185, 176, 0, 12, 76, 77, 84, 0, 66, 77, 84, 0, 45, 48, 52, 0, 45, 48, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 53, 62, 53, 10}, - - "zoneinfo/America/Boise": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 151, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 158, 166, 72, 160, 159, 187, 21, 144, 160, 134, 42, 160, 161, 154, 247, 144, 168, 70, 76, 32, 203, 137, 12, 144, 210, 35, 244, 112, 210, 97, 24, 0, 250, 248, 117, 16, 251, 232, 88, 0, 252, 216, 87, 16, 253, 200, 58, 0, 254, 184, 57, 16, 255, 168, 28, 0, 0, 152, 27, 16, 1, 135, 254, 0, 2, 119, 253, 16, 3, 113, 26, 128, 4, 97, 25, 144, 5, 80, 252, 128, 6, 64, 251, 144, 7, 48, 222, 128, 7, 178, 31, 144, 9, 16, 192, 128, 9, 173, 177, 16, 10, 240, 162, 128, 11, 224, 161, 144, 12, 217, 191, 0, 13, 192, 131, 144, 14, 185, 161, 0, 15, 169, 160, 16, 16, 153, 131, 0, 17, 137, 130, 16, 18, 121, 101, 0, 19, 105, 100, 16, 20, 89, 71, 0, 21, 73, 70, 16, 22, 57, 41, 0, 23, 41, 40, 16, 24, 34, 69, 128, 25, 9, 10, 16, 26, 2, 39, 128, 26, 242, 38, 144, 27, 226, 9, 128, 28, 210, 8, 144, 29, 193, 235, 128, 30, 177, 234, 144, 31, 161, 205, 128, 32, 118, 29, 16, 33, 129, 175, 128, 34, 85, 255, 16, 35, 106, 204, 0, 36, 53, 225, 16, 37, 74, 174, 0, 38, 21, 195, 16, 39, 42, 144, 0, 39, 254, 223, 144, 41, 10, 114, 0, 41, 222, 193, 144, 42, 234, 84, 0, 43, 190, 163, 144, 44, 211, 112, 128, 45, 158, 133, 144, 46, 179, 82, 128, 47, 126, 103, 144, 48, 147, 52, 128, 49, 103, 132, 16, 50, 115, 22, 128, 51, 71, 102, 16, 52, 82, 248, 128, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 231, 12, 16, 57, 251, 217, 0, 58, 198, 238, 16, 59, 219, 187, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 206, 144, 65, 132, 155, 128, 66, 79, 176, 144, 67, 100, 125, 128, 68, 47, 146, 144, 69, 68, 95, 128, 69, 243, 197, 16, 71, 45, 124, 0, 71, 211, 167, 16, 73, 13, 94, 0, 73, 179, 137, 16, 74, 237, 64, 0, 75, 156, 165, 144, 76, 214, 92, 128, 77, 124, 135, 144, 78, 182, 62, 128, 79, 92, 105, 144, 80, 150, 32, 128, 81, 60, 75, 144, 82, 118, 2, 128, 83, 28, 45, 144, 84, 85, 228, 128, 84, 252, 15, 144, 86, 53, 198, 128, 86, 229, 44, 16, 88, 30, 227, 0, 88, 197, 14, 16, 89, 254, 197, 0, 90, 164, 240, 16, 91, 222, 167, 0, 92, 132, 210, 16, 93, 190, 137, 0, 94, 100, 180, 16, 95, 158, 107, 0, 96, 77, 208, 144, 97, 135, 135, 128, 98, 45, 178, 144, 99, 103, 105, 128, 100, 13, 148, 144, 101, 71, 75, 128, 101, 237, 118, 144, 103, 39, 45, 128, 103, 205, 88, 144, 105, 7, 15, 128, 105, 173, 58, 144, 106, 230, 241, 128, 107, 150, 87, 16, 108, 208, 14, 0, 109, 118, 57, 16, 110, 175, 240, 0, 111, 86, 27, 16, 112, 143, 210, 0, 113, 53, 253, 16, 114, 111, 180, 0, 115, 21, 223, 16, 116, 79, 150, 0, 116, 254, 251, 144, 118, 56, 178, 128, 118, 222, 221, 144, 120, 24, 148, 128, 120, 190, 191, 144, 121, 248, 118, 128, 122, 158, 161, 144, 123, 216, 88, 128, 124, 126, 131, 144, 125, 184, 58, 128, 126, 94, 101, 144, 127, 152, 28, 128, 2, 1, 2, 1, 2, 5, 3, 4, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 255, 255, 147, 15, 0, 0, 255, 255, 157, 144, 1, 4, 255, 255, 143, 128, 0, 8, 255, 255, 171, 160, 1, 12, 255, 255, 171, 160, 1, 16, 255, 255, 157, 144, 0, 20, 255, 255, 171, 160, 1, 24, 76, 77, 84, 0, 80, 68, 84, 0, 80, 83, 84, 0, 77, 87, 84, 0, 77, 80, 84, 0, 77, 83, 84, 0, 77, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 77, 83, 84, 55, 77, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Buenos_Aires": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 33, 15, 48, 39, 208, 88, 160, 41, 0, 241, 48, 41, 176, 58, 160, 42, 224, 211, 48, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 71, 119, 9, 176, 71, 220, 127, 32, 72, 250, 162, 176, 73, 188, 97, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 3, 5, 4, 5, 4, 5, 5, 255, 255, 201, 52, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Cambridge_Bay": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 124, 0, 0, 0, 11, 0, 0, 0, 37, 128, 0, 0, 0, 161, 242, 205, 128, 203, 137, 12, 144, 210, 35, 244, 112, 210, 97, 24, 0, 247, 47, 90, 112, 248, 40, 133, 240, 19, 105, 100, 16, 20, 89, 71, 0, 21, 73, 70, 16, 22, 57, 41, 0, 23, 41, 40, 16, 24, 34, 69, 128, 25, 9, 10, 16, 26, 2, 39, 128, 26, 242, 38, 144, 27, 226, 9, 128, 28, 210, 8, 144, 29, 193, 235, 128, 30, 177, 234, 144, 31, 161, 205, 128, 32, 118, 29, 16, 33, 129, 175, 128, 34, 85, 255, 16, 35, 106, 204, 0, 36, 53, 225, 16, 37, 74, 174, 0, 38, 21, 195, 16, 39, 42, 144, 0, 39, 254, 223, 144, 41, 10, 114, 0, 41, 222, 193, 144, 42, 234, 84, 0, 43, 190, 163, 144, 44, 211, 112, 128, 45, 158, 133, 144, 46, 179, 82, 128, 47, 126, 103, 144, 48, 147, 52, 128, 49, 103, 132, 16, 50, 115, 22, 128, 51, 71, 102, 16, 52, 82, 248, 128, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 230, 254, 0, 57, 251, 202, 240, 58, 4, 233, 80, 58, 198, 238, 16, 59, 219, 187, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 206, 144, 65, 132, 155, 128, 66, 79, 176, 144, 67, 100, 125, 128, 68, 47, 146, 144, 69, 68, 95, 128, 69, 243, 197, 16, 71, 45, 124, 0, 71, 211, 167, 16, 73, 13, 94, 0, 73, 179, 137, 16, 74, 237, 64, 0, 75, 156, 165, 144, 76, 214, 92, 128, 77, 124, 135, 144, 78, 182, 62, 128, 79, 92, 105, 144, 80, 150, 32, 128, 81, 60, 75, 144, 82, 118, 2, 128, 83, 28, 45, 144, 84, 85, 228, 128, 84, 252, 15, 144, 86, 53, 198, 128, 86, 229, 44, 16, 88, 30, 227, 0, 88, 197, 14, 16, 89, 254, 197, 0, 90, 164, 240, 16, 91, 222, 167, 0, 92, 132, 210, 16, 93, 190, 137, 0, 94, 100, 180, 16, 95, 158, 107, 0, 96, 77, 208, 144, 97, 135, 135, 128, 98, 45, 178, 144, 99, 103, 105, 128, 100, 13, 148, 144, 101, 71, 75, 128, 101, 237, 118, 144, 103, 39, 45, 128, 103, 205, 88, 144, 105, 7, 15, 128, 105, 173, 58, 144, 106, 230, 241, 128, 107, 150, 87, 16, 108, 208, 14, 0, 109, 118, 57, 16, 110, 175, 240, 0, 111, 86, 27, 16, 112, 143, 210, 0, 113, 53, 253, 16, 114, 111, 180, 0, 115, 21, 223, 16, 116, 79, 150, 0, 116, 254, 251, 144, 118, 56, 178, 128, 118, 222, 221, 144, 120, 24, 148, 128, 120, 190, 191, 144, 121, 248, 118, 128, 122, 158, 161, 144, 123, 216, 88, 128, 124, 126, 131, 144, 125, 184, 58, 128, 126, 94, 101, 144, 127, 152, 28, 128, 0, 3, 1, 2, 3, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 7, 6, 8, 7, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 0, 0, 0, 0, 0, 0, 255, 255, 171, 160, 1, 4, 255, 255, 171, 160, 1, 8, 255, 255, 157, 144, 0, 12, 255, 255, 185, 176, 1, 16, 255, 255, 171, 160, 1, 21, 255, 255, 185, 176, 1, 25, 255, 255, 171, 160, 0, 29, 255, 255, 185, 176, 0, 33, 255, 255, 171, 160, 1, 21, 255, 255, 157, 144, 0, 12, 45, 48, 48, 0, 77, 87, 84, 0, 77, 80, 84, 0, 77, 83, 84, 0, 77, 68, 68, 84, 0, 77, 68, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 69, 83, 84, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 10, 77, 83, 84, 55, 77, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Campo_Grande": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 129, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 122, 52, 184, 15, 87, 240, 184, 253, 78, 176, 185, 241, 66, 64, 186, 222, 130, 48, 218, 56, 188, 64, 218, 236, 8, 64, 220, 25, 239, 192, 220, 185, 103, 48, 221, 251, 35, 64, 222, 155, 236, 48, 223, 221, 168, 64, 224, 84, 65, 48, 244, 152, 13, 192, 245, 5, 108, 48, 246, 192, 114, 64, 247, 14, 44, 176, 248, 81, 58, 64, 248, 199, 211, 48, 250, 10, 224, 192, 250, 169, 6, 176, 251, 236, 20, 64, 252, 139, 139, 176, 29, 201, 156, 64, 30, 120, 229, 176, 31, 160, 67, 192, 32, 51, 221, 176, 33, 129, 119, 64, 34, 11, 214, 176, 35, 88, 30, 192, 35, 226, 126, 48, 37, 56, 0, 192, 37, 212, 213, 48, 39, 33, 29, 64, 39, 189, 241, 176, 41, 0, 255, 64, 41, 148, 153, 48, 42, 234, 27, 192, 43, 107, 64, 176, 44, 192, 195, 64, 45, 102, 210, 48, 46, 160, 165, 64, 47, 70, 180, 48, 48, 128, 135, 64, 49, 29, 91, 176, 50, 87, 46, 192, 51, 6, 120, 48, 52, 56, 98, 64, 52, 248, 207, 48, 54, 32, 45, 64, 54, 207, 118, 176, 55, 246, 212, 192, 56, 184, 147, 48, 57, 223, 241, 64, 58, 143, 58, 176, 59, 201, 13, 192, 60, 111, 28, 176, 61, 196, 159, 64, 62, 78, 254, 176, 63, 146, 12, 64, 64, 46, 224, 176, 65, 135, 6, 64, 66, 23, 253, 48, 67, 81, 208, 64, 67, 247, 223, 48, 69, 77, 97, 192, 69, 224, 251, 176, 71, 17, 148, 64, 71, 183, 163, 48, 72, 250, 176, 192, 73, 151, 133, 48, 74, 218, 146, 192, 75, 128, 161, 176, 76, 186, 116, 192, 77, 96, 131, 176, 78, 154, 86, 192, 79, 73, 160, 48, 80, 131, 115, 64, 81, 32, 71, 176, 82, 99, 85, 64, 83, 0, 41, 176, 84, 67, 55, 64, 84, 233, 70, 48, 86, 35, 25, 64, 86, 201, 40, 48, 88, 2, 251, 64, 88, 169, 10, 48, 89, 226, 221, 64, 90, 136, 236, 48, 91, 203, 249, 192, 92, 104, 206, 48, 93, 171, 219, 192, 94, 72, 176, 48, 95, 139, 189, 192, 96, 49, 204, 176, 97, 107, 159, 192, 98, 17, 174, 176, 99, 75, 129, 192, 99, 250, 203, 48, 101, 43, 99, 192, 101, 209, 114, 176, 103, 20, 128, 64, 103, 177, 84, 176, 104, 244, 98, 64, 105, 154, 113, 48, 106, 212, 68, 64, 107, 122, 83, 48, 108, 180, 38, 64, 109, 90, 53, 48, 110, 148, 8, 64, 111, 58, 23, 48, 112, 125, 36, 192, 113, 25, 249, 48, 114, 93, 6, 192, 114, 249, 219, 48, 116, 60, 232, 192, 116, 217, 189, 48, 118, 28, 202, 192, 118, 194, 217, 176, 119, 252, 172, 192, 120, 171, 246, 48, 121, 220, 142, 192, 122, 130, 157, 176, 123, 197, 171, 64, 124, 98, 127, 176, 125, 165, 141, 64, 126, 75, 156, 48, 127, 133, 111, 64, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 255, 255, 204, 204, 0, 0, 255, 255, 213, 208, 1, 4, 255, 255, 199, 192, 0, 8, 76, 77, 84, 0, 45, 48, 51, 0, 45, 48, 52, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 52, 62, 52, 60, 45, 48, 51, 62, 44, 77, 49, 48, 46, 51, 46, 48, 47, 48, 44, 77, 50, 46, 51, 46, 48, 47, 48, 10}, - - "zoneinfo/America/Cancun": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 43, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 165, 182, 218, 96, 22, 134, 213, 96, 49, 103, 103, 240, 50, 114, 250, 96, 51, 71, 73, 240, 52, 82, 220, 96, 53, 39, 43, 240, 53, 196, 0, 96, 54, 50, 204, 112, 55, 7, 28, 0, 56, 27, 232, 240, 56, 230, 254, 0, 57, 251, 202, 240, 58, 245, 4, 128, 59, 182, 194, 240, 60, 175, 252, 128, 61, 187, 142, 240, 62, 143, 222, 128, 63, 155, 112, 240, 64, 111, 192, 128, 65, 132, 141, 112, 66, 79, 162, 128, 67, 100, 111, 112, 68, 47, 132, 128, 69, 68, 81, 112, 70, 15, 102, 128, 71, 36, 51, 112, 71, 248, 131, 0, 73, 4, 21, 112, 73, 216, 101, 0, 74, 227, 247, 112, 75, 184, 71, 0, 76, 205, 19, 240, 77, 152, 41, 0, 78, 172, 245, 240, 79, 120, 11, 0, 80, 140, 215, 240, 81, 97, 39, 128, 82, 108, 185, 240, 83, 65, 9, 128, 84, 76, 155, 240, 84, 205, 221, 0, 0, 1, 3, 2, 3, 2, 3, 2, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 3, 255, 255, 174, 168, 0, 0, 255, 255, 171, 160, 0, 4, 255, 255, 199, 192, 1, 8, 255, 255, 185, 176, 0, 12, 255, 255, 185, 176, 1, 16, 76, 77, 84, 0, 67, 83, 84, 0, 69, 68, 84, 0, 69, 83, 84, 0, 67, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 83, 84, 53, 10}, - - "zoneinfo/America/Caracas": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 18, 128, 0, 0, 0, 147, 30, 44, 60, 246, 152, 236, 72, 71, 91, 146, 112, 87, 37, 169, 112, 127, 255, 255, 255, 1, 2, 3, 2, 3, 3, 255, 255, 193, 64, 0, 0, 255, 255, 193, 68, 0, 4, 255, 255, 192, 184, 0, 8, 255, 255, 199, 192, 0, 14, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 51, 48, 0, 45, 48, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 52, 62, 52, 10}, - - "zoneinfo/America/Catamarca": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 33, 15, 48, 39, 208, 88, 160, 41, 0, 255, 64, 41, 176, 58, 160, 42, 224, 211, 48, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 64, 187, 241, 48, 64, 213, 11, 192, 71, 119, 9, 176, 71, 220, 127, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 5, 4, 2, 4, 5, 4, 5, 3, 5, 2, 5, 4, 5, 5, 255, 255, 194, 84, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Cayenne": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 145, 244, 43, 144, 251, 195, 53, 192, 127, 255, 255, 255, 0, 1, 2, 2, 255, 255, 206, 240, 0, 0, 255, 255, 199, 192, 0, 4, 255, 255, 213, 208, 0, 8, 76, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Cayman": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 139, 244, 97, 232, 1, 2, 255, 255, 181, 112, 0, 0, 255, 255, 181, 24, 0, 4, 255, 255, 185, 176, 0, 8, 76, 77, 84, 0, 67, 77, 84, 0, 69, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 69, 83, 84, 53, 10}, - - "zoneinfo/America/Chicago": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 236, 0, 0, 0, 7, 0, 0, 0, 24, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 162, 203, 116, 0, 163, 131, 247, 240, 164, 69, 210, 128, 165, 99, 217, 240, 166, 83, 217, 0, 167, 21, 151, 112, 168, 51, 187, 0, 168, 254, 179, 240, 170, 19, 157, 0, 170, 222, 149, 240, 171, 243, 127, 0, 172, 190, 119, 240, 173, 211, 97, 0, 174, 158, 89, 240, 175, 179, 67, 0, 176, 126, 59, 240, 177, 156, 95, 128, 178, 103, 88, 112, 179, 124, 65, 128, 180, 71, 58, 112, 181, 92, 35, 128, 182, 39, 28, 112, 183, 60, 5, 128, 184, 6, 254, 112, 185, 27, 231, 128, 185, 230, 224, 112, 187, 5, 4, 0, 187, 198, 194, 112, 188, 228, 230, 0, 189, 175, 222, 240, 190, 196, 200, 0, 191, 143, 192, 240, 192, 90, 214, 0, 193, 176, 60, 112, 194, 132, 140, 0, 195, 79, 132, 240, 196, 100, 110, 0, 197, 47, 102, 240, 198, 77, 138, 128, 199, 15, 72, 240, 200, 45, 108, 128, 200, 248, 101, 112, 202, 13, 78, 128, 202, 216, 71, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 211, 117, 243, 0, 212, 64, 235, 240, 213, 85, 213, 0, 214, 32, 205, 240, 215, 53, 183, 0, 216, 0, 175, 240, 217, 21, 153, 0, 217, 224, 145, 240, 218, 254, 181, 128, 219, 192, 115, 240, 220, 222, 151, 128, 221, 169, 144, 112, 222, 190, 121, 128, 223, 137, 114, 112, 224, 158, 91, 128, 225, 105, 84, 112, 226, 126, 61, 128, 227, 73, 54, 112, 228, 94, 31, 128, 229, 87, 60, 240, 230, 71, 60, 0, 231, 55, 30, 240, 232, 39, 30, 0, 233, 23, 0, 240, 234, 7, 0, 0, 234, 246, 226, 240, 235, 230, 226, 0, 236, 214, 196, 240, 237, 198, 196, 0, 238, 191, 225, 112, 239, 175, 224, 128, 240, 159, 195, 112, 241, 143, 194, 128, 242, 127, 165, 112, 243, 111, 164, 128, 244, 95, 135, 112, 245, 79, 134, 128, 246, 63, 105, 112, 247, 47, 104, 128, 248, 40, 133, 240, 249, 15, 74, 128, 250, 8, 103, 240, 250, 248, 103, 0, 251, 232, 73, 240, 252, 216, 73, 0, 253, 200, 43, 240, 254, 184, 43, 0, 255, 168, 13, 240, 0, 152, 13, 0, 1, 135, 239, 240, 2, 119, 239, 0, 3, 113, 12, 112, 4, 97, 11, 128, 5, 80, 238, 112, 6, 64, 237, 128, 7, 48, 208, 112, 7, 141, 39, 128, 9, 16, 178, 112, 9, 173, 163, 0, 10, 240, 148, 112, 11, 224, 147, 128, 12, 217, 176, 240, 13, 192, 117, 128, 14, 185, 146, 240, 15, 169, 146, 0, 16, 153, 116, 240, 17, 137, 116, 0, 18, 121, 86, 240, 19, 105, 86, 0, 20, 89, 56, 240, 21, 73, 56, 0, 22, 57, 26, 240, 23, 41, 26, 0, 24, 34, 55, 112, 25, 8, 252, 0, 26, 2, 25, 112, 26, 242, 24, 128, 27, 225, 251, 112, 28, 209, 250, 128, 29, 193, 221, 112, 30, 177, 220, 128, 31, 161, 191, 112, 32, 118, 15, 0, 33, 129, 161, 112, 34, 85, 241, 0, 35, 106, 189, 240, 36, 53, 211, 0, 37, 74, 159, 240, 38, 21, 181, 0, 39, 42, 129, 240, 39, 254, 209, 128, 41, 10, 99, 240, 41, 222, 179, 128, 42, 234, 69, 240, 43, 190, 149, 128, 44, 211, 98, 112, 45, 158, 119, 128, 46, 179, 68, 112, 47, 126, 89, 128, 48, 147, 38, 112, 49, 103, 118, 0, 50, 115, 8, 112, 51, 71, 88, 0, 52, 82, 234, 112, 53, 39, 58, 0, 54, 50, 204, 112, 55, 7, 28, 0, 56, 27, 232, 240, 56, 230, 254, 0, 57, 251, 202, 240, 58, 198, 224, 0, 59, 219, 172, 240, 60, 175, 252, 128, 61, 187, 142, 240, 62, 143, 222, 128, 63, 155, 112, 240, 64, 111, 192, 128, 65, 132, 141, 112, 66, 79, 162, 128, 67, 100, 111, 112, 68, 47, 132, 128, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 109, 240, 71, 211, 153, 0, 73, 13, 79, 240, 73, 179, 123, 0, 74, 237, 49, 240, 75, 156, 151, 128, 76, 214, 78, 112, 77, 124, 121, 128, 78, 182, 48, 112, 79, 92, 91, 128, 80, 150, 18, 112, 81, 60, 61, 128, 82, 117, 244, 112, 83, 28, 31, 128, 84, 85, 214, 112, 84, 252, 1, 128, 86, 53, 184, 112, 86, 229, 30, 0, 88, 30, 212, 240, 88, 197, 0, 0, 89, 254, 182, 240, 90, 164, 226, 0, 91, 222, 152, 240, 92, 132, 196, 0, 93, 190, 122, 240, 94, 100, 166, 0, 95, 158, 92, 240, 96, 77, 194, 128, 97, 135, 121, 112, 98, 45, 164, 128, 99, 103, 91, 112, 100, 13, 134, 128, 101, 71, 61, 112, 101, 237, 104, 128, 103, 39, 31, 112, 103, 205, 74, 128, 105, 7, 1, 112, 105, 173, 44, 128, 106, 230, 227, 112, 107, 150, 73, 0, 108, 207, 255, 240, 109, 118, 43, 0, 110, 175, 225, 240, 111, 86, 13, 0, 112, 143, 195, 240, 113, 53, 239, 0, 114, 111, 165, 240, 115, 21, 209, 0, 116, 79, 135, 240, 116, 254, 237, 128, 118, 56, 164, 112, 118, 222, 207, 128, 120, 24, 134, 112, 120, 190, 177, 128, 121, 248, 104, 112, 122, 158, 147, 128, 123, 216, 74, 112, 124, 126, 117, 128, 125, 184, 44, 112, 126, 94, 87, 128, 127, 152, 14, 112, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 4, 5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 173, 212, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 0, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 1, 20, 255, 255, 171, 160, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 69, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Chihuahua": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 91, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 165, 182, 232, 112, 175, 242, 110, 224, 182, 102, 86, 96, 183, 67, 210, 96, 184, 12, 54, 96, 184, 253, 134, 240, 49, 103, 118, 0, 50, 115, 8, 112, 51, 71, 88, 0, 52, 82, 234, 112, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 231, 12, 16, 57, 251, 217, 0, 58, 245, 18, 144, 59, 182, 209, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 206, 144, 65, 132, 155, 128, 66, 79, 176, 144, 67, 100, 125, 128, 68, 47, 146, 144, 69, 68, 95, 128, 70, 15, 116, 144, 71, 36, 65, 128, 71, 248, 145, 16, 73, 4, 35, 128, 73, 216, 115, 16, 74, 228, 5, 128, 75, 184, 85, 16, 76, 205, 34, 0, 77, 152, 55, 16, 78, 173, 4, 0, 79, 120, 25, 16, 80, 140, 230, 0, 81, 97, 53, 144, 82, 108, 200, 0, 83, 65, 23, 144, 84, 76, 170, 0, 85, 32, 249, 144, 86, 44, 140, 0, 87, 0, 219, 144, 88, 21, 168, 128, 88, 224, 189, 144, 89, 245, 138, 128, 90, 192, 159, 144, 91, 213, 108, 128, 92, 169, 188, 16, 93, 181, 78, 128, 94, 137, 158, 16, 95, 149, 48, 128, 96, 105, 128, 16, 97, 126, 77, 0, 98, 73, 98, 16, 99, 94, 47, 0, 100, 41, 68, 16, 101, 62, 17, 0, 102, 18, 96, 144, 103, 29, 243, 0, 103, 242, 66, 144, 104, 253, 213, 0, 105, 210, 36, 144, 106, 221, 183, 0, 107, 178, 6, 144, 108, 198, 211, 128, 109, 145, 232, 144, 110, 166, 181, 128, 111, 113, 202, 144, 112, 134, 151, 128, 113, 90, 231, 16, 114, 102, 121, 128, 115, 58, 201, 16, 116, 70, 91, 128, 117, 26, 171, 16, 118, 47, 120, 0, 118, 250, 141, 16, 120, 15, 90, 0, 120, 218, 111, 16, 121, 239, 60, 0, 122, 186, 81, 16, 123, 207, 30, 0, 124, 163, 109, 144, 125, 175, 0, 0, 126, 131, 79, 144, 127, 142, 226, 0, 0, 1, 2, 1, 2, 1, 2, 3, 2, 3, 2, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 255, 255, 156, 140, 0, 0, 255, 255, 157, 144, 0, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 171, 160, 1, 16, 255, 255, 157, 144, 0, 4, 76, 77, 84, 0, 77, 83, 84, 0, 67, 83, 84, 0, 67, 68, 84, 0, 77, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 77, 83, 84, 55, 77, 68, 84, 44, 77, 52, 46, 49, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/America/Coral_Harbour": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 6, 0, 0, 0, 24, 128, 0, 0, 0, 158, 184, 161, 128, 159, 186, 249, 112, 200, 248, 87, 96, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 2, 1, 2, 1, 3, 4, 5, 255, 255, 170, 28, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 10, 69, 83, 84, 53, 10}, - - "zoneinfo/America/Cordoba": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 33, 15, 48, 39, 208, 88, 160, 41, 0, 255, 64, 41, 176, 58, 160, 42, 224, 211, 48, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 71, 119, 9, 176, 71, 220, 127, 32, 72, 250, 162, 176, 73, 188, 97, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 5, 4, 2, 4, 5, 4, 5, 3, 5, 4, 5, 4, 5, 5, 255, 255, 195, 208, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Costa_Rica": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 4, 0, 0, 0, 17, 128, 0, 0, 0, 163, 232, 22, 77, 17, 54, 73, 96, 17, 183, 110, 80, 19, 22, 43, 96, 19, 151, 80, 80, 39, 151, 224, 96, 40, 110, 182, 208, 41, 119, 194, 96, 41, 194, 217, 208, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 255, 255, 177, 51, 0, 0, 255, 255, 177, 51, 0, 4, 255, 255, 185, 176, 1, 9, 255, 255, 171, 160, 0, 13, 76, 77, 84, 0, 83, 74, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 54, 10}, - - "zoneinfo/America/Creston": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 4, 0, 0, 0, 12, 128, 0, 0, 0, 155, 214, 75, 112, 158, 249, 59, 0, 1, 2, 1, 255, 255, 146, 196, 0, 0, 255, 255, 157, 144, 0, 4, 255, 255, 143, 128, 0, 8, 255, 255, 157, 144, 0, 4, 76, 77, 84, 0, 77, 83, 84, 0, 80, 83, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 77, 83, 84, 55, 10}, - - "zoneinfo/America/Cuiaba": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 127, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 123, 148, 184, 15, 87, 240, 184, 253, 78, 176, 185, 241, 66, 64, 186, 222, 130, 48, 218, 56, 188, 64, 218, 236, 8, 64, 220, 25, 239, 192, 220, 185, 103, 48, 221, 251, 35, 64, 222, 155, 236, 48, 223, 221, 168, 64, 224, 84, 65, 48, 244, 152, 13, 192, 245, 5, 108, 48, 246, 192, 114, 64, 247, 14, 44, 176, 248, 81, 58, 64, 248, 199, 211, 48, 250, 10, 224, 192, 250, 169, 6, 176, 251, 236, 20, 64, 252, 139, 139, 176, 29, 201, 156, 64, 30, 120, 229, 176, 31, 160, 67, 192, 32, 51, 221, 176, 33, 129, 119, 64, 34, 11, 214, 176, 35, 88, 30, 192, 35, 226, 126, 48, 37, 56, 0, 192, 37, 212, 213, 48, 39, 33, 29, 64, 39, 189, 241, 176, 41, 0, 255, 64, 41, 148, 153, 48, 42, 234, 27, 192, 43, 107, 64, 176, 44, 192, 195, 64, 45, 102, 210, 48, 46, 160, 165, 64, 47, 70, 180, 48, 48, 128, 135, 64, 49, 29, 91, 176, 50, 87, 46, 192, 51, 6, 120, 48, 52, 56, 98, 64, 52, 248, 207, 48, 54, 32, 45, 64, 54, 207, 118, 176, 55, 246, 212, 192, 56, 184, 147, 48, 57, 223, 241, 64, 58, 143, 58, 176, 59, 201, 13, 192, 60, 111, 28, 176, 61, 196, 159, 64, 62, 78, 254, 176, 65, 135, 6, 64, 66, 23, 253, 48, 67, 81, 208, 64, 67, 247, 223, 48, 69, 77, 97, 192, 69, 224, 251, 176, 71, 17, 148, 64, 71, 183, 163, 48, 72, 250, 176, 192, 73, 151, 133, 48, 74, 218, 146, 192, 75, 128, 161, 176, 76, 186, 116, 192, 77, 96, 131, 176, 78, 154, 86, 192, 79, 73, 160, 48, 80, 131, 115, 64, 81, 32, 71, 176, 82, 99, 85, 64, 83, 0, 41, 176, 84, 67, 55, 64, 84, 233, 70, 48, 86, 35, 25, 64, 86, 201, 40, 48, 88, 2, 251, 64, 88, 169, 10, 48, 89, 226, 221, 64, 90, 136, 236, 48, 91, 203, 249, 192, 92, 104, 206, 48, 93, 171, 219, 192, 94, 72, 176, 48, 95, 139, 189, 192, 96, 49, 204, 176, 97, 107, 159, 192, 98, 17, 174, 176, 99, 75, 129, 192, 99, 250, 203, 48, 101, 43, 99, 192, 101, 209, 114, 176, 103, 20, 128, 64, 103, 177, 84, 176, 104, 244, 98, 64, 105, 154, 113, 48, 106, 212, 68, 64, 107, 122, 83, 48, 108, 180, 38, 64, 109, 90, 53, 48, 110, 148, 8, 64, 111, 58, 23, 48, 112, 125, 36, 192, 113, 25, 249, 48, 114, 93, 6, 192, 114, 249, 219, 48, 116, 60, 232, 192, 116, 217, 189, 48, 118, 28, 202, 192, 118, 194, 217, 176, 119, 252, 172, 192, 120, 171, 246, 48, 121, 220, 142, 192, 122, 130, 157, 176, 123, 197, 171, 64, 124, 98, 127, 176, 125, 165, 141, 64, 126, 75, 156, 48, 127, 133, 111, 64, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 255, 255, 203, 108, 0, 0, 255, 255, 213, 208, 1, 4, 255, 255, 199, 192, 0, 8, 76, 77, 84, 0, 45, 48, 51, 0, 45, 48, 52, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 52, 62, 52, 60, 45, 48, 51, 62, 44, 77, 49, 48, 46, 51, 46, 48, 47, 48, 44, 77, 50, 46, 51, 46, 48, 47, 48, 10}, - - "zoneinfo/America/Curacao": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 14, 128, 0, 0, 0, 147, 30, 46, 35, 246, 152, 236, 72, 0, 1, 2, 255, 255, 191, 93, 0, 0, 255, 255, 192, 184, 0, 4, 255, 255, 199, 192, 0, 10, 76, 77, 84, 0, 45, 48, 52, 51, 48, 0, 65, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Danmarkshavn": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 35, 0, 0, 0, 6, 0, 0, 0, 16, 128, 0, 0, 0, 155, 128, 73, 0, 19, 77, 124, 80, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 48, 231, 78, 48, 0, 1, 4, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 255, 255, 238, 128, 0, 0, 255, 255, 213, 208, 0, 4, 255, 255, 213, 208, 0, 4, 255, 255, 227, 224, 1, 8, 255, 255, 227, 224, 1, 8, 0, 0, 0, 0, 0, 12, 76, 77, 84, 0, 45, 48, 51, 0, 45, 48, 50, 0, 71, 77, 84, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/America/Dawson": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 127, 0, 0, 0, 8, 0, 0, 0, 33, 128, 0, 0, 0, 158, 184, 203, 176, 159, 187, 35, 160, 160, 208, 12, 176, 161, 162, 210, 128, 203, 137, 40, 176, 210, 35, 244, 112, 210, 97, 52, 32, 247, 47, 118, 144, 248, 40, 162, 16, 7, 48, 236, 144, 19, 105, 114, 32, 20, 89, 85, 16, 21, 73, 84, 32, 22, 57, 55, 16, 23, 41, 54, 32, 24, 34, 83, 144, 25, 9, 24, 32, 26, 2, 53, 144, 26, 242, 52, 160, 27, 226, 23, 144, 28, 210, 22, 160, 29, 193, 249, 144, 30, 177, 248, 160, 31, 161, 219, 144, 32, 118, 43, 32, 33, 129, 189, 144, 34, 86, 13, 32, 35, 106, 218, 16, 36, 53, 239, 32, 37, 74, 188, 16, 38, 21, 209, 32, 39, 42, 158, 16, 39, 254, 237, 160, 41, 10, 128, 16, 41, 222, 207, 160, 42, 234, 98, 16, 43, 190, 177, 160, 44, 211, 126, 144, 45, 158, 147, 160, 46, 179, 96, 144, 47, 126, 117, 160, 48, 147, 66, 144, 49, 103, 146, 32, 50, 115, 36, 144, 51, 71, 116, 32, 52, 83, 6, 144, 53, 39, 86, 32, 54, 50, 232, 144, 55, 7, 56, 32, 56, 28, 5, 16, 56, 231, 26, 32, 57, 251, 231, 16, 58, 198, 252, 32, 59, 219, 201, 16, 60, 176, 24, 160, 61, 187, 171, 16, 62, 143, 250, 160, 63, 155, 141, 16, 64, 111, 220, 160, 65, 132, 169, 144, 66, 79, 190, 160, 67, 100, 139, 144, 68, 47, 160, 160, 69, 68, 109, 144, 69, 243, 211, 32, 71, 45, 138, 16, 71, 211, 181, 32, 73, 13, 108, 16, 73, 179, 151, 32, 74, 237, 78, 16, 75, 156, 179, 160, 76, 214, 106, 144, 77, 124, 149, 160, 78, 182, 76, 144, 79, 92, 119, 160, 80, 150, 46, 144, 81, 60, 89, 160, 82, 118, 16, 144, 83, 28, 59, 160, 84, 85, 242, 144, 84, 252, 29, 160, 86, 53, 212, 144, 86, 229, 58, 32, 88, 30, 241, 16, 88, 197, 28, 32, 89, 254, 211, 16, 90, 164, 254, 32, 91, 222, 181, 16, 92, 132, 224, 32, 93, 190, 151, 16, 94, 100, 194, 32, 95, 158, 121, 16, 96, 77, 222, 160, 97, 135, 149, 144, 98, 45, 192, 160, 99, 103, 119, 144, 100, 13, 162, 160, 101, 71, 89, 144, 101, 237, 132, 160, 103, 39, 59, 144, 103, 205, 102, 160, 105, 7, 29, 144, 105, 173, 72, 160, 106, 230, 255, 144, 107, 150, 101, 32, 108, 208, 28, 16, 109, 118, 71, 32, 110, 175, 254, 16, 111, 86, 41, 32, 112, 143, 224, 16, 113, 54, 11, 32, 114, 111, 194, 16, 115, 21, 237, 32, 116, 79, 164, 16, 116, 255, 9, 160, 118, 56, 192, 144, 118, 222, 235, 160, 120, 24, 162, 144, 120, 190, 205, 160, 121, 248, 132, 144, 122, 158, 175, 160, 123, 216, 102, 144, 124, 126, 145, 160, 125, 184, 72, 144, 126, 94, 115, 160, 127, 152, 42, 144, 2, 1, 2, 1, 2, 3, 4, 2, 5, 2, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 255, 255, 125, 76, 0, 0, 255, 255, 143, 128, 1, 4, 255, 255, 129, 112, 0, 8, 255, 255, 143, 128, 1, 12, 255, 255, 143, 128, 1, 16, 255, 255, 157, 144, 1, 20, 255, 255, 143, 128, 0, 25, 255, 255, 157, 144, 1, 29, 76, 77, 84, 0, 89, 68, 84, 0, 89, 83, 84, 0, 89, 87, 84, 0, 89, 80, 84, 0, 89, 68, 68, 84, 0, 80, 83, 84, 0, 80, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 10, 80, 83, 84, 56, 80, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Dawson_Creek": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 58, 0, 0, 0, 6, 0, 0, 0, 24, 128, 0, 0, 0, 158, 184, 189, 160, 159, 187, 21, 144, 203, 137, 26, 160, 210, 35, 244, 112, 210, 97, 38, 16, 213, 85, 241, 32, 214, 32, 234, 16, 215, 53, 211, 32, 216, 0, 204, 16, 217, 21, 181, 32, 217, 224, 174, 16, 218, 254, 209, 160, 219, 192, 144, 16, 220, 222, 179, 160, 221, 169, 172, 144, 222, 190, 149, 160, 223, 137, 142, 144, 224, 158, 119, 160, 225, 105, 112, 144, 226, 126, 89, 160, 227, 73, 82, 144, 228, 94, 59, 160, 229, 41, 52, 144, 230, 71, 88, 32, 231, 18, 81, 16, 232, 39, 58, 32, 232, 242, 51, 16, 234, 7, 28, 32, 234, 210, 21, 16, 235, 230, 254, 32, 236, 177, 247, 16, 237, 198, 224, 32, 238, 145, 217, 16, 239, 175, 252, 160, 240, 113, 187, 16, 241, 143, 222, 160, 242, 127, 193, 144, 243, 111, 192, 160, 244, 95, 163, 144, 245, 79, 162, 160, 246, 63, 133, 144, 247, 47, 132, 160, 248, 40, 162, 16, 249, 15, 102, 160, 250, 8, 132, 16, 250, 248, 131, 32, 251, 232, 102, 16, 252, 216, 101, 32, 253, 200, 72, 16, 254, 184, 71, 32, 255, 168, 42, 16, 0, 152, 41, 32, 1, 136, 12, 16, 2, 120, 11, 32, 3, 113, 40, 144, 4, 97, 39, 160, 5, 1, 240, 144, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 5, 255, 255, 143, 72, 0, 0, 255, 255, 157, 144, 1, 4, 255, 255, 143, 128, 0, 8, 255, 255, 157, 144, 1, 12, 255, 255, 157, 144, 1, 16, 255, 255, 157, 144, 0, 20, 76, 77, 84, 0, 80, 68, 84, 0, 80, 83, 84, 0, 80, 87, 84, 0, 80, 80, 84, 0, 77, 83, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 10, 77, 83, 84, 55, 10}, - - "zoneinfo/America/Denver": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 158, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 158, 166, 58, 144, 159, 187, 7, 128, 160, 134, 28, 144, 161, 154, 233, 128, 162, 101, 254, 144, 163, 132, 6, 0, 164, 69, 224, 144, 164, 143, 166, 128, 203, 137, 12, 144, 210, 35, 244, 112, 210, 97, 24, 0, 247, 47, 118, 144, 248, 40, 148, 0, 249, 15, 88, 144, 250, 8, 118, 0, 250, 248, 117, 16, 251, 232, 88, 0, 252, 216, 87, 16, 253, 200, 58, 0, 254, 184, 57, 16, 255, 168, 28, 0, 0, 152, 27, 16, 1, 135, 254, 0, 2, 119, 253, 16, 3, 113, 26, 128, 4, 97, 25, 144, 5, 80, 252, 128, 6, 64, 251, 144, 7, 48, 222, 128, 7, 141, 53, 144, 9, 16, 192, 128, 9, 173, 177, 16, 10, 240, 162, 128, 11, 224, 161, 144, 12, 217, 191, 0, 13, 192, 131, 144, 14, 185, 161, 0, 15, 169, 160, 16, 16, 153, 131, 0, 17, 137, 130, 16, 18, 121, 101, 0, 19, 105, 100, 16, 20, 89, 71, 0, 21, 73, 70, 16, 22, 57, 41, 0, 23, 41, 40, 16, 24, 34, 69, 128, 25, 9, 10, 16, 26, 2, 39, 128, 26, 242, 38, 144, 27, 226, 9, 128, 28, 210, 8, 144, 29, 193, 235, 128, 30, 177, 234, 144, 31, 161, 205, 128, 32, 118, 29, 16, 33, 129, 175, 128, 34, 85, 255, 16, 35, 106, 204, 0, 36, 53, 225, 16, 37, 74, 174, 0, 38, 21, 195, 16, 39, 42, 144, 0, 39, 254, 223, 144, 41, 10, 114, 0, 41, 222, 193, 144, 42, 234, 84, 0, 43, 190, 163, 144, 44, 211, 112, 128, 45, 158, 133, 144, 46, 179, 82, 128, 47, 126, 103, 144, 48, 147, 52, 128, 49, 103, 132, 16, 50, 115, 22, 128, 51, 71, 102, 16, 52, 82, 248, 128, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 231, 12, 16, 57, 251, 217, 0, 58, 198, 238, 16, 59, 219, 187, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 206, 144, 65, 132, 155, 128, 66, 79, 176, 144, 67, 100, 125, 128, 68, 47, 146, 144, 69, 68, 95, 128, 69, 243, 197, 16, 71, 45, 124, 0, 71, 211, 167, 16, 73, 13, 94, 0, 73, 179, 137, 16, 74, 237, 64, 0, 75, 156, 165, 144, 76, 214, 92, 128, 77, 124, 135, 144, 78, 182, 62, 128, 79, 92, 105, 144, 80, 150, 32, 128, 81, 60, 75, 144, 82, 118, 2, 128, 83, 28, 45, 144, 84, 85, 228, 128, 84, 252, 15, 144, 86, 53, 198, 128, 86, 229, 44, 16, 88, 30, 227, 0, 88, 197, 14, 16, 89, 254, 197, 0, 90, 164, 240, 16, 91, 222, 167, 0, 92, 132, 210, 16, 93, 190, 137, 0, 94, 100, 180, 16, 95, 158, 107, 0, 96, 77, 208, 144, 97, 135, 135, 128, 98, 45, 178, 144, 99, 103, 105, 128, 100, 13, 148, 144, 101, 71, 75, 128, 101, 237, 118, 144, 103, 39, 45, 128, 103, 205, 88, 144, 105, 7, 15, 128, 105, 173, 58, 144, 106, 230, 241, 128, 107, 150, 87, 16, 108, 208, 14, 0, 109, 118, 57, 16, 110, 175, 240, 0, 111, 86, 27, 16, 112, 143, 210, 0, 113, 53, 253, 16, 114, 111, 180, 0, 115, 21, 223, 16, 116, 79, 150, 0, 116, 254, 251, 144, 118, 56, 178, 128, 118, 222, 221, 144, 120, 24, 148, 128, 120, 190, 191, 144, 121, 248, 118, 128, 122, 158, 161, 144, 123, 216, 88, 128, 124, 126, 131, 144, 125, 184, 58, 128, 126, 94, 101, 144, 127, 152, 28, 128, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 157, 148, 0, 0, 255, 255, 171, 160, 1, 4, 255, 255, 157, 144, 0, 8, 255, 255, 171, 160, 1, 12, 255, 255, 171, 160, 1, 16, 76, 77, 84, 0, 77, 68, 84, 0, 77, 83, 84, 0, 77, 87, 84, 0, 77, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 77, 83, 84, 55, 77, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Detroit": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 138, 0, 0, 0, 6, 0, 0, 0, 24, 128, 0, 0, 0, 133, 189, 34, 91, 153, 60, 148, 0, 203, 136, 240, 112, 210, 35, 244, 112, 210, 96, 251, 224, 215, 53, 168, 240, 216, 0, 161, 224, 6, 64, 223, 112, 7, 48, 194, 96, 7, 141, 25, 112, 9, 16, 164, 96, 10, 0, 163, 112, 10, 240, 134, 96, 11, 224, 133, 112, 12, 217, 162, 224, 13, 192, 103, 112, 14, 185, 132, 224, 15, 169, 131, 240, 16, 153, 102, 224, 17, 137, 101, 240, 18, 121, 72, 224, 19, 105, 71, 240, 20, 89, 42, 224, 21, 73, 41, 240, 22, 57, 12, 224, 23, 41, 11, 240, 24, 34, 41, 96, 25, 8, 237, 240, 26, 2, 11, 96, 26, 242, 10, 112, 27, 225, 237, 96, 28, 209, 236, 112, 29, 193, 207, 96, 30, 177, 206, 112, 31, 161, 177, 96, 32, 118, 0, 240, 33, 129, 147, 96, 34, 85, 226, 240, 35, 106, 175, 224, 36, 53, 196, 240, 37, 74, 145, 224, 38, 21, 166, 240, 39, 42, 115, 224, 39, 254, 195, 112, 41, 10, 85, 224, 41, 222, 165, 112, 42, 234, 55, 224, 43, 190, 135, 112, 44, 211, 84, 96, 45, 158, 105, 112, 46, 179, 54, 96, 47, 126, 75, 112, 48, 147, 24, 96, 49, 103, 103, 240, 50, 114, 250, 96, 51, 71, 73, 240, 52, 82, 220, 96, 53, 39, 43, 240, 54, 50, 190, 96, 55, 7, 13, 240, 56, 27, 218, 224, 56, 230, 239, 240, 57, 251, 188, 224, 58, 198, 209, 240, 59, 219, 158, 224, 60, 175, 238, 112, 61, 187, 128, 224, 62, 143, 208, 112, 63, 155, 98, 224, 64, 111, 178, 112, 65, 132, 127, 96, 66, 79, 148, 112, 67, 100, 97, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 0, 1, 2, 3, 4, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 255, 255, 178, 37, 0, 0, 255, 255, 171, 160, 0, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 1, 12, 255, 255, 199, 192, 1, 16, 255, 255, 199, 192, 1, 20, 76, 77, 84, 0, 67, 83, 84, 0, 69, 83, 84, 0, 69, 87, 84, 0, 69, 80, 84, 0, 69, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Dominica": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 147, 55, 51, 172, 0, 1, 255, 255, 198, 84, 0, 0, 255, 255, 199, 192, 0, 4, 76, 77, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Edmonton": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 155, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 136, 222, 206, 224, 158, 184, 175, 144, 159, 187, 7, 128, 160, 152, 145, 144, 160, 210, 133, 128, 162, 138, 232, 144, 163, 132, 6, 0, 164, 106, 202, 144, 165, 53, 195, 128, 166, 83, 231, 16, 167, 21, 165, 128, 168, 51, 201, 16, 168, 254, 194, 0, 203, 137, 12, 144, 210, 35, 244, 112, 210, 97, 24, 0, 213, 85, 227, 16, 214, 32, 220, 0, 250, 248, 117, 16, 251, 232, 88, 0, 254, 184, 57, 16, 255, 168, 28, 0, 4, 97, 25, 144, 5, 80, 252, 128, 6, 64, 251, 144, 7, 48, 222, 128, 8, 32, 221, 144, 9, 16, 192, 128, 10, 0, 191, 144, 10, 240, 162, 128, 11, 224, 161, 144, 12, 217, 191, 0, 13, 192, 131, 144, 14, 185, 161, 0, 15, 169, 160, 16, 16, 153, 131, 0, 17, 137, 130, 16, 18, 121, 101, 0, 19, 105, 100, 16, 20, 89, 71, 0, 21, 73, 70, 16, 22, 57, 41, 0, 23, 41, 40, 16, 24, 34, 69, 128, 25, 9, 10, 16, 26, 2, 39, 128, 26, 242, 38, 144, 27, 226, 9, 128, 28, 210, 8, 144, 29, 193, 235, 128, 30, 177, 234, 144, 31, 161, 205, 128, 32, 118, 29, 16, 33, 129, 175, 128, 34, 85, 255, 16, 35, 106, 204, 0, 36, 53, 225, 16, 37, 74, 174, 0, 38, 21, 195, 16, 39, 42, 144, 0, 39, 254, 223, 144, 41, 10, 114, 0, 41, 222, 193, 144, 42, 234, 84, 0, 43, 190, 163, 144, 44, 211, 112, 128, 45, 158, 133, 144, 46, 179, 82, 128, 47, 126, 103, 144, 48, 147, 52, 128, 49, 103, 132, 16, 50, 115, 22, 128, 51, 71, 102, 16, 52, 82, 248, 128, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 231, 12, 16, 57, 251, 217, 0, 58, 198, 238, 16, 59, 219, 187, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 206, 144, 65, 132, 155, 128, 66, 79, 176, 144, 67, 100, 125, 128, 68, 47, 146, 144, 69, 68, 95, 128, 69, 243, 197, 16, 71, 45, 124, 0, 71, 211, 167, 16, 73, 13, 94, 0, 73, 179, 137, 16, 74, 237, 64, 0, 75, 156, 165, 144, 76, 214, 92, 128, 77, 124, 135, 144, 78, 182, 62, 128, 79, 92, 105, 144, 80, 150, 32, 128, 81, 60, 75, 144, 82, 118, 2, 128, 83, 28, 45, 144, 84, 85, 228, 128, 84, 252, 15, 144, 86, 53, 198, 128, 86, 229, 44, 16, 88, 30, 227, 0, 88, 197, 14, 16, 89, 254, 197, 0, 90, 164, 240, 16, 91, 222, 167, 0, 92, 132, 210, 16, 93, 190, 137, 0, 94, 100, 180, 16, 95, 158, 107, 0, 96, 77, 208, 144, 97, 135, 135, 128, 98, 45, 178, 144, 99, 103, 105, 128, 100, 13, 148, 144, 101, 71, 75, 128, 101, 237, 118, 144, 103, 39, 45, 128, 103, 205, 88, 144, 105, 7, 15, 128, 105, 173, 58, 144, 106, 230, 241, 128, 107, 150, 87, 16, 108, 208, 14, 0, 109, 118, 57, 16, 110, 175, 240, 0, 111, 86, 27, 16, 112, 143, 210, 0, 113, 53, 253, 16, 114, 111, 180, 0, 115, 21, 223, 16, 116, 79, 150, 0, 116, 254, 251, 144, 118, 56, 178, 128, 118, 222, 221, 144, 120, 24, 148, 128, 120, 190, 191, 144, 121, 248, 118, 128, 122, 158, 161, 144, 123, 216, 88, 128, 124, 126, 131, 144, 125, 184, 58, 128, 126, 94, 101, 144, 127, 152, 28, 128, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 149, 160, 0, 0, 255, 255, 171, 160, 1, 4, 255, 255, 157, 144, 0, 8, 255, 255, 171, 160, 1, 12, 255, 255, 171, 160, 1, 16, 76, 77, 84, 0, 77, 68, 84, 0, 77, 83, 84, 0, 77, 87, 84, 0, 77, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 77, 83, 84, 55, 77, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Eirunepe": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 35, 0, 0, 0, 5, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 136, 128, 184, 15, 102, 0, 184, 253, 92, 192, 185, 241, 80, 80, 186, 222, 144, 64, 218, 56, 202, 80, 218, 236, 22, 80, 220, 25, 253, 208, 220, 185, 117, 64, 221, 251, 49, 80, 222, 155, 250, 64, 223, 221, 182, 80, 224, 84, 79, 64, 244, 152, 27, 208, 245, 5, 122, 64, 246, 192, 128, 80, 247, 14, 58, 192, 248, 81, 72, 80, 248, 199, 225, 64, 250, 10, 238, 208, 250, 169, 20, 192, 251, 236, 34, 80, 252, 139, 153, 192, 29, 201, 170, 80, 30, 120, 243, 192, 31, 160, 81, 208, 32, 51, 235, 192, 33, 129, 133, 80, 34, 11, 228, 192, 44, 192, 209, 80, 45, 102, 224, 64, 72, 96, 127, 80, 82, 127, 4, 192, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 2, 255, 255, 190, 128, 0, 0, 255, 255, 199, 192, 1, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 0, 4, 255, 255, 185, 176, 0, 8, 76, 77, 84, 0, 45, 48, 52, 0, 45, 48, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 53, 62, 53, 10}, - - "zoneinfo/America/El_Salvador": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 163, 213, 166, 32, 32, 154, 220, 224, 33, 92, 155, 80, 34, 122, 190, 224, 35, 60, 125, 80, 0, 2, 1, 2, 1, 2, 255, 255, 172, 96, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 54, 10}, - - "zoneinfo/America/Ensenada": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 150, 0, 0, 0, 6, 0, 0, 0, 24, 128, 0, 0, 0, 165, 182, 246, 128, 169, 121, 79, 112, 175, 242, 124, 240, 182, 102, 100, 112, 183, 27, 16, 0, 184, 10, 242, 240, 203, 234, 141, 128, 210, 35, 244, 112, 210, 153, 186, 112, 215, 27, 89, 0, 216, 145, 180, 240, 226, 126, 75, 144, 227, 73, 82, 144, 228, 94, 45, 144, 229, 41, 52, 144, 230, 71, 74, 16, 231, 18, 81, 16, 232, 39, 44, 16, 232, 242, 51, 16, 234, 7, 14, 16, 234, 210, 21, 16, 235, 230, 240, 16, 236, 177, 247, 16, 237, 198, 210, 16, 238, 145, 217, 16, 11, 224, 175, 160, 12, 217, 205, 16, 13, 192, 145, 160, 14, 185, 175, 16, 15, 169, 174, 32, 16, 153, 145, 16, 17, 137, 144, 32, 18, 121, 115, 16, 19, 105, 114, 32, 20, 89, 85, 16, 21, 73, 84, 32, 22, 57, 55, 16, 23, 41, 54, 32, 24, 34, 83, 144, 25, 9, 24, 32, 26, 2, 53, 144, 26, 242, 52, 160, 27, 226, 23, 144, 28, 210, 22, 160, 29, 193, 249, 144, 30, 177, 248, 160, 31, 161, 219, 144, 32, 118, 43, 32, 33, 129, 189, 144, 34, 86, 13, 32, 35, 106, 218, 16, 36, 53, 239, 32, 37, 74, 188, 16, 38, 21, 209, 32, 39, 42, 158, 16, 39, 254, 237, 160, 41, 10, 128, 16, 41, 222, 207, 160, 42, 234, 98, 16, 43, 190, 177, 160, 44, 211, 126, 144, 45, 158, 147, 160, 46, 179, 96, 144, 47, 126, 117, 160, 48, 147, 66, 144, 49, 103, 146, 32, 50, 115, 36, 144, 51, 71, 116, 32, 52, 83, 6, 144, 53, 39, 86, 32, 54, 50, 232, 144, 55, 7, 56, 32, 56, 28, 5, 16, 56, 231, 26, 32, 57, 251, 231, 16, 58, 198, 252, 32, 59, 219, 201, 16, 60, 176, 24, 160, 61, 187, 171, 16, 62, 143, 250, 160, 63, 155, 141, 16, 64, 111, 220, 160, 65, 132, 169, 144, 66, 79, 190, 160, 67, 100, 139, 144, 68, 47, 160, 160, 69, 68, 109, 144, 70, 15, 130, 160, 71, 36, 79, 144, 71, 248, 159, 32, 73, 4, 49, 144, 73, 216, 129, 32, 74, 228, 19, 144, 75, 156, 179, 160, 76, 214, 106, 144, 77, 124, 149, 160, 78, 182, 76, 144, 79, 92, 119, 160, 80, 150, 46, 144, 81, 60, 89, 160, 82, 118, 16, 144, 83, 28, 59, 160, 84, 85, 242, 144, 84, 252, 29, 160, 86, 53, 212, 144, 86, 229, 58, 32, 88, 30, 241, 16, 88, 197, 28, 32, 89, 254, 211, 16, 90, 164, 254, 32, 91, 222, 181, 16, 92, 132, 224, 32, 93, 190, 151, 16, 94, 100, 194, 32, 95, 158, 121, 16, 96, 77, 222, 160, 97, 135, 149, 144, 98, 45, 192, 160, 99, 103, 119, 144, 100, 13, 162, 160, 101, 71, 89, 144, 101, 237, 132, 160, 103, 39, 59, 144, 103, 205, 102, 160, 105, 7, 29, 144, 105, 173, 72, 160, 106, 230, 255, 144, 107, 150, 101, 32, 108, 208, 28, 16, 109, 118, 71, 32, 110, 175, 254, 16, 111, 86, 41, 32, 112, 143, 224, 16, 113, 54, 11, 32, 114, 111, 194, 16, 115, 21, 237, 32, 116, 79, 164, 16, 116, 255, 9, 160, 118, 56, 192, 144, 118, 222, 235, 160, 120, 24, 162, 144, 120, 190, 205, 160, 121, 248, 132, 144, 122, 158, 175, 160, 123, 216, 102, 144, 124, 126, 145, 160, 125, 184, 72, 144, 126, 94, 115, 160, 127, 152, 42, 144, 0, 1, 2, 1, 2, 3, 2, 4, 5, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 255, 255, 146, 76, 0, 0, 255, 255, 157, 144, 0, 4, 255, 255, 143, 128, 0, 8, 255, 255, 157, 144, 1, 12, 255, 255, 157, 144, 1, 16, 255, 255, 157, 144, 1, 20, 76, 77, 84, 0, 77, 83, 84, 0, 80, 83, 84, 0, 80, 68, 84, 0, 80, 87, 84, 0, 80, 80, 84, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 10, 80, 83, 84, 56, 80, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Fort_Nelson": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 143, 0, 0, 0, 6, 0, 0, 0, 24, 128, 0, 0, 0, 158, 184, 189, 160, 159, 187, 21, 144, 203, 137, 26, 160, 210, 35, 244, 112, 210, 97, 38, 16, 213, 85, 241, 32, 214, 32, 234, 16, 215, 53, 211, 32, 216, 0, 204, 16, 217, 21, 181, 32, 217, 224, 174, 16, 218, 254, 209, 160, 219, 192, 144, 16, 220, 222, 179, 160, 221, 169, 172, 144, 222, 190, 149, 160, 223, 137, 142, 144, 224, 158, 119, 160, 225, 105, 112, 144, 226, 126, 89, 160, 227, 73, 82, 144, 228, 94, 59, 160, 229, 41, 52, 144, 230, 71, 88, 32, 231, 18, 81, 16, 232, 39, 58, 32, 232, 242, 51, 16, 234, 7, 28, 32, 234, 210, 21, 16, 235, 230, 254, 32, 236, 177, 247, 16, 237, 198, 224, 32, 238, 145, 217, 16, 239, 175, 252, 160, 240, 113, 187, 16, 241, 143, 222, 160, 242, 127, 193, 144, 243, 111, 192, 160, 244, 95, 163, 144, 245, 79, 162, 160, 246, 63, 133, 144, 247, 47, 132, 160, 248, 40, 162, 16, 249, 15, 102, 160, 250, 8, 132, 16, 250, 248, 131, 32, 251, 232, 102, 16, 252, 216, 101, 32, 253, 200, 72, 16, 254, 184, 71, 32, 255, 168, 42, 16, 0, 152, 41, 32, 1, 136, 12, 16, 2, 120, 11, 32, 3, 113, 40, 144, 4, 97, 39, 160, 5, 81, 10, 144, 6, 65, 9, 160, 7, 48, 236, 144, 8, 32, 235, 160, 9, 16, 206, 144, 10, 0, 205, 160, 10, 240, 176, 144, 11, 224, 175, 160, 12, 217, 205, 16, 13, 192, 145, 160, 14, 185, 175, 16, 15, 169, 174, 32, 16, 153, 145, 16, 17, 137, 144, 32, 18, 121, 115, 16, 19, 105, 114, 32, 20, 89, 85, 16, 21, 73, 84, 32, 22, 57, 55, 16, 23, 41, 54, 32, 24, 34, 83, 144, 25, 9, 24, 32, 26, 2, 53, 144, 26, 242, 52, 160, 27, 226, 23, 144, 28, 210, 22, 160, 29, 193, 249, 144, 30, 177, 248, 160, 31, 161, 219, 144, 32, 118, 43, 32, 33, 129, 189, 144, 34, 86, 13, 32, 35, 106, 218, 16, 36, 53, 239, 32, 37, 74, 188, 16, 38, 21, 209, 32, 39, 42, 158, 16, 39, 254, 237, 160, 41, 10, 128, 16, 41, 222, 207, 160, 42, 234, 98, 16, 43, 190, 177, 160, 44, 211, 126, 144, 45, 158, 147, 160, 46, 179, 96, 144, 47, 126, 117, 160, 48, 147, 66, 144, 49, 103, 146, 32, 50, 115, 36, 144, 51, 71, 116, 32, 52, 83, 6, 144, 53, 39, 86, 32, 54, 50, 232, 144, 55, 7, 56, 32, 56, 28, 5, 16, 56, 231, 26, 32, 57, 251, 231, 16, 58, 198, 252, 32, 59, 219, 201, 16, 60, 176, 24, 160, 61, 187, 171, 16, 62, 143, 250, 160, 63, 155, 141, 16, 64, 111, 220, 160, 65, 132, 169, 144, 66, 79, 190, 160, 67, 100, 139, 144, 68, 47, 160, 160, 69, 68, 109, 144, 69, 243, 211, 32, 71, 45, 138, 16, 71, 211, 181, 32, 73, 13, 108, 16, 73, 179, 151, 32, 74, 237, 78, 16, 75, 156, 179, 160, 76, 214, 106, 144, 77, 124, 149, 160, 78, 182, 76, 144, 79, 92, 119, 160, 80, 150, 46, 144, 81, 60, 89, 160, 82, 118, 16, 144, 83, 28, 59, 160, 84, 85, 242, 144, 84, 252, 29, 160, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 255, 255, 140, 249, 0, 0, 255, 255, 157, 144, 1, 4, 255, 255, 143, 128, 0, 8, 255, 255, 157, 144, 1, 12, 255, 255, 157, 144, 1, 16, 255, 255, 157, 144, 0, 20, 76, 77, 84, 0, 80, 68, 84, 0, 80, 83, 84, 0, 80, 87, 84, 0, 80, 80, 84, 0, 77, 83, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 10, 77, 83, 84, 55, 10}, - - "zoneinfo/America/Fort_Wayne": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 99, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 202, 87, 34, 128, 202, 216, 71, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 211, 117, 243, 0, 212, 64, 235, 240, 213, 85, 213, 0, 214, 32, 205, 240, 215, 53, 183, 0, 216, 0, 175, 240, 217, 21, 153, 0, 217, 224, 145, 240, 218, 254, 181, 128, 219, 192, 115, 240, 220, 222, 151, 128, 221, 169, 144, 112, 222, 190, 121, 128, 223, 137, 114, 112, 224, 158, 91, 128, 225, 105, 84, 112, 226, 126, 61, 128, 227, 73, 54, 112, 228, 94, 31, 128, 232, 242, 22, 240, 234, 7, 0, 0, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 255, 255, 175, 58, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 255, 255, 199, 192, 1, 24, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 69, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Fortaleza": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 107, 24, 184, 15, 73, 224, 184, 253, 64, 160, 185, 241, 52, 48, 186, 222, 116, 32, 218, 56, 174, 48, 218, 235, 250, 48, 220, 25, 225, 176, 220, 185, 89, 32, 221, 251, 21, 48, 222, 155, 222, 32, 223, 221, 154, 48, 224, 84, 51, 32, 244, 151, 255, 176, 245, 5, 94, 32, 246, 192, 100, 48, 247, 14, 30, 160, 248, 81, 44, 48, 248, 199, 197, 32, 250, 10, 210, 176, 250, 168, 248, 160, 251, 236, 6, 48, 252, 139, 125, 160, 29, 201, 142, 48, 30, 120, 215, 160, 31, 160, 53, 176, 32, 51, 207, 160, 33, 129, 105, 48, 34, 11, 200, 160, 35, 88, 16, 176, 35, 226, 112, 32, 37, 55, 242, 176, 37, 212, 199, 32, 55, 246, 198, 176, 56, 184, 133, 32, 57, 223, 227, 48, 57, 242, 74, 32, 59, 200, 255, 176, 60, 111, 14, 160, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 255, 255, 219, 232, 0, 0, 255, 255, 227, 224, 1, 4, 255, 255, 213, 208, 0, 8, 76, 77, 84, 0, 45, 48, 50, 0, 45, 48, 51, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Glace_Bay": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 141, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 128, 241, 168, 52, 158, 184, 133, 96, 159, 186, 221, 80, 203, 136, 226, 96, 210, 35, 244, 112, 210, 96, 237, 208, 224, 158, 63, 96, 225, 105, 56, 80, 4, 96, 239, 96, 5, 80, 210, 80, 6, 64, 209, 96, 7, 48, 180, 80, 8, 32, 179, 96, 9, 16, 150, 80, 10, 0, 149, 96, 10, 240, 120, 80, 11, 224, 119, 96, 12, 217, 148, 208, 13, 192, 89, 96, 14, 185, 118, 208, 15, 169, 117, 224, 16, 153, 88, 208, 17, 137, 87, 224, 18, 121, 58, 208, 19, 105, 57, 224, 20, 89, 28, 208, 21, 73, 27, 224, 22, 56, 254, 208, 23, 40, 253, 224, 24, 34, 27, 80, 25, 8, 223, 224, 26, 1, 253, 80, 26, 241, 252, 96, 27, 225, 223, 80, 28, 209, 222, 96, 29, 193, 193, 80, 30, 177, 192, 96, 31, 161, 163, 80, 32, 117, 242, 224, 33, 129, 133, 80, 34, 85, 212, 224, 35, 106, 161, 208, 36, 53, 182, 224, 37, 74, 131, 208, 38, 21, 152, 224, 39, 42, 101, 208, 39, 254, 181, 96, 41, 10, 71, 208, 41, 222, 151, 96, 42, 234, 41, 208, 43, 190, 121, 96, 44, 211, 70, 80, 45, 158, 91, 96, 46, 179, 40, 80, 47, 126, 61, 96, 48, 147, 10, 80, 49, 103, 89, 224, 50, 114, 236, 80, 51, 71, 59, 224, 52, 82, 206, 80, 53, 39, 29, 224, 54, 50, 176, 80, 55, 6, 255, 224, 56, 27, 204, 208, 56, 230, 225, 224, 57, 251, 174, 208, 58, 198, 195, 224, 59, 219, 144, 208, 60, 175, 224, 96, 61, 187, 114, 208, 62, 143, 194, 96, 63, 155, 84, 208, 64, 111, 164, 96, 65, 132, 113, 80, 66, 79, 134, 96, 67, 100, 83, 80, 68, 47, 104, 96, 69, 68, 53, 80, 69, 243, 154, 224, 71, 45, 81, 208, 71, 211, 124, 224, 73, 13, 51, 208, 73, 179, 94, 224, 74, 237, 21, 208, 75, 156, 123, 96, 76, 214, 50, 80, 77, 124, 93, 96, 78, 182, 20, 80, 79, 92, 63, 96, 80, 149, 246, 80, 81, 60, 33, 96, 82, 117, 216, 80, 83, 28, 3, 96, 84, 85, 186, 80, 84, 251, 229, 96, 86, 53, 156, 80, 86, 229, 1, 224, 88, 30, 184, 208, 88, 196, 227, 224, 89, 254, 154, 208, 90, 164, 197, 224, 91, 222, 124, 208, 92, 132, 167, 224, 93, 190, 94, 208, 94, 100, 137, 224, 95, 158, 64, 208, 96, 77, 166, 96, 97, 135, 93, 80, 98, 45, 136, 96, 99, 103, 63, 80, 100, 13, 106, 96, 101, 71, 33, 80, 101, 237, 76, 96, 103, 39, 3, 80, 103, 205, 46, 96, 105, 6, 229, 80, 105, 173, 16, 96, 106, 230, 199, 80, 107, 150, 44, 224, 108, 207, 227, 208, 109, 118, 14, 224, 110, 175, 197, 208, 111, 85, 240, 224, 112, 143, 167, 208, 113, 53, 210, 224, 114, 111, 137, 208, 115, 21, 180, 224, 116, 79, 107, 208, 116, 254, 209, 96, 118, 56, 136, 80, 118, 222, 179, 96, 120, 24, 106, 80, 120, 190, 149, 96, 121, 248, 76, 80, 122, 158, 119, 96, 123, 216, 46, 80, 124, 126, 89, 96, 125, 184, 16, 80, 126, 94, 59, 96, 127, 151, 242, 80, 0, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 199, 204, 0, 0, 255, 255, 213, 208, 1, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 213, 208, 1, 16, 76, 77, 84, 0, 65, 68, 84, 0, 65, 83, 84, 0, 65, 87, 84, 0, 65, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 65, 83, 84, 52, 65, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Godthab": []byte{84, 90, 105, 102, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 119, 0, 0, 0, 5, 0, 0, 0, 12, 128, 0, 0, 0, 155, 128, 104, 0, 19, 77, 124, 80, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 127, 255, 255, 255, 0, 1, 4, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 2, 255, 255, 207, 128, 0, 0, 255, 255, 213, 208, 0, 4, 255, 255, 213, 208, 0, 4, 255, 255, 227, 224, 1, 8, 255, 255, 227, 224, 1, 8, 76, 77, 84, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 10, 60, 45, 48, 51, 62, 51, 60, 45, 48, 50, 62, 44, 77, 51, 46, 53, 46, 48, 47, 45, 50, 44, 77, 49, 48, 46, 53, 46, 48, 47, 45, 49, 10}, - - "zoneinfo/America/Goose_Bay": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 204, 0, 0, 0, 11, 0, 0, 0, 33, 128, 0, 0, 0, 158, 184, 126, 140, 159, 186, 214, 124, 190, 158, 77, 108, 192, 184, 49, 56, 193, 121, 239, 168, 194, 152, 19, 56, 195, 89, 209, 168, 196, 119, 245, 56, 197, 57, 179, 168, 198, 97, 17, 184, 199, 25, 149, 168, 200, 64, 243, 184, 201, 2, 178, 40, 202, 32, 213, 184, 202, 226, 148, 40, 204, 0, 183, 184, 210, 35, 244, 112, 210, 96, 230, 200, 211, 136, 68, 216, 212, 74, 3, 72, 213, 104, 38, 216, 214, 41, 229, 72, 215, 72, 8, 216, 216, 9, 199, 72, 217, 39, 234, 216, 217, 233, 169, 72, 219, 17, 7, 88, 219, 210, 197, 200, 220, 222, 116, 88, 221, 169, 109, 72, 222, 190, 86, 88, 223, 137, 79, 72, 224, 158, 56, 88, 225, 105, 49, 72, 226, 126, 26, 88, 227, 73, 19, 72, 228, 93, 252, 88, 229, 40, 245, 72, 230, 71, 24, 216, 231, 18, 17, 200, 232, 38, 250, 216, 232, 241, 243, 200, 234, 6, 220, 216, 234, 209, 213, 200, 235, 230, 190, 216, 236, 177, 183, 200, 237, 198, 160, 216, 238, 191, 190, 72, 239, 175, 189, 88, 240, 159, 160, 72, 241, 143, 159, 88, 242, 127, 130, 72, 243, 111, 129, 88, 244, 95, 100, 72, 245, 79, 99, 88, 246, 63, 70, 72, 247, 47, 69, 88, 248, 40, 98, 200, 248, 218, 107, 88, 249, 15, 46, 96, 250, 8, 75, 208, 250, 248, 74, 224, 251, 232, 45, 208, 252, 216, 44, 224, 253, 200, 15, 208, 254, 184, 14, 224, 255, 167, 241, 208, 0, 151, 240, 224, 1, 135, 211, 208, 2, 119, 210, 224, 3, 112, 240, 80, 4, 96, 239, 96, 5, 80, 210, 80, 6, 64, 209, 96, 7, 48, 180, 80, 8, 32, 179, 96, 9, 16, 150, 80, 10, 0, 149, 96, 10, 240, 120, 80, 11, 224, 119, 96, 12, 217, 148, 208, 13, 192, 89, 96, 14, 185, 118, 208, 15, 169, 117, 224, 16, 153, 88, 208, 17, 137, 87, 224, 18, 121, 58, 208, 19, 105, 57, 224, 20, 89, 28, 208, 21, 73, 27, 224, 22, 56, 254, 208, 23, 40, 253, 224, 24, 34, 27, 80, 25, 8, 223, 224, 26, 1, 253, 80, 26, 241, 252, 96, 27, 225, 223, 80, 28, 209, 222, 96, 29, 193, 193, 80, 30, 177, 192, 96, 31, 161, 163, 80, 32, 117, 214, 252, 33, 129, 105, 108, 34, 85, 184, 252, 35, 106, 119, 220, 36, 53, 154, 252, 37, 74, 103, 236, 38, 21, 124, 252, 39, 42, 73, 236, 39, 254, 153, 124, 41, 10, 43, 236, 41, 222, 123, 124, 42, 234, 13, 236, 43, 190, 93, 124, 44, 211, 42, 108, 45, 158, 63, 124, 46, 179, 12, 108, 47, 126, 33, 124, 48, 146, 238, 108, 49, 103, 61, 252, 50, 114, 208, 108, 51, 71, 31, 252, 52, 82, 178, 108, 53, 39, 1, 252, 54, 50, 148, 108, 55, 6, 227, 252, 56, 27, 176, 236, 56, 230, 197, 252, 57, 251, 146, 236, 58, 198, 167, 252, 59, 219, 116, 236, 60, 175, 196, 124, 61, 187, 86, 236, 62, 143, 166, 124, 63, 155, 56, 236, 64, 111, 136, 124, 65, 132, 85, 108, 66, 79, 106, 124, 67, 100, 55, 108, 68, 47, 76, 124, 69, 68, 25, 108, 69, 243, 126, 252, 71, 45, 53, 236, 71, 211, 96, 252, 73, 13, 23, 236, 73, 179, 66, 252, 74, 236, 249, 236, 75, 156, 95, 124, 76, 214, 22, 108, 77, 124, 65, 124, 78, 182, 20, 80, 79, 92, 63, 96, 80, 149, 246, 80, 81, 60, 33, 96, 82, 117, 216, 80, 83, 28, 3, 96, 84, 85, 186, 80, 84, 251, 229, 96, 86, 53, 156, 80, 86, 229, 1, 224, 88, 30, 184, 208, 88, 196, 227, 224, 89, 254, 154, 208, 90, 164, 197, 224, 91, 222, 124, 208, 92, 132, 167, 224, 93, 190, 94, 208, 94, 100, 137, 224, 95, 158, 64, 208, 96, 77, 166, 96, 97, 135, 93, 80, 98, 45, 136, 96, 99, 103, 63, 80, 100, 13, 106, 96, 101, 71, 33, 80, 101, 237, 76, 96, 103, 39, 3, 80, 103, 205, 46, 96, 105, 6, 229, 80, 105, 173, 16, 96, 106, 230, 199, 80, 107, 150, 44, 224, 108, 207, 227, 208, 109, 118, 14, 224, 110, 175, 197, 208, 111, 85, 240, 224, 112, 143, 167, 208, 113, 53, 210, 224, 114, 111, 137, 208, 115, 21, 180, 224, 116, 79, 107, 208, 116, 254, 209, 96, 118, 56, 136, 80, 118, 222, 179, 96, 120, 24, 106, 80, 120, 190, 149, 96, 121, 248, 76, 80, 122, 158, 119, 96, 123, 216, 46, 80, 124, 126, 89, 96, 125, 184, 16, 80, 126, 94, 59, 96, 127, 151, 242, 80, 1, 2, 1, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 6, 5, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 9, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 255, 255, 199, 92, 0, 0, 255, 255, 206, 148, 0, 4, 255, 255, 220, 164, 1, 8, 255, 255, 206, 200, 0, 4, 255, 255, 220, 216, 1, 8, 255, 255, 220, 216, 1, 12, 255, 255, 220, 216, 1, 16, 255, 255, 213, 208, 1, 20, 255, 255, 199, 192, 0, 24, 255, 255, 227, 224, 1, 28, 255, 255, 213, 208, 1, 20, 76, 77, 84, 0, 78, 83, 84, 0, 78, 68, 84, 0, 78, 80, 84, 0, 78, 87, 84, 0, 65, 68, 84, 0, 65, 83, 84, 0, 65, 68, 68, 84, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 65, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Grand_Turk": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 116, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 147, 15, 180, 255, 17, 137, 101, 240, 18, 121, 72, 224, 19, 105, 71, 240, 20, 89, 42, 224, 21, 73, 41, 240, 22, 57, 12, 224, 23, 41, 11, 240, 24, 34, 41, 96, 25, 8, 237, 240, 26, 2, 11, 96, 26, 242, 10, 112, 27, 225, 237, 96, 28, 209, 236, 112, 29, 193, 207, 96, 30, 177, 206, 112, 31, 161, 177, 96, 32, 118, 0, 240, 33, 129, 147, 96, 34, 85, 226, 240, 35, 106, 175, 224, 36, 53, 196, 240, 37, 74, 145, 224, 38, 21, 166, 240, 39, 42, 115, 224, 39, 254, 195, 112, 41, 10, 85, 224, 41, 222, 165, 112, 42, 234, 55, 224, 43, 190, 135, 112, 44, 211, 84, 96, 45, 158, 105, 112, 46, 179, 54, 96, 47, 126, 75, 112, 48, 147, 24, 96, 49, 103, 103, 240, 50, 114, 250, 96, 51, 71, 73, 240, 52, 82, 220, 96, 53, 39, 43, 240, 54, 50, 190, 96, 55, 7, 13, 240, 56, 27, 218, 224, 56, 230, 239, 240, 57, 251, 188, 224, 58, 198, 209, 240, 59, 219, 158, 224, 60, 175, 238, 112, 61, 187, 128, 224, 62, 143, 208, 112, 63, 155, 98, 224, 64, 111, 178, 112, 65, 132, 127, 96, 66, 79, 148, 112, 67, 100, 97, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 4, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 255, 255, 189, 80, 0, 0, 255, 255, 184, 1, 0, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 1, 12, 255, 255, 199, 192, 0, 16, 255, 255, 185, 176, 0, 8, 76, 77, 84, 0, 75, 77, 84, 0, 69, 83, 84, 0, 69, 68, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Grenada": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 147, 55, 51, 172, 0, 1, 255, 255, 198, 84, 0, 0, 255, 255, 199, 192, 0, 4, 76, 77, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Guadeloupe": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 147, 55, 51, 172, 0, 1, 255, 255, 198, 84, 0, 0, 255, 255, 199, 192, 0, 4, 76, 77, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Guatemala": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 159, 157, 234, 220, 7, 85, 172, 96, 7, 205, 150, 208, 25, 44, 120, 96, 25, 207, 228, 80, 39, 234, 238, 224, 40, 200, 92, 208, 68, 84, 82, 96, 69, 31, 75, 80, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 171, 36, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 54, 10}, - - "zoneinfo/America/Guayaquil": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 4, 0, 0, 0, 16, 128, 0, 0, 0, 182, 164, 66, 24, 43, 22, 252, 208, 43, 113, 230, 64, 127, 255, 255, 255, 1, 3, 2, 3, 3, 255, 255, 181, 40, 0, 0, 255, 255, 182, 104, 0, 4, 255, 255, 199, 192, 1, 8, 255, 255, 185, 176, 0, 12, 76, 77, 84, 0, 81, 77, 84, 0, 45, 48, 52, 0, 45, 48, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 53, 62, 53, 10}, - - "zoneinfo/America/Guyana": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 4, 0, 0, 0, 18, 128, 0, 0, 0, 152, 217, 121, 136, 10, 125, 180, 60, 39, 127, 251, 48, 127, 255, 255, 255, 0, 1, 2, 3, 3, 255, 255, 201, 120, 0, 0, 255, 255, 203, 68, 0, 4, 255, 255, 213, 208, 0, 10, 255, 255, 199, 192, 0, 14, 76, 77, 84, 0, 45, 48, 51, 52, 53, 0, 45, 48, 51, 0, 45, 48, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 52, 62, 52, 10}, - - "zoneinfo/America/Halifax": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 229, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 128, 241, 171, 160, 154, 228, 222, 192, 155, 214, 19, 48, 158, 184, 133, 96, 159, 186, 221, 80, 162, 157, 23, 64, 163, 48, 177, 48, 164, 122, 86, 64, 165, 27, 31, 48, 166, 83, 160, 192, 166, 252, 82, 176, 168, 60, 189, 64, 168, 220, 52, 176, 170, 28, 159, 64, 170, 205, 58, 48, 171, 252, 129, 64, 172, 191, 145, 48, 173, 238, 216, 64, 174, 140, 254, 48, 175, 188, 69, 64, 176, 127, 85, 48, 177, 174, 156, 64, 178, 75, 112, 176, 179, 142, 126, 64, 180, 36, 187, 48, 181, 110, 96, 64, 182, 21, 192, 176, 183, 78, 66, 64, 184, 8, 23, 176, 185, 36, 233, 192, 185, 231, 249, 176, 187, 4, 203, 192, 187, 209, 22, 48, 189, 0, 93, 64, 189, 157, 49, 176, 190, 242, 180, 64, 191, 144, 218, 48, 192, 211, 231, 192, 193, 94, 71, 48, 194, 141, 142, 64, 195, 80, 158, 48, 196, 109, 112, 64, 197, 48, 128, 48, 198, 114, 60, 64, 199, 16, 98, 48, 200, 54, 110, 192, 200, 249, 126, 176, 202, 22, 80, 192, 202, 217, 96, 176, 203, 136, 226, 96, 210, 35, 244, 112, 210, 96, 237, 208, 211, 117, 214, 224, 212, 64, 207, 208, 213, 85, 184, 224, 214, 32, 177, 208, 215, 53, 154, 224, 216, 0, 147, 208, 217, 21, 124, 224, 217, 224, 117, 208, 220, 222, 123, 96, 221, 169, 116, 80, 222, 190, 93, 96, 223, 137, 86, 80, 224, 158, 63, 96, 225, 105, 56, 80, 226, 126, 33, 96, 227, 73, 26, 80, 230, 71, 31, 224, 231, 18, 24, 208, 232, 39, 1, 224, 232, 241, 250, 208, 234, 6, 227, 224, 234, 209, 220, 208, 235, 230, 197, 224, 236, 177, 190, 208, 241, 143, 166, 96, 242, 127, 137, 80, 243, 111, 136, 96, 244, 95, 107, 80, 245, 79, 106, 96, 246, 63, 77, 80, 247, 47, 76, 96, 248, 40, 105, 208, 249, 15, 46, 96, 250, 8, 75, 208, 250, 248, 74, 224, 251, 232, 45, 208, 252, 216, 44, 224, 253, 200, 15, 208, 254, 184, 14, 224, 255, 167, 241, 208, 0, 151, 240, 224, 1, 135, 211, 208, 2, 119, 210, 224, 3, 112, 240, 80, 4, 96, 239, 96, 5, 80, 210, 80, 6, 64, 209, 96, 7, 48, 180, 80, 8, 32, 179, 96, 9, 16, 150, 80, 10, 0, 149, 96, 10, 240, 120, 80, 11, 224, 119, 96, 12, 217, 148, 208, 13, 192, 89, 96, 14, 185, 118, 208, 15, 169, 117, 224, 16, 153, 88, 208, 17, 137, 87, 224, 18, 121, 58, 208, 19, 105, 57, 224, 20, 89, 28, 208, 21, 73, 27, 224, 22, 56, 254, 208, 23, 40, 253, 224, 24, 34, 27, 80, 25, 8, 223, 224, 26, 1, 253, 80, 26, 241, 252, 96, 27, 225, 223, 80, 28, 209, 222, 96, 29, 193, 193, 80, 30, 177, 192, 96, 31, 161, 163, 80, 32, 117, 242, 224, 33, 129, 133, 80, 34, 85, 212, 224, 35, 106, 161, 208, 36, 53, 182, 224, 37, 74, 131, 208, 38, 21, 152, 224, 39, 42, 101, 208, 39, 254, 181, 96, 41, 10, 71, 208, 41, 222, 151, 96, 42, 234, 41, 208, 43, 190, 121, 96, 44, 211, 70, 80, 45, 158, 91, 96, 46, 179, 40, 80, 47, 126, 61, 96, 48, 147, 10, 80, 49, 103, 89, 224, 50, 114, 236, 80, 51, 71, 59, 224, 52, 82, 206, 80, 53, 39, 29, 224, 54, 50, 176, 80, 55, 6, 255, 224, 56, 27, 204, 208, 56, 230, 225, 224, 57, 251, 174, 208, 58, 198, 195, 224, 59, 219, 144, 208, 60, 175, 224, 96, 61, 187, 114, 208, 62, 143, 194, 96, 63, 155, 84, 208, 64, 111, 164, 96, 65, 132, 113, 80, 66, 79, 134, 96, 67, 100, 83, 80, 68, 47, 104, 96, 69, 68, 53, 80, 69, 243, 154, 224, 71, 45, 81, 208, 71, 211, 124, 224, 73, 13, 51, 208, 73, 179, 94, 224, 74, 237, 21, 208, 75, 156, 123, 96, 76, 214, 50, 80, 77, 124, 93, 96, 78, 182, 20, 80, 79, 92, 63, 96, 80, 149, 246, 80, 81, 60, 33, 96, 82, 117, 216, 80, 83, 28, 3, 96, 84, 85, 186, 80, 84, 251, 229, 96, 86, 53, 156, 80, 86, 229, 1, 224, 88, 30, 184, 208, 88, 196, 227, 224, 89, 254, 154, 208, 90, 164, 197, 224, 91, 222, 124, 208, 92, 132, 167, 224, 93, 190, 94, 208, 94, 100, 137, 224, 95, 158, 64, 208, 96, 77, 166, 96, 97, 135, 93, 80, 98, 45, 136, 96, 99, 103, 63, 80, 100, 13, 106, 96, 101, 71, 33, 80, 101, 237, 76, 96, 103, 39, 3, 80, 103, 205, 46, 96, 105, 6, 229, 80, 105, 173, 16, 96, 106, 230, 199, 80, 107, 150, 44, 224, 108, 207, 227, 208, 109, 118, 14, 224, 110, 175, 197, 208, 111, 85, 240, 224, 112, 143, 167, 208, 113, 53, 210, 224, 114, 111, 137, 208, 115, 21, 180, 224, 116, 79, 107, 208, 116, 254, 209, 96, 118, 56, 136, 80, 118, 222, 179, 96, 120, 24, 106, 80, 120, 190, 149, 96, 121, 248, 76, 80, 122, 158, 119, 96, 123, 216, 46, 80, 124, 126, 89, 96, 125, 184, 16, 80, 126, 94, 59, 96, 127, 151, 242, 80, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 196, 96, 0, 0, 255, 255, 213, 208, 1, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 213, 208, 1, 16, 76, 77, 84, 0, 65, 68, 84, 0, 65, 83, 84, 0, 65, 87, 84, 0, 65, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 65, 83, 84, 52, 65, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Havana": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, 0, 6, 0, 0, 0, 16, 128, 0, 0, 0, 172, 98, 194, 128, 177, 211, 148, 80, 178, 116, 93, 64, 200, 91, 102, 208, 200, 211, 81, 64, 202, 59, 72, 208, 202, 188, 109, 192, 204, 36, 101, 80, 204, 156, 79, 192, 209, 196, 11, 80, 210, 59, 245, 192, 211, 163, 237, 80, 212, 27, 215, 192, 247, 96, 5, 208, 247, 255, 125, 64, 249, 61, 68, 208, 249, 227, 83, 192, 250, 219, 59, 208, 251, 167, 134, 64, 252, 197, 169, 208, 253, 135, 104, 64, 254, 184, 0, 208, 255, 167, 227, 192, 0, 151, 226, 208, 1, 135, 197, 192, 2, 119, 196, 208, 3, 112, 226, 64, 4, 96, 225, 80, 5, 53, 20, 192, 6, 64, 195, 80, 7, 22, 72, 64, 8, 32, 165, 80, 8, 247, 123, 192, 10, 0, 135, 80, 10, 240, 106, 64, 11, 224, 105, 80, 12, 217, 134, 192, 13, 192, 75, 80, 14, 185, 104, 192, 15, 178, 162, 80, 16, 125, 155, 64, 17, 81, 234, 208, 18, 102, 183, 192, 19, 49, 204, 208, 20, 70, 153, 192, 21, 91, 130, 208, 22, 38, 123, 192, 23, 59, 100, 208, 24, 6, 93, 192, 25, 27, 70, 208, 25, 230, 63, 192, 26, 251, 40, 208, 27, 207, 92, 64, 28, 219, 10, 208, 29, 175, 62, 64, 30, 122, 83, 80, 31, 143, 32, 64, 32, 90, 53, 80, 33, 111, 2, 64, 34, 67, 81, 208, 35, 78, 228, 64, 36, 35, 51, 208, 37, 46, 198, 64, 38, 21, 138, 208, 39, 23, 226, 192, 39, 254, 167, 80, 40, 247, 210, 208, 41, 222, 137, 80, 42, 215, 180, 208, 43, 190, 107, 80, 44, 183, 150, 208, 45, 158, 77, 80, 46, 151, 120, 208, 47, 126, 47, 80, 48, 119, 90, 208, 49, 103, 75, 208, 50, 87, 60, 208, 51, 71, 45, 208, 52, 64, 89, 80, 53, 29, 213, 80, 54, 50, 176, 80, 54, 253, 183, 80, 56, 27, 204, 208, 56, 230, 211, 208, 57, 251, 174, 208, 58, 198, 181, 208, 59, 219, 144, 208, 60, 175, 210, 80, 61, 187, 114, 208, 62, 143, 180, 80, 63, 155, 84, 208, 64, 102, 91, 208, 69, 68, 53, 80, 69, 243, 140, 208, 71, 36, 23, 80, 71, 220, 169, 80, 73, 3, 249, 80, 73, 179, 80, 208, 74, 227, 219, 80, 75, 156, 109, 80, 76, 204, 247, 208, 77, 133, 137, 208, 78, 191, 78, 208, 79, 119, 224, 208, 80, 149, 246, 80, 81, 60, 19, 80, 82, 117, 216, 80, 83, 27, 245, 80, 84, 85, 186, 80, 84, 251, 215, 80, 86, 53, 156, 80, 86, 228, 243, 208, 88, 30, 184, 208, 88, 196, 213, 208, 89, 254, 154, 208, 90, 164, 183, 208, 91, 222, 124, 208, 92, 132, 153, 208, 93, 190, 94, 208, 94, 100, 123, 208, 95, 158, 64, 208, 96, 77, 152, 80, 97, 135, 93, 80, 98, 45, 122, 80, 99, 103, 63, 80, 100, 13, 92, 80, 101, 71, 33, 80, 101, 237, 62, 80, 103, 39, 3, 80, 103, 205, 32, 80, 105, 6, 229, 80, 105, 173, 2, 80, 106, 230, 199, 80, 107, 150, 30, 208, 108, 207, 227, 208, 109, 118, 0, 208, 110, 175, 197, 208, 111, 85, 226, 208, 112, 143, 167, 208, 113, 53, 196, 208, 114, 111, 137, 208, 115, 21, 166, 208, 116, 79, 107, 208, 116, 254, 195, 80, 118, 56, 136, 80, 118, 222, 165, 80, 120, 24, 106, 80, 120, 190, 135, 80, 121, 248, 76, 80, 122, 158, 105, 80, 123, 216, 46, 80, 124, 126, 75, 80, 125, 184, 16, 80, 126, 94, 45, 80, 127, 151, 242, 80, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 255, 255, 178, 200, 0, 0, 255, 255, 178, 192, 0, 4, 255, 255, 199, 192, 1, 8, 255, 255, 185, 176, 0, 12, 255, 255, 185, 176, 0, 12, 255, 255, 199, 192, 1, 8, 76, 77, 84, 0, 72, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 53, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 47, 48, 44, 77, 49, 49, 46, 49, 46, 48, 47, 49, 10}, - - "zoneinfo/America/Hermosillo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 165, 182, 232, 112, 175, 242, 110, 224, 182, 102, 86, 96, 183, 67, 210, 96, 184, 12, 54, 96, 184, 253, 134, 240, 203, 234, 113, 96, 216, 145, 180, 240, 0, 0, 112, 128, 49, 103, 132, 16, 50, 115, 22, 128, 51, 71, 102, 16, 52, 82, 248, 128, 53, 39, 72, 16, 54, 50, 218, 128, 0, 1, 2, 1, 2, 1, 2, 1, 3, 1, 4, 1, 4, 1, 4, 1, 255, 255, 151, 248, 0, 0, 255, 255, 157, 144, 0, 4, 255, 255, 171, 160, 0, 8, 255, 255, 143, 128, 0, 12, 255, 255, 171, 160, 1, 16, 255, 255, 157, 144, 0, 4, 76, 77, 84, 0, 77, 83, 84, 0, 67, 83, 84, 0, 80, 83, 84, 0, 77, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 77, 83, 84, 55, 10}, - - "zoneinfo/America/Indiana/Indianapolis": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 99, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 202, 87, 34, 128, 202, 216, 71, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 211, 117, 243, 0, 212, 64, 235, 240, 213, 85, 213, 0, 214, 32, 205, 240, 215, 53, 183, 0, 216, 0, 175, 240, 217, 21, 153, 0, 217, 224, 145, 240, 218, 254, 181, 128, 219, 192, 115, 240, 220, 222, 151, 128, 221, 169, 144, 112, 222, 190, 121, 128, 223, 137, 114, 112, 224, 158, 91, 128, 225, 105, 84, 112, 226, 126, 61, 128, 227, 73, 54, 112, 228, 94, 31, 128, 232, 242, 22, 240, 234, 7, 0, 0, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 255, 255, 175, 58, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 255, 255, 199, 192, 1, 24, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 69, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Indiana/Knox": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 154, 0, 0, 0, 7, 0, 0, 0, 24, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 213, 85, 213, 0, 214, 32, 205, 240, 215, 53, 183, 0, 216, 0, 175, 240, 217, 21, 153, 0, 217, 224, 145, 240, 218, 254, 181, 128, 219, 192, 115, 240, 220, 222, 151, 128, 221, 169, 144, 112, 222, 190, 121, 128, 223, 137, 114, 112, 224, 158, 91, 128, 225, 105, 84, 112, 226, 126, 61, 128, 227, 73, 54, 112, 228, 94, 31, 128, 229, 87, 60, 240, 230, 71, 60, 0, 231, 55, 30, 240, 232, 39, 30, 0, 232, 242, 22, 240, 234, 7, 0, 0, 234, 209, 248, 240, 235, 230, 226, 0, 236, 214, 196, 240, 237, 198, 196, 0, 238, 191, 225, 112, 239, 175, 224, 128, 240, 159, 195, 112, 241, 143, 194, 128, 244, 95, 135, 112, 250, 248, 103, 0, 251, 232, 73, 240, 252, 216, 73, 0, 253, 200, 43, 240, 254, 184, 43, 0, 255, 168, 13, 240, 0, 152, 13, 0, 1, 135, 239, 240, 2, 119, 239, 0, 3, 113, 12, 112, 4, 97, 11, 128, 5, 80, 238, 112, 6, 64, 237, 128, 7, 48, 208, 112, 7, 141, 39, 128, 9, 16, 178, 112, 9, 173, 163, 0, 10, 240, 148, 112, 11, 224, 147, 128, 12, 217, 176, 240, 13, 192, 117, 128, 14, 185, 146, 240, 15, 169, 146, 0, 16, 153, 116, 240, 17, 137, 116, 0, 18, 121, 86, 240, 19, 105, 86, 0, 20, 89, 56, 240, 21, 73, 56, 0, 22, 57, 26, 240, 23, 41, 26, 0, 24, 34, 55, 112, 25, 8, 252, 0, 26, 2, 25, 112, 26, 242, 24, 128, 27, 225, 251, 112, 28, 209, 250, 128, 29, 193, 221, 112, 30, 177, 220, 128, 31, 161, 191, 112, 32, 118, 15, 0, 33, 129, 161, 112, 34, 85, 241, 0, 35, 106, 189, 240, 36, 53, 211, 0, 37, 74, 159, 240, 38, 21, 181, 0, 39, 42, 129, 240, 39, 254, 209, 128, 41, 10, 99, 240, 68, 47, 118, 112, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 109, 240, 71, 211, 153, 0, 73, 13, 79, 240, 73, 179, 123, 0, 74, 237, 49, 240, 75, 156, 151, 128, 76, 214, 78, 112, 77, 124, 121, 128, 78, 182, 48, 112, 79, 92, 91, 128, 80, 150, 18, 112, 81, 60, 61, 128, 82, 117, 244, 112, 83, 28, 31, 128, 84, 85, 214, 112, 84, 252, 1, 128, 86, 53, 184, 112, 86, 229, 30, 0, 88, 30, 212, 240, 88, 197, 0, 0, 89, 254, 182, 240, 90, 164, 226, 0, 91, 222, 152, 240, 92, 132, 196, 0, 93, 190, 122, 240, 94, 100, 166, 0, 95, 158, 92, 240, 96, 77, 194, 128, 97, 135, 121, 112, 98, 45, 164, 128, 99, 103, 91, 112, 100, 13, 134, 128, 101, 71, 61, 112, 101, 237, 104, 128, 103, 39, 31, 112, 103, 205, 74, 128, 105, 7, 1, 112, 105, 173, 44, 128, 106, 230, 227, 112, 107, 150, 73, 0, 108, 207, 255, 240, 109, 118, 43, 0, 110, 175, 225, 240, 111, 86, 13, 0, 112, 143, 195, 240, 113, 53, 239, 0, 114, 111, 165, 240, 115, 21, 209, 0, 116, 79, 135, 240, 116, 254, 237, 128, 118, 56, 164, 112, 118, 222, 207, 128, 120, 24, 134, 112, 120, 190, 177, 128, 121, 248, 104, 112, 122, 158, 147, 128, 123, 216, 74, 112, 124, 126, 117, 128, 125, 184, 44, 112, 126, 94, 87, 128, 127, 152, 14, 112, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 5, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 174, 202, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 255, 255, 171, 160, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Indiana/Marengo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 103, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 220, 222, 151, 128, 221, 169, 144, 112, 226, 126, 61, 128, 227, 73, 54, 112, 228, 94, 31, 128, 229, 41, 24, 112, 230, 71, 60, 0, 231, 18, 52, 240, 232, 39, 30, 0, 232, 242, 22, 240, 234, 7, 0, 0, 234, 209, 248, 240, 235, 230, 226, 0, 236, 177, 218, 240, 237, 198, 196, 0, 238, 145, 188, 240, 239, 175, 224, 128, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 2, 119, 224, 240, 3, 112, 254, 96, 4, 96, 253, 112, 5, 80, 224, 96, 6, 64, 223, 112, 7, 48, 194, 96, 7, 141, 25, 112, 9, 16, 178, 112, 9, 173, 148, 240, 10, 240, 134, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 1, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 255, 255, 175, 13, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 255, 255, 199, 192, 1, 24, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 69, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Indiana/Petersburg": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 116, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 228, 103, 61, 224, 229, 41, 24, 112, 230, 71, 60, 0, 231, 18, 52, 240, 232, 39, 30, 0, 232, 242, 22, 240, 234, 7, 0, 0, 234, 209, 248, 240, 235, 230, 226, 0, 236, 177, 218, 240, 237, 198, 196, 0, 238, 145, 188, 240, 239, 175, 224, 128, 240, 159, 195, 112, 241, 143, 194, 128, 242, 127, 165, 112, 243, 111, 164, 128, 244, 95, 135, 112, 245, 79, 134, 128, 246, 63, 105, 112, 247, 47, 104, 128, 250, 8, 103, 240, 250, 248, 103, 0, 251, 232, 73, 240, 252, 216, 73, 0, 253, 200, 43, 240, 254, 184, 43, 0, 255, 168, 13, 240, 0, 152, 13, 0, 1, 135, 239, 240, 2, 119, 239, 0, 3, 113, 12, 112, 4, 97, 11, 128, 5, 80, 238, 112, 6, 64, 237, 128, 7, 48, 208, 112, 7, 141, 39, 128, 9, 16, 178, 112, 9, 173, 163, 0, 10, 240, 148, 112, 11, 224, 147, 128, 12, 217, 176, 240, 13, 192, 117, 128, 14, 185, 146, 240, 68, 47, 118, 112, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 109, 240, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 5, 1, 2, 1, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 255, 255, 174, 45, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 255, 255, 199, 192, 1, 24, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 69, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Indiana/Tell_City": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 101, 0, 0, 0, 9, 0, 0, 0, 28, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 211, 117, 243, 0, 212, 64, 235, 240, 224, 158, 91, 128, 225, 105, 84, 112, 226, 126, 61, 128, 227, 73, 54, 112, 228, 103, 61, 224, 229, 41, 24, 112, 230, 71, 60, 0, 231, 18, 52, 240, 232, 39, 30, 0, 232, 242, 22, 240, 234, 7, 0, 0, 234, 209, 248, 240, 235, 230, 226, 0, 236, 177, 218, 240, 237, 198, 196, 0, 238, 191, 225, 112, 239, 175, 224, 128, 240, 113, 158, 240, 241, 143, 194, 128, 242, 127, 165, 112, 243, 111, 164, 128, 244, 95, 135, 112, 245, 79, 134, 128, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 68, 47, 118, 112, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 109, 240, 71, 211, 153, 0, 73, 13, 79, 240, 73, 179, 123, 0, 74, 237, 49, 240, 75, 156, 151, 128, 76, 214, 78, 112, 77, 124, 121, 128, 78, 182, 48, 112, 79, 92, 91, 128, 80, 150, 18, 112, 81, 60, 61, 128, 82, 117, 244, 112, 83, 28, 31, 128, 84, 85, 214, 112, 84, 252, 1, 128, 86, 53, 184, 112, 86, 229, 30, 0, 88, 30, 212, 240, 88, 197, 0, 0, 89, 254, 182, 240, 90, 164, 226, 0, 91, 222, 152, 240, 92, 132, 196, 0, 93, 190, 122, 240, 94, 100, 166, 0, 95, 158, 92, 240, 96, 77, 194, 128, 97, 135, 121, 112, 98, 45, 164, 128, 99, 103, 91, 112, 100, 13, 134, 128, 101, 71, 61, 112, 101, 237, 104, 128, 103, 39, 31, 112, 103, 205, 74, 128, 105, 7, 1, 112, 105, 173, 44, 128, 106, 230, 227, 112, 107, 150, 73, 0, 108, 207, 255, 240, 109, 118, 43, 0, 110, 175, 225, 240, 111, 86, 13, 0, 112, 143, 195, 240, 113, 53, 239, 0, 114, 111, 165, 240, 115, 21, 209, 0, 116, 79, 135, 240, 116, 254, 237, 128, 118, 56, 164, 112, 118, 222, 207, 128, 120, 24, 134, 112, 120, 190, 177, 128, 121, 248, 104, 112, 122, 158, 147, 128, 123, 216, 74, 112, 124, 126, 117, 128, 125, 184, 44, 112, 126, 94, 87, 128, 127, 152, 14, 112, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 6, 5, 6, 5, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 174, 169, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 255, 255, 199, 192, 1, 24, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 69, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Indiana/Vevay": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 81, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 226, 126, 61, 128, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 2, 119, 224, 240, 3, 112, 254, 96, 4, 96, 253, 112, 5, 80, 224, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 2, 3, 4, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 255, 255, 176, 64, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 255, 255, 199, 192, 1, 24, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 69, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Indiana/Vincennes": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 101, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 211, 117, 243, 0, 212, 64, 235, 240, 224, 158, 91, 128, 225, 105, 84, 112, 226, 126, 61, 128, 227, 73, 54, 112, 228, 103, 61, 224, 229, 41, 24, 112, 230, 71, 60, 0, 231, 18, 52, 240, 232, 39, 30, 0, 232, 242, 22, 240, 234, 7, 0, 0, 234, 209, 248, 240, 235, 230, 226, 0, 236, 177, 218, 240, 237, 198, 196, 0, 238, 191, 225, 112, 239, 175, 224, 128, 240, 113, 158, 240, 241, 143, 194, 128, 242, 127, 165, 112, 243, 111, 164, 128, 244, 95, 135, 112, 245, 79, 134, 128, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 68, 47, 118, 112, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 109, 240, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 6, 5, 6, 5, 1, 2, 1, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 255, 255, 173, 241, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 255, 255, 199, 192, 1, 24, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 69, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Indiana/Winamac": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 107, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 211, 117, 243, 0, 212, 64, 235, 240, 213, 85, 213, 0, 214, 32, 205, 240, 215, 53, 183, 0, 216, 0, 175, 240, 217, 21, 153, 0, 217, 224, 145, 240, 218, 254, 181, 128, 219, 192, 115, 240, 220, 222, 151, 128, 221, 169, 144, 112, 222, 190, 121, 128, 223, 137, 114, 112, 224, 158, 91, 128, 225, 105, 84, 112, 226, 126, 61, 128, 227, 73, 54, 112, 228, 94, 31, 128, 229, 87, 60, 240, 230, 71, 60, 0, 231, 55, 30, 240, 232, 39, 30, 0, 232, 242, 22, 240, 234, 7, 0, 0, 234, 209, 248, 240, 235, 230, 226, 0, 236, 177, 218, 240, 237, 198, 196, 0, 238, 145, 188, 240, 239, 175, 224, 128, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 68, 47, 118, 112, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 6, 5, 6, 5, 1, 2, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 255, 255, 174, 207, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 255, 255, 199, 192, 1, 24, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 69, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Indianapolis": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 99, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 202, 87, 34, 128, 202, 216, 71, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 211, 117, 243, 0, 212, 64, 235, 240, 213, 85, 213, 0, 214, 32, 205, 240, 215, 53, 183, 0, 216, 0, 175, 240, 217, 21, 153, 0, 217, 224, 145, 240, 218, 254, 181, 128, 219, 192, 115, 240, 220, 222, 151, 128, 221, 169, 144, 112, 222, 190, 121, 128, 223, 137, 114, 112, 224, 158, 91, 128, 225, 105, 84, 112, 226, 126, 61, 128, 227, 73, 54, 112, 228, 94, 31, 128, 232, 242, 22, 240, 234, 7, 0, 0, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 255, 255, 175, 58, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 255, 255, 199, 192, 1, 24, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 69, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Inuvik": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 121, 0, 0, 0, 5, 0, 0, 0, 21, 128, 0, 0, 0, 224, 6, 78, 128, 247, 47, 104, 128, 248, 40, 148, 0, 17, 137, 144, 32, 19, 105, 100, 16, 20, 89, 71, 0, 21, 73, 70, 16, 22, 57, 41, 0, 23, 41, 40, 16, 24, 34, 69, 128, 25, 9, 10, 16, 26, 2, 39, 128, 26, 242, 38, 144, 27, 226, 9, 128, 28, 210, 8, 144, 29, 193, 235, 128, 30, 177, 234, 144, 31, 161, 205, 128, 32, 118, 29, 16, 33, 129, 175, 128, 34, 85, 255, 16, 35, 106, 204, 0, 36, 53, 225, 16, 37, 74, 174, 0, 38, 21, 195, 16, 39, 42, 144, 0, 39, 254, 223, 144, 41, 10, 114, 0, 41, 222, 193, 144, 42, 234, 84, 0, 43, 190, 163, 144, 44, 211, 112, 128, 45, 158, 133, 144, 46, 179, 82, 128, 47, 126, 103, 144, 48, 147, 52, 128, 49, 103, 132, 16, 50, 115, 22, 128, 51, 71, 102, 16, 52, 82, 248, 128, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 231, 12, 16, 57, 251, 217, 0, 58, 198, 238, 16, 59, 219, 187, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 206, 144, 65, 132, 155, 128, 66, 79, 176, 144, 67, 100, 125, 128, 68, 47, 146, 144, 69, 68, 95, 128, 69, 243, 197, 16, 71, 45, 124, 0, 71, 211, 167, 16, 73, 13, 94, 0, 73, 179, 137, 16, 74, 237, 64, 0, 75, 156, 165, 144, 76, 214, 92, 128, 77, 124, 135, 144, 78, 182, 62, 128, 79, 92, 105, 144, 80, 150, 32, 128, 81, 60, 75, 144, 82, 118, 2, 128, 83, 28, 45, 144, 84, 85, 228, 128, 84, 252, 15, 144, 86, 53, 198, 128, 86, 229, 44, 16, 88, 30, 227, 0, 88, 197, 14, 16, 89, 254, 197, 0, 90, 164, 240, 16, 91, 222, 167, 0, 92, 132, 210, 16, 93, 190, 137, 0, 94, 100, 180, 16, 95, 158, 107, 0, 96, 77, 208, 144, 97, 135, 135, 128, 98, 45, 178, 144, 99, 103, 105, 128, 100, 13, 148, 144, 101, 71, 75, 128, 101, 237, 118, 144, 103, 39, 45, 128, 103, 205, 88, 144, 105, 7, 15, 128, 105, 173, 58, 144, 106, 230, 241, 128, 107, 150, 87, 16, 108, 208, 14, 0, 109, 118, 57, 16, 110, 175, 240, 0, 111, 86, 27, 16, 112, 143, 210, 0, 113, 53, 253, 16, 114, 111, 180, 0, 115, 21, 223, 16, 116, 79, 150, 0, 116, 254, 251, 144, 118, 56, 178, 128, 118, 222, 221, 144, 120, 24, 148, 128, 120, 190, 191, 144, 121, 248, 118, 128, 122, 158, 161, 144, 123, 216, 88, 128, 124, 126, 131, 144, 125, 184, 58, 128, 126, 94, 101, 144, 127, 152, 28, 128, 0, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 0, 0, 0, 0, 255, 255, 171, 160, 1, 4, 255, 255, 143, 128, 0, 9, 255, 255, 157, 144, 0, 13, 255, 255, 171, 160, 1, 17, 45, 48, 48, 0, 80, 68, 68, 84, 0, 80, 83, 84, 0, 77, 83, 84, 0, 77, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 77, 83, 84, 55, 77, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Iqaluit": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 122, 0, 0, 0, 10, 0, 0, 0, 33, 128, 0, 0, 0, 204, 108, 161, 128, 210, 35, 244, 112, 210, 96, 251, 224, 247, 47, 62, 80, 248, 40, 105, 208, 19, 105, 71, 240, 20, 89, 42, 224, 21, 73, 41, 240, 22, 57, 12, 224, 23, 41, 11, 240, 24, 34, 41, 96, 25, 8, 237, 240, 26, 2, 11, 96, 26, 242, 10, 112, 27, 225, 237, 96, 28, 209, 236, 112, 29, 193, 207, 96, 30, 177, 206, 112, 31, 161, 177, 96, 32, 118, 0, 240, 33, 129, 147, 96, 34, 85, 226, 240, 35, 106, 175, 224, 36, 53, 196, 240, 37, 74, 145, 224, 38, 21, 166, 240, 39, 42, 115, 224, 39, 254, 195, 112, 41, 10, 85, 224, 41, 222, 165, 112, 42, 234, 55, 224, 43, 190, 135, 112, 44, 211, 84, 96, 45, 158, 105, 112, 46, 179, 54, 96, 47, 126, 75, 112, 48, 147, 24, 96, 49, 103, 103, 240, 50, 114, 250, 96, 51, 71, 73, 240, 52, 82, 220, 96, 53, 39, 43, 240, 54, 50, 190, 96, 55, 7, 13, 240, 56, 27, 218, 224, 56, 230, 254, 0, 57, 251, 202, 240, 58, 198, 209, 240, 59, 219, 158, 224, 60, 175, 238, 112, 61, 187, 128, 224, 62, 143, 208, 112, 63, 155, 98, 224, 64, 111, 178, 112, 65, 132, 127, 96, 66, 79, 148, 112, 67, 100, 97, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 0, 5, 1, 2, 3, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 6, 7, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 0, 0, 0, 0, 0, 0, 255, 255, 199, 192, 1, 4, 255, 255, 185, 176, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 199, 192, 1, 17, 255, 255, 199, 192, 1, 21, 255, 255, 171, 160, 0, 25, 255, 255, 185, 176, 1, 29, 255, 255, 199, 192, 1, 17, 255, 255, 185, 176, 0, 8, 45, 48, 48, 0, 69, 80, 84, 0, 69, 83, 84, 0, 69, 68, 68, 84, 0, 69, 68, 84, 0, 69, 87, 84, 0, 67, 83, 84, 0, 67, 68, 84, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Jamaica": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 4, 0, 0, 0, 16, 128, 0, 0, 0, 147, 15, 180, 255, 7, 141, 25, 112, 9, 16, 164, 96, 9, 173, 148, 240, 10, 240, 134, 96, 11, 224, 133, 112, 12, 217, 162, 224, 13, 192, 103, 112, 14, 185, 132, 224, 15, 169, 131, 240, 16, 153, 102, 224, 17, 137, 101, 240, 18, 121, 72, 224, 19, 105, 71, 240, 20, 89, 42, 224, 21, 73, 41, 240, 22, 57, 12, 224, 23, 41, 11, 240, 24, 34, 41, 96, 25, 8, 237, 240, 26, 2, 11, 96, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 255, 255, 184, 1, 0, 0, 255, 255, 184, 1, 0, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 1, 12, 76, 77, 84, 0, 75, 77, 84, 0, 69, 83, 84, 0, 69, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 83, 84, 53, 10}, - - "zoneinfo/America/Jujuy": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 60, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 42, 87, 192, 39, 226, 219, 176, 40, 238, 138, 64, 41, 176, 58, 160, 42, 224, 211, 48, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 71, 119, 9, 176, 71, 220, 127, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 2, 3, 2, 4, 5, 4, 5, 3, 5, 4, 5, 5, 255, 255, 194, 200, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Juneau": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 143, 0, 0, 0, 9, 0, 0, 0, 38, 128, 0, 0, 0, 203, 137, 26, 160, 210, 35, 244, 112, 210, 97, 38, 16, 254, 184, 71, 32, 255, 168, 42, 16, 0, 152, 41, 32, 1, 136, 12, 16, 2, 120, 11, 32, 3, 113, 40, 144, 4, 97, 39, 160, 5, 81, 10, 144, 6, 65, 9, 160, 7, 48, 236, 144, 7, 141, 67, 160, 9, 16, 206, 144, 9, 173, 191, 32, 10, 240, 176, 144, 11, 224, 175, 160, 12, 217, 205, 16, 13, 192, 145, 160, 14, 185, 175, 16, 15, 169, 174, 32, 16, 153, 145, 16, 17, 137, 144, 32, 18, 121, 115, 16, 19, 105, 114, 32, 20, 89, 99, 32, 21, 73, 84, 32, 22, 57, 55, 16, 23, 41, 54, 32, 24, 34, 83, 144, 25, 9, 24, 32, 26, 2, 53, 144, 26, 43, 20, 16, 26, 242, 66, 176, 27, 226, 37, 160, 28, 210, 36, 176, 29, 194, 7, 160, 30, 178, 6, 176, 31, 161, 233, 160, 32, 118, 57, 48, 33, 129, 203, 160, 34, 86, 27, 48, 35, 106, 232, 32, 36, 53, 253, 48, 37, 74, 202, 32, 38, 21, 223, 48, 39, 42, 172, 32, 39, 254, 251, 176, 41, 10, 142, 32, 41, 222, 221, 176, 42, 234, 112, 32, 43, 190, 191, 176, 44, 211, 140, 160, 45, 158, 161, 176, 46, 179, 110, 160, 47, 126, 131, 176, 48, 147, 80, 160, 49, 103, 160, 48, 50, 115, 50, 160, 51, 71, 130, 48, 52, 83, 20, 160, 53, 39, 100, 48, 54, 50, 246, 160, 55, 7, 70, 48, 56, 28, 19, 32, 56, 231, 40, 48, 57, 251, 245, 32, 58, 199, 10, 48, 59, 219, 215, 32, 60, 176, 38, 176, 61, 187, 185, 32, 62, 144, 8, 176, 63, 155, 155, 32, 64, 111, 234, 176, 65, 132, 183, 160, 66, 79, 204, 176, 67, 100, 153, 160, 68, 47, 174, 176, 69, 68, 123, 160, 69, 243, 225, 48, 71, 45, 152, 32, 71, 211, 195, 48, 73, 13, 122, 32, 73, 179, 165, 48, 74, 237, 92, 32, 75, 156, 193, 176, 76, 214, 120, 160, 77, 124, 163, 176, 78, 182, 90, 160, 79, 92, 133, 176, 80, 150, 60, 160, 81, 60, 103, 176, 82, 118, 30, 160, 83, 28, 73, 176, 84, 86, 0, 160, 84, 252, 43, 176, 86, 53, 226, 160, 86, 229, 72, 48, 88, 30, 255, 32, 88, 197, 42, 48, 89, 254, 225, 32, 90, 165, 12, 48, 91, 222, 195, 32, 92, 132, 238, 48, 93, 190, 165, 32, 94, 100, 208, 48, 95, 158, 135, 32, 96, 77, 236, 176, 97, 135, 163, 160, 98, 45, 206, 176, 99, 103, 133, 160, 100, 13, 176, 176, 101, 71, 103, 160, 101, 237, 146, 176, 103, 39, 73, 160, 103, 205, 116, 176, 105, 7, 43, 160, 105, 173, 86, 176, 106, 231, 13, 160, 107, 150, 115, 48, 108, 208, 42, 32, 109, 118, 85, 48, 110, 176, 12, 32, 111, 86, 55, 48, 112, 143, 238, 32, 113, 54, 25, 48, 114, 111, 208, 32, 115, 21, 251, 48, 116, 79, 178, 32, 116, 255, 23, 176, 118, 56, 206, 160, 118, 222, 249, 176, 120, 24, 176, 160, 120, 190, 219, 176, 121, 248, 146, 160, 122, 158, 189, 176, 123, 216, 116, 160, 124, 126, 159, 176, 125, 184, 86, 160, 126, 94, 129, 176, 127, 152, 56, 160, 1, 2, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 1, 4, 1, 4, 1, 4, 6, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 255, 255, 129, 251, 0, 0, 255, 255, 143, 128, 0, 4, 255, 255, 157, 144, 1, 8, 255, 255, 157, 144, 1, 12, 255, 255, 157, 144, 1, 16, 255, 255, 143, 128, 1, 20, 255, 255, 129, 112, 0, 24, 255, 255, 143, 128, 1, 28, 255, 255, 129, 112, 0, 33, 76, 77, 84, 0, 80, 83, 84, 0, 80, 87, 84, 0, 80, 80, 84, 0, 80, 68, 84, 0, 89, 68, 84, 0, 89, 83, 84, 0, 65, 75, 68, 84, 0, 65, 75, 83, 84, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 10, 65, 75, 83, 84, 57, 65, 75, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Kentucky/Louisville": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 178, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 164, 115, 247, 0, 165, 22, 17, 112, 202, 13, 78, 128, 202, 216, 71, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 210, 219, 151, 96, 211, 164, 9, 112, 213, 85, 213, 0, 219, 192, 115, 240, 220, 222, 151, 128, 221, 169, 144, 112, 222, 190, 121, 128, 223, 137, 114, 112, 224, 158, 91, 128, 225, 105, 84, 112, 226, 126, 61, 128, 227, 73, 54, 112, 228, 94, 31, 128, 229, 41, 24, 112, 230, 71, 60, 0, 231, 55, 30, 240, 232, 39, 30, 0, 233, 23, 0, 240, 234, 7, 0, 0, 234, 246, 226, 240, 235, 230, 226, 0, 236, 214, 196, 240, 237, 198, 196, 0, 238, 191, 225, 112, 239, 175, 224, 128, 240, 30, 144, 112, 252, 216, 58, 240, 253, 200, 29, 224, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 2, 119, 224, 240, 3, 112, 254, 96, 4, 96, 253, 112, 5, 80, 224, 96, 6, 64, 223, 112, 7, 48, 194, 96, 7, 141, 25, 112, 9, 16, 178, 112, 9, 173, 148, 240, 10, 240, 134, 96, 11, 224, 133, 112, 12, 217, 162, 224, 13, 192, 103, 112, 14, 185, 132, 224, 15, 169, 131, 240, 16, 153, 102, 224, 17, 137, 101, 240, 18, 121, 72, 224, 19, 105, 71, 240, 20, 89, 42, 224, 21, 73, 41, 240, 22, 57, 12, 224, 23, 41, 11, 240, 24, 34, 41, 96, 25, 8, 237, 240, 26, 2, 11, 96, 26, 242, 10, 112, 27, 225, 237, 96, 28, 209, 236, 112, 29, 193, 207, 96, 30, 177, 206, 112, 31, 161, 177, 96, 32, 118, 0, 240, 33, 129, 147, 96, 34, 85, 226, 240, 35, 106, 175, 224, 36, 53, 196, 240, 37, 74, 145, 224, 38, 21, 166, 240, 39, 42, 115, 224, 39, 254, 195, 112, 41, 10, 85, 224, 41, 222, 165, 112, 42, 234, 55, 224, 43, 190, 135, 112, 44, 211, 84, 96, 45, 158, 105, 112, 46, 179, 54, 96, 47, 126, 75, 112, 48, 147, 24, 96, 49, 103, 103, 240, 50, 114, 250, 96, 51, 71, 73, 240, 52, 82, 220, 96, 53, 39, 43, 240, 54, 50, 190, 96, 55, 7, 13, 240, 56, 27, 218, 224, 56, 230, 239, 240, 57, 251, 188, 224, 58, 198, 209, 240, 59, 219, 158, 224, 60, 175, 238, 112, 61, 187, 128, 224, 62, 143, 208, 112, 63, 155, 98, 224, 64, 111, 178, 112, 65, 132, 127, 96, 66, 79, 148, 112, 67, 100, 97, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 1, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 255, 255, 175, 154, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 255, 255, 199, 192, 1, 24, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 69, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Kentucky/Monticello": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 148, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 252, 216, 73, 0, 253, 200, 43, 240, 254, 184, 43, 0, 255, 168, 13, 240, 0, 152, 13, 0, 1, 135, 239, 240, 2, 119, 239, 0, 3, 113, 12, 112, 4, 97, 11, 128, 5, 80, 238, 112, 6, 64, 237, 128, 7, 48, 208, 112, 7, 141, 39, 128, 9, 16, 178, 112, 9, 173, 163, 0, 10, 240, 148, 112, 11, 224, 147, 128, 12, 217, 176, 240, 13, 192, 117, 128, 14, 185, 146, 240, 15, 169, 146, 0, 16, 153, 116, 240, 17, 137, 116, 0, 18, 121, 86, 240, 19, 105, 86, 0, 20, 89, 56, 240, 21, 73, 56, 0, 22, 57, 26, 240, 23, 41, 26, 0, 24, 34, 55, 112, 25, 8, 252, 0, 26, 2, 25, 112, 26, 242, 24, 128, 27, 225, 251, 112, 28, 209, 250, 128, 29, 193, 221, 112, 30, 177, 220, 128, 31, 161, 191, 112, 32, 118, 15, 0, 33, 129, 161, 112, 34, 85, 241, 0, 35, 106, 189, 240, 36, 53, 211, 0, 37, 74, 159, 240, 38, 21, 181, 0, 39, 42, 129, 240, 39, 254, 209, 128, 41, 10, 99, 240, 41, 222, 179, 128, 42, 234, 69, 240, 43, 190, 149, 128, 44, 211, 98, 112, 45, 158, 119, 128, 46, 179, 68, 112, 47, 126, 89, 128, 48, 147, 38, 112, 49, 103, 118, 0, 50, 115, 8, 112, 51, 71, 88, 0, 52, 82, 234, 112, 53, 39, 58, 0, 54, 50, 204, 112, 55, 7, 28, 0, 56, 27, 232, 240, 56, 230, 254, 0, 57, 251, 202, 240, 58, 198, 209, 240, 59, 219, 158, 224, 60, 175, 238, 112, 61, 187, 128, 224, 62, 143, 208, 112, 63, 155, 98, 224, 64, 111, 178, 112, 65, 132, 127, 96, 66, 79, 148, 112, 67, 100, 97, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 255, 255, 176, 116, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 199, 192, 1, 20, 255, 255, 185, 176, 0, 24, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 68, 84, 0, 69, 83, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Knox_IN": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 154, 0, 0, 0, 7, 0, 0, 0, 24, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 213, 85, 213, 0, 214, 32, 205, 240, 215, 53, 183, 0, 216, 0, 175, 240, 217, 21, 153, 0, 217, 224, 145, 240, 218, 254, 181, 128, 219, 192, 115, 240, 220, 222, 151, 128, 221, 169, 144, 112, 222, 190, 121, 128, 223, 137, 114, 112, 224, 158, 91, 128, 225, 105, 84, 112, 226, 126, 61, 128, 227, 73, 54, 112, 228, 94, 31, 128, 229, 87, 60, 240, 230, 71, 60, 0, 231, 55, 30, 240, 232, 39, 30, 0, 232, 242, 22, 240, 234, 7, 0, 0, 234, 209, 248, 240, 235, 230, 226, 0, 236, 214, 196, 240, 237, 198, 196, 0, 238, 191, 225, 112, 239, 175, 224, 128, 240, 159, 195, 112, 241, 143, 194, 128, 244, 95, 135, 112, 250, 248, 103, 0, 251, 232, 73, 240, 252, 216, 73, 0, 253, 200, 43, 240, 254, 184, 43, 0, 255, 168, 13, 240, 0, 152, 13, 0, 1, 135, 239, 240, 2, 119, 239, 0, 3, 113, 12, 112, 4, 97, 11, 128, 5, 80, 238, 112, 6, 64, 237, 128, 7, 48, 208, 112, 7, 141, 39, 128, 9, 16, 178, 112, 9, 173, 163, 0, 10, 240, 148, 112, 11, 224, 147, 128, 12, 217, 176, 240, 13, 192, 117, 128, 14, 185, 146, 240, 15, 169, 146, 0, 16, 153, 116, 240, 17, 137, 116, 0, 18, 121, 86, 240, 19, 105, 86, 0, 20, 89, 56, 240, 21, 73, 56, 0, 22, 57, 26, 240, 23, 41, 26, 0, 24, 34, 55, 112, 25, 8, 252, 0, 26, 2, 25, 112, 26, 242, 24, 128, 27, 225, 251, 112, 28, 209, 250, 128, 29, 193, 221, 112, 30, 177, 220, 128, 31, 161, 191, 112, 32, 118, 15, 0, 33, 129, 161, 112, 34, 85, 241, 0, 35, 106, 189, 240, 36, 53, 211, 0, 37, 74, 159, 240, 38, 21, 181, 0, 39, 42, 129, 240, 39, 254, 209, 128, 41, 10, 99, 240, 68, 47, 118, 112, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 109, 240, 71, 211, 153, 0, 73, 13, 79, 240, 73, 179, 123, 0, 74, 237, 49, 240, 75, 156, 151, 128, 76, 214, 78, 112, 77, 124, 121, 128, 78, 182, 48, 112, 79, 92, 91, 128, 80, 150, 18, 112, 81, 60, 61, 128, 82, 117, 244, 112, 83, 28, 31, 128, 84, 85, 214, 112, 84, 252, 1, 128, 86, 53, 184, 112, 86, 229, 30, 0, 88, 30, 212, 240, 88, 197, 0, 0, 89, 254, 182, 240, 90, 164, 226, 0, 91, 222, 152, 240, 92, 132, 196, 0, 93, 190, 122, 240, 94, 100, 166, 0, 95, 158, 92, 240, 96, 77, 194, 128, 97, 135, 121, 112, 98, 45, 164, 128, 99, 103, 91, 112, 100, 13, 134, 128, 101, 71, 61, 112, 101, 237, 104, 128, 103, 39, 31, 112, 103, 205, 74, 128, 105, 7, 1, 112, 105, 173, 44, 128, 106, 230, 227, 112, 107, 150, 73, 0, 108, 207, 255, 240, 109, 118, 43, 0, 110, 175, 225, 240, 111, 86, 13, 0, 112, 143, 195, 240, 113, 53, 239, 0, 114, 111, 165, 240, 115, 21, 209, 0, 116, 79, 135, 240, 116, 254, 237, 128, 118, 56, 164, 112, 118, 222, 207, 128, 120, 24, 134, 112, 120, 190, 177, 128, 121, 248, 104, 112, 122, 158, 147, 128, 123, 216, 74, 112, 124, 126, 117, 128, 125, 184, 44, 112, 126, 94, 87, 128, 127, 152, 14, 112, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 5, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 174, 202, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 255, 255, 171, 160, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Kralendijk": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 14, 128, 0, 0, 0, 147, 30, 46, 35, 246, 152, 236, 72, 0, 1, 2, 255, 255, 191, 93, 0, 0, 255, 255, 192, 184, 0, 4, 255, 255, 199, 192, 0, 10, 76, 77, 84, 0, 45, 48, 52, 51, 48, 0, 65, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/La_Paz": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 17, 128, 0, 0, 0, 184, 30, 150, 228, 184, 238, 213, 212, 127, 255, 255, 255, 1, 2, 3, 3, 255, 255, 192, 28, 0, 0, 255, 255, 192, 28, 0, 4, 255, 255, 206, 44, 1, 8, 255, 255, 199, 192, 0, 13, 76, 77, 84, 0, 67, 77, 84, 0, 66, 79, 83, 84, 0, 45, 48, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 52, 62, 52, 10}, - - "zoneinfo/America/Lima": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 4, 0, 0, 0, 12, 128, 0, 0, 0, 140, 116, 64, 212, 195, 207, 74, 80, 196, 69, 227, 64, 197, 47, 74, 208, 198, 31, 45, 192, 199, 15, 44, 208, 199, 255, 15, 192, 30, 24, 196, 80, 30, 143, 93, 64, 31, 249, 247, 208, 32, 112, 144, 192, 37, 158, 227, 208, 38, 21, 124, 192, 45, 37, 3, 80, 45, 155, 156, 64, 127, 255, 255, 255, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 3, 255, 255, 183, 196, 0, 0, 255, 255, 183, 172, 0, 0, 255, 255, 199, 192, 1, 4, 255, 255, 185, 176, 0, 8, 76, 77, 84, 0, 45, 48, 52, 0, 45, 48, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 53, 62, 53, 10}, - - "zoneinfo/America/Los_Angeles": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 186, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 158, 166, 72, 160, 159, 187, 21, 144, 160, 134, 42, 160, 161, 154, 247, 144, 203, 137, 26, 160, 210, 35, 244, 112, 210, 97, 38, 16, 214, 254, 116, 92, 216, 128, 173, 144, 218, 254, 195, 144, 219, 192, 144, 16, 220, 222, 165, 144, 221, 169, 172, 144, 222, 190, 135, 144, 223, 137, 142, 144, 224, 158, 105, 144, 225, 105, 112, 144, 226, 126, 75, 144, 227, 73, 82, 144, 228, 94, 45, 144, 229, 41, 52, 144, 230, 71, 74, 16, 231, 18, 81, 16, 232, 39, 44, 16, 232, 242, 51, 16, 234, 7, 14, 16, 234, 210, 21, 16, 235, 230, 240, 16, 236, 177, 247, 16, 237, 198, 210, 16, 238, 145, 217, 16, 239, 175, 238, 144, 240, 113, 187, 16, 241, 143, 208, 144, 242, 127, 193, 144, 243, 111, 178, 144, 244, 95, 163, 144, 245, 79, 148, 144, 246, 63, 133, 144, 247, 47, 118, 144, 248, 40, 162, 16, 249, 15, 88, 144, 250, 8, 132, 16, 250, 248, 131, 32, 251, 232, 102, 16, 252, 216, 101, 32, 253, 200, 72, 16, 254, 184, 71, 32, 255, 168, 42, 16, 0, 152, 41, 32, 1, 136, 12, 16, 2, 120, 11, 32, 3, 113, 40, 144, 4, 97, 39, 160, 5, 81, 10, 144, 6, 65, 9, 160, 7, 48, 236, 144, 7, 141, 67, 160, 9, 16, 206, 144, 9, 173, 191, 32, 10, 240, 176, 144, 11, 224, 175, 160, 12, 217, 205, 16, 13, 192, 145, 160, 14, 185, 175, 16, 15, 169, 174, 32, 16, 153, 145, 16, 17, 137, 144, 32, 18, 121, 115, 16, 19, 105, 114, 32, 20, 89, 85, 16, 21, 73, 84, 32, 22, 57, 55, 16, 23, 41, 54, 32, 24, 34, 83, 144, 25, 9, 24, 32, 26, 2, 53, 144, 26, 242, 52, 160, 27, 226, 23, 144, 28, 210, 22, 160, 29, 193, 249, 144, 30, 177, 248, 160, 31, 161, 219, 144, 32, 118, 43, 32, 33, 129, 189, 144, 34, 86, 13, 32, 35, 106, 218, 16, 36, 53, 239, 32, 37, 74, 188, 16, 38, 21, 209, 32, 39, 42, 158, 16, 39, 254, 237, 160, 41, 10, 128, 16, 41, 222, 207, 160, 42, 234, 98, 16, 43, 190, 177, 160, 44, 211, 126, 144, 45, 158, 147, 160, 46, 179, 96, 144, 47, 126, 117, 160, 48, 147, 66, 144, 49, 103, 146, 32, 50, 115, 36, 144, 51, 71, 116, 32, 52, 83, 6, 144, 53, 39, 86, 32, 54, 50, 232, 144, 55, 7, 56, 32, 56, 28, 5, 16, 56, 231, 26, 32, 57, 251, 231, 16, 58, 198, 252, 32, 59, 219, 201, 16, 60, 176, 24, 160, 61, 187, 171, 16, 62, 143, 250, 160, 63, 155, 141, 16, 64, 111, 220, 160, 65, 132, 169, 144, 66, 79, 190, 160, 67, 100, 139, 144, 68, 47, 160, 160, 69, 68, 109, 144, 69, 243, 211, 32, 71, 45, 138, 16, 71, 211, 181, 32, 73, 13, 108, 16, 73, 179, 151, 32, 74, 237, 78, 16, 75, 156, 179, 160, 76, 214, 106, 144, 77, 124, 149, 160, 78, 182, 76, 144, 79, 92, 119, 160, 80, 150, 46, 144, 81, 60, 89, 160, 82, 118, 16, 144, 83, 28, 59, 160, 84, 85, 242, 144, 84, 252, 29, 160, 86, 53, 212, 144, 86, 229, 58, 32, 88, 30, 241, 16, 88, 197, 28, 32, 89, 254, 211, 16, 90, 164, 254, 32, 91, 222, 181, 16, 92, 132, 224, 32, 93, 190, 151, 16, 94, 100, 194, 32, 95, 158, 121, 16, 96, 77, 222, 160, 97, 135, 149, 144, 98, 45, 192, 160, 99, 103, 119, 144, 100, 13, 162, 160, 101, 71, 89, 144, 101, 237, 132, 160, 103, 39, 59, 144, 103, 205, 102, 160, 105, 7, 29, 144, 105, 173, 72, 160, 106, 230, 255, 144, 107, 150, 101, 32, 108, 208, 28, 16, 109, 118, 71, 32, 110, 175, 254, 16, 111, 86, 41, 32, 112, 143, 224, 16, 113, 54, 11, 32, 114, 111, 194, 16, 115, 21, 237, 32, 116, 79, 164, 16, 116, 255, 9, 160, 118, 56, 192, 144, 118, 222, 235, 160, 120, 24, 162, 144, 120, 190, 205, 160, 121, 248, 132, 144, 122, 158, 175, 160, 123, 216, 102, 144, 124, 126, 145, 160, 125, 184, 72, 144, 126, 94, 115, 160, 127, 152, 42, 144, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 145, 38, 0, 0, 255, 255, 157, 144, 1, 4, 255, 255, 143, 128, 0, 8, 255, 255, 157, 144, 1, 12, 255, 255, 157, 144, 1, 16, 76, 77, 84, 0, 80, 68, 84, 0, 80, 83, 84, 0, 80, 87, 84, 0, 80, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 80, 83, 84, 56, 80, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Louisville": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 178, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 164, 115, 247, 0, 165, 22, 17, 112, 202, 13, 78, 128, 202, 216, 71, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 210, 219, 151, 96, 211, 164, 9, 112, 213, 85, 213, 0, 219, 192, 115, 240, 220, 222, 151, 128, 221, 169, 144, 112, 222, 190, 121, 128, 223, 137, 114, 112, 224, 158, 91, 128, 225, 105, 84, 112, 226, 126, 61, 128, 227, 73, 54, 112, 228, 94, 31, 128, 229, 41, 24, 112, 230, 71, 60, 0, 231, 55, 30, 240, 232, 39, 30, 0, 233, 23, 0, 240, 234, 7, 0, 0, 234, 246, 226, 240, 235, 230, 226, 0, 236, 214, 196, 240, 237, 198, 196, 0, 238, 191, 225, 112, 239, 175, 224, 128, 240, 30, 144, 112, 252, 216, 58, 240, 253, 200, 29, 224, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 2, 119, 224, 240, 3, 112, 254, 96, 4, 96, 253, 112, 5, 80, 224, 96, 6, 64, 223, 112, 7, 48, 194, 96, 7, 141, 25, 112, 9, 16, 178, 112, 9, 173, 148, 240, 10, 240, 134, 96, 11, 224, 133, 112, 12, 217, 162, 224, 13, 192, 103, 112, 14, 185, 132, 224, 15, 169, 131, 240, 16, 153, 102, 224, 17, 137, 101, 240, 18, 121, 72, 224, 19, 105, 71, 240, 20, 89, 42, 224, 21, 73, 41, 240, 22, 57, 12, 224, 23, 41, 11, 240, 24, 34, 41, 96, 25, 8, 237, 240, 26, 2, 11, 96, 26, 242, 10, 112, 27, 225, 237, 96, 28, 209, 236, 112, 29, 193, 207, 96, 30, 177, 206, 112, 31, 161, 177, 96, 32, 118, 0, 240, 33, 129, 147, 96, 34, 85, 226, 240, 35, 106, 175, 224, 36, 53, 196, 240, 37, 74, 145, 224, 38, 21, 166, 240, 39, 42, 115, 224, 39, 254, 195, 112, 41, 10, 85, 224, 41, 222, 165, 112, 42, 234, 55, 224, 43, 190, 135, 112, 44, 211, 84, 96, 45, 158, 105, 112, 46, 179, 54, 96, 47, 126, 75, 112, 48, 147, 24, 96, 49, 103, 103, 240, 50, 114, 250, 96, 51, 71, 73, 240, 52, 82, 220, 96, 53, 39, 43, 240, 54, 50, 190, 96, 55, 7, 13, 240, 56, 27, 218, 224, 56, 230, 239, 240, 57, 251, 188, 224, 58, 198, 209, 240, 59, 219, 158, 224, 60, 175, 238, 112, 61, 187, 128, 224, 62, 143, 208, 112, 63, 155, 98, 224, 64, 111, 178, 112, 65, 132, 127, 96, 66, 79, 148, 112, 67, 100, 97, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 1, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 255, 255, 175, 154, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 255, 255, 199, 192, 1, 24, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 69, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Lower_Princes": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 14, 128, 0, 0, 0, 147, 30, 46, 35, 246, 152, 236, 72, 0, 1, 2, 255, 255, 191, 93, 0, 0, 255, 255, 192, 184, 0, 4, 255, 255, 199, 192, 0, 10, 76, 77, 84, 0, 45, 48, 52, 51, 48, 0, 65, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Maceio": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 43, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 104, 124, 184, 15, 73, 224, 184, 253, 64, 160, 185, 241, 52, 48, 186, 222, 116, 32, 218, 56, 174, 48, 218, 235, 250, 48, 220, 25, 225, 176, 220, 185, 89, 32, 221, 251, 21, 48, 222, 155, 222, 32, 223, 221, 154, 48, 224, 84, 51, 32, 244, 151, 255, 176, 245, 5, 94, 32, 246, 192, 100, 48, 247, 14, 30, 160, 248, 81, 44, 48, 248, 199, 197, 32, 250, 10, 210, 176, 250, 168, 248, 160, 251, 236, 6, 48, 252, 139, 125, 160, 29, 201, 142, 48, 30, 120, 215, 160, 31, 160, 53, 176, 32, 51, 207, 160, 33, 129, 105, 48, 34, 11, 200, 160, 35, 88, 16, 176, 35, 226, 112, 32, 37, 55, 242, 176, 37, 212, 199, 32, 48, 128, 121, 48, 49, 29, 77, 160, 55, 246, 198, 176, 56, 184, 133, 32, 57, 223, 227, 48, 57, 242, 74, 32, 59, 200, 255, 176, 60, 111, 14, 160, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 255, 255, 222, 132, 0, 0, 255, 255, 227, 224, 1, 4, 255, 255, 213, 208, 0, 8, 76, 77, 84, 0, 45, 48, 50, 0, 45, 48, 51, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Managua": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 189, 45, 72, 232, 6, 67, 116, 96, 9, 164, 62, 80, 17, 81, 248, 224, 17, 212, 111, 80, 19, 49, 218, 224, 19, 180, 81, 80, 41, 97, 145, 32, 42, 193, 75, 80, 43, 67, 221, 224, 50, 201, 239, 80, 66, 88, 192, 224, 67, 63, 105, 80, 68, 84, 110, 128, 69, 31, 89, 96, 1, 2, 3, 2, 4, 2, 4, 2, 3, 2, 3, 2, 4, 2, 4, 2, 255, 255, 175, 28, 0, 0, 255, 255, 175, 24, 0, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 0, 12, 255, 255, 185, 176, 1, 16, 255, 255, 171, 160, 0, 8, 76, 77, 84, 0, 77, 77, 84, 0, 67, 83, 84, 0, 69, 83, 84, 0, 67, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 54, 10}, - - "zoneinfo/America/Manaus": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 127, 68, 184, 15, 87, 240, 184, 253, 78, 176, 185, 241, 66, 64, 186, 222, 130, 48, 218, 56, 188, 64, 218, 236, 8, 64, 220, 25, 239, 192, 220, 185, 103, 48, 221, 251, 35, 64, 222, 155, 236, 48, 223, 221, 168, 64, 224, 84, 65, 48, 244, 152, 13, 192, 245, 5, 108, 48, 246, 192, 114, 64, 247, 14, 44, 176, 248, 81, 58, 64, 248, 199, 211, 48, 250, 10, 224, 192, 250, 169, 6, 176, 251, 236, 20, 64, 252, 139, 139, 176, 29, 201, 156, 64, 30, 120, 229, 176, 31, 160, 67, 192, 32, 51, 221, 176, 33, 129, 119, 64, 34, 11, 214, 176, 44, 192, 195, 64, 45, 102, 210, 48, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 255, 255, 199, 188, 0, 0, 255, 255, 213, 208, 1, 4, 255, 255, 199, 192, 0, 8, 76, 77, 84, 0, 45, 48, 51, 0, 45, 48, 52, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 52, 62, 52, 10}, - - "zoneinfo/America/Marigot": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 147, 55, 51, 172, 0, 1, 255, 255, 198, 84, 0, 0, 255, 255, 199, 192, 0, 4, 76, 77, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Martinique": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 17, 128, 0, 0, 0, 145, 163, 200, 68, 19, 77, 110, 64, 20, 52, 22, 176, 1, 2, 3, 2, 255, 255, 198, 188, 0, 0, 255, 255, 198, 188, 0, 4, 255, 255, 199, 192, 0, 9, 255, 255, 213, 208, 1, 13, 76, 77, 84, 0, 70, 70, 77, 84, 0, 65, 83, 84, 0, 65, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Matamoros": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 88, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 165, 182, 218, 96, 34, 85, 241, 0, 35, 106, 189, 240, 49, 103, 118, 0, 50, 115, 8, 112, 51, 71, 88, 0, 52, 82, 234, 112, 53, 39, 58, 0, 54, 50, 204, 112, 55, 7, 28, 0, 56, 27, 232, 240, 56, 230, 254, 0, 57, 251, 202, 240, 58, 245, 4, 128, 59, 182, 194, 240, 60, 175, 252, 128, 61, 187, 142, 240, 62, 143, 222, 128, 63, 155, 112, 240, 64, 111, 192, 128, 65, 132, 141, 112, 66, 79, 162, 128, 67, 100, 111, 112, 68, 47, 132, 128, 69, 68, 81, 112, 70, 15, 102, 128, 71, 36, 51, 112, 71, 248, 131, 0, 73, 4, 21, 112, 73, 216, 101, 0, 74, 227, 247, 112, 75, 156, 151, 128, 76, 214, 78, 112, 77, 124, 121, 128, 78, 182, 48, 112, 79, 92, 91, 128, 80, 150, 18, 112, 81, 60, 61, 128, 82, 117, 244, 112, 83, 28, 31, 128, 84, 85, 214, 112, 84, 252, 1, 128, 86, 53, 184, 112, 86, 229, 30, 0, 88, 30, 212, 240, 88, 197, 0, 0, 89, 254, 182, 240, 90, 164, 226, 0, 91, 222, 152, 240, 92, 132, 196, 0, 93, 190, 122, 240, 94, 100, 166, 0, 95, 158, 92, 240, 96, 77, 194, 128, 97, 135, 121, 112, 98, 45, 164, 128, 99, 103, 91, 112, 100, 13, 134, 128, 101, 71, 61, 112, 101, 237, 104, 128, 103, 39, 31, 112, 103, 205, 74, 128, 105, 7, 1, 112, 105, 173, 44, 128, 106, 230, 227, 112, 107, 150, 73, 0, 108, 207, 255, 240, 109, 118, 43, 0, 110, 175, 225, 240, 111, 86, 13, 0, 112, 143, 195, 240, 113, 53, 239, 0, 114, 111, 165, 240, 115, 21, 209, 0, 116, 79, 135, 240, 116, 254, 237, 128, 118, 56, 164, 112, 118, 222, 207, 128, 120, 24, 134, 112, 120, 190, 177, 128, 121, 248, 104, 112, 122, 158, 147, 128, 123, 216, 74, 112, 124, 126, 117, 128, 125, 184, 44, 112, 126, 94, 87, 128, 127, 152, 14, 112, 0, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 255, 255, 162, 64, 0, 0, 255, 255, 171, 160, 0, 4, 255, 255, 185, 176, 1, 8, 76, 77, 84, 0, 67, 83, 84, 0, 67, 68, 84, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Mazatlan": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 94, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 165, 182, 232, 112, 175, 242, 110, 224, 182, 102, 86, 96, 183, 67, 210, 96, 184, 12, 54, 96, 184, 253, 134, 240, 203, 234, 113, 96, 216, 145, 180, 240, 0, 0, 112, 128, 49, 103, 132, 16, 50, 115, 22, 128, 51, 71, 102, 16, 52, 82, 248, 128, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 231, 12, 16, 57, 251, 217, 0, 58, 245, 18, 144, 59, 182, 209, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 206, 144, 65, 132, 155, 128, 66, 79, 176, 144, 67, 100, 125, 128, 68, 47, 146, 144, 69, 68, 95, 128, 70, 15, 116, 144, 71, 36, 65, 128, 71, 248, 145, 16, 73, 4, 35, 128, 73, 216, 115, 16, 74, 228, 5, 128, 75, 184, 85, 16, 76, 205, 34, 0, 77, 152, 55, 16, 78, 173, 4, 0, 79, 120, 25, 16, 80, 140, 230, 0, 81, 97, 53, 144, 82, 108, 200, 0, 83, 65, 23, 144, 84, 76, 170, 0, 85, 32, 249, 144, 86, 44, 140, 0, 87, 0, 219, 144, 88, 21, 168, 128, 88, 224, 189, 144, 89, 245, 138, 128, 90, 192, 159, 144, 91, 213, 108, 128, 92, 169, 188, 16, 93, 181, 78, 128, 94, 137, 158, 16, 95, 149, 48, 128, 96, 105, 128, 16, 97, 126, 77, 0, 98, 73, 98, 16, 99, 94, 47, 0, 100, 41, 68, 16, 101, 62, 17, 0, 102, 18, 96, 144, 103, 29, 243, 0, 103, 242, 66, 144, 104, 253, 213, 0, 105, 210, 36, 144, 106, 221, 183, 0, 107, 178, 6, 144, 108, 198, 211, 128, 109, 145, 232, 144, 110, 166, 181, 128, 111, 113, 202, 144, 112, 134, 151, 128, 113, 90, 231, 16, 114, 102, 121, 128, 115, 58, 201, 16, 116, 70, 91, 128, 117, 26, 171, 16, 118, 47, 120, 0, 118, 250, 141, 16, 120, 15, 90, 0, 120, 218, 111, 16, 121, 239, 60, 0, 122, 186, 81, 16, 123, 207, 30, 0, 124, 163, 109, 144, 125, 175, 0, 0, 126, 131, 79, 144, 127, 142, 226, 0, 0, 1, 2, 1, 2, 1, 2, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 255, 255, 156, 60, 0, 0, 255, 255, 157, 144, 0, 4, 255, 255, 171, 160, 0, 8, 255, 255, 143, 128, 0, 12, 255, 255, 171, 160, 1, 16, 255, 255, 157, 144, 0, 4, 76, 77, 84, 0, 77, 83, 84, 0, 67, 83, 84, 0, 80, 83, 84, 0, 77, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 77, 83, 84, 55, 77, 68, 84, 44, 77, 52, 46, 49, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/America/Mendoza": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 25, 52, 64, 39, 205, 195, 176, 40, 250, 103, 192, 41, 176, 72, 176, 42, 224, 225, 64, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 64, 176, 19, 176, 65, 86, 62, 192, 71, 119, 9, 176, 71, 220, 127, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 2, 3, 2, 3, 2, 4, 5, 3, 5, 2, 5, 4, 5, 5, 255, 255, 191, 124, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Menominee": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 143, 0, 0, 0, 7, 0, 0, 0, 24, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 211, 117, 243, 0, 212, 64, 235, 240, 249, 15, 74, 128, 250, 8, 103, 240, 254, 184, 43, 0, 6, 64, 223, 112, 7, 48, 208, 112, 7, 141, 39, 128, 9, 16, 178, 112, 9, 173, 163, 0, 10, 240, 148, 112, 11, 224, 147, 128, 12, 217, 176, 240, 13, 192, 117, 128, 14, 185, 146, 240, 15, 169, 146, 0, 16, 153, 116, 240, 17, 137, 116, 0, 18, 121, 86, 240, 19, 105, 86, 0, 20, 89, 56, 240, 21, 73, 56, 0, 22, 57, 26, 240, 23, 41, 26, 0, 24, 34, 55, 112, 25, 8, 252, 0, 26, 2, 25, 112, 26, 242, 24, 128, 27, 225, 251, 112, 28, 209, 250, 128, 29, 193, 221, 112, 30, 177, 220, 128, 31, 161, 191, 112, 32, 118, 15, 0, 33, 129, 161, 112, 34, 85, 241, 0, 35, 106, 189, 240, 36, 53, 211, 0, 37, 74, 159, 240, 38, 21, 181, 0, 39, 42, 129, 240, 39, 254, 209, 128, 41, 10, 99, 240, 41, 222, 179, 128, 42, 234, 69, 240, 43, 190, 149, 128, 44, 211, 98, 112, 45, 158, 119, 128, 46, 179, 68, 112, 47, 126, 89, 128, 48, 147, 38, 112, 49, 103, 118, 0, 50, 115, 8, 112, 51, 71, 88, 0, 52, 82, 234, 112, 53, 39, 58, 0, 54, 50, 204, 112, 55, 7, 28, 0, 56, 27, 232, 240, 56, 230, 254, 0, 57, 251, 202, 240, 58, 198, 224, 0, 59, 219, 172, 240, 60, 175, 252, 128, 61, 187, 142, 240, 62, 143, 222, 128, 63, 155, 112, 240, 64, 111, 192, 128, 65, 132, 141, 112, 66, 79, 162, 128, 67, 100, 111, 112, 68, 47, 132, 128, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 109, 240, 71, 211, 153, 0, 73, 13, 79, 240, 73, 179, 123, 0, 74, 237, 49, 240, 75, 156, 151, 128, 76, 214, 78, 112, 77, 124, 121, 128, 78, 182, 48, 112, 79, 92, 91, 128, 80, 150, 18, 112, 81, 60, 61, 128, 82, 117, 244, 112, 83, 28, 31, 128, 84, 85, 214, 112, 84, 252, 1, 128, 86, 53, 184, 112, 86, 229, 30, 0, 88, 30, 212, 240, 88, 197, 0, 0, 89, 254, 182, 240, 90, 164, 226, 0, 91, 222, 152, 240, 92, 132, 196, 0, 93, 190, 122, 240, 94, 100, 166, 0, 95, 158, 92, 240, 96, 77, 194, 128, 97, 135, 121, 112, 98, 45, 164, 128, 99, 103, 91, 112, 100, 13, 134, 128, 101, 71, 61, 112, 101, 237, 104, 128, 103, 39, 31, 112, 103, 205, 74, 128, 105, 7, 1, 112, 105, 173, 44, 128, 106, 230, 227, 112, 107, 150, 73, 0, 108, 207, 255, 240, 109, 118, 43, 0, 110, 175, 225, 240, 111, 86, 13, 0, 112, 143, 195, 240, 113, 53, 239, 0, 114, 111, 165, 240, 115, 21, 209, 0, 116, 79, 135, 240, 116, 254, 237, 128, 118, 56, 164, 112, 118, 222, 207, 128, 120, 24, 134, 112, 120, 190, 177, 128, 121, 248, 104, 112, 122, 158, 147, 128, 123, 216, 74, 112, 124, 126, 117, 128, 125, 184, 44, 112, 126, 94, 87, 128, 127, 152, 14, 112, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 5, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 173, 221, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 255, 255, 171, 160, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Merida": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 88, 0, 0, 0, 5, 0, 0, 0, 16, 128, 0, 0, 0, 165, 182, 218, 96, 22, 134, 213, 96, 24, 76, 75, 80, 49, 103, 118, 0, 50, 115, 8, 112, 51, 71, 88, 0, 52, 82, 234, 112, 53, 39, 58, 0, 54, 50, 204, 112, 55, 7, 28, 0, 56, 27, 232, 240, 56, 230, 254, 0, 57, 251, 202, 240, 58, 245, 4, 128, 59, 182, 194, 240, 60, 175, 252, 128, 61, 187, 142, 240, 62, 143, 222, 128, 63, 155, 112, 240, 64, 111, 192, 128, 65, 132, 141, 112, 66, 79, 162, 128, 67, 100, 111, 112, 68, 47, 132, 128, 69, 68, 81, 112, 70, 15, 102, 128, 71, 36, 51, 112, 71, 248, 131, 0, 73, 4, 21, 112, 73, 216, 101, 0, 74, 227, 247, 112, 75, 184, 71, 0, 76, 205, 19, 240, 77, 152, 41, 0, 78, 172, 245, 240, 79, 120, 11, 0, 80, 140, 215, 240, 81, 97, 39, 128, 82, 108, 185, 240, 83, 65, 9, 128, 84, 76, 155, 240, 85, 32, 235, 128, 86, 44, 125, 240, 87, 0, 205, 128, 88, 21, 154, 112, 88, 224, 175, 128, 89, 245, 124, 112, 90, 192, 145, 128, 91, 213, 94, 112, 92, 169, 174, 0, 93, 181, 64, 112, 94, 137, 144, 0, 95, 149, 34, 112, 96, 105, 114, 0, 97, 126, 62, 240, 98, 73, 84, 0, 99, 94, 32, 240, 100, 41, 54, 0, 101, 62, 2, 240, 102, 18, 82, 128, 103, 29, 228, 240, 103, 242, 52, 128, 104, 253, 198, 240, 105, 210, 22, 128, 106, 221, 168, 240, 107, 177, 248, 128, 108, 198, 197, 112, 109, 145, 218, 128, 110, 166, 167, 112, 111, 113, 188, 128, 112, 134, 137, 112, 113, 90, 217, 0, 114, 102, 107, 112, 115, 58, 187, 0, 116, 70, 77, 112, 117, 26, 157, 0, 118, 47, 105, 240, 118, 250, 127, 0, 120, 15, 75, 240, 120, 218, 97, 0, 121, 239, 45, 240, 122, 186, 67, 0, 123, 207, 15, 240, 124, 163, 95, 128, 125, 174, 241, 240, 126, 131, 65, 128, 127, 142, 211, 240, 0, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 255, 255, 171, 252, 0, 0, 255, 255, 171, 160, 0, 4, 255, 255, 185, 176, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 171, 160, 0, 4, 76, 77, 84, 0, 67, 83, 84, 0, 69, 83, 84, 0, 67, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 52, 46, 49, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/America/Metlakatla": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 79, 0, 0, 0, 7, 0, 0, 0, 30, 128, 0, 0, 0, 203, 137, 26, 160, 210, 35, 244, 112, 210, 97, 38, 16, 254, 184, 71, 32, 255, 168, 42, 16, 0, 152, 41, 32, 1, 136, 12, 16, 2, 120, 11, 32, 3, 113, 40, 144, 4, 97, 39, 160, 5, 81, 10, 144, 6, 65, 9, 160, 7, 48, 236, 144, 7, 141, 67, 160, 9, 16, 206, 144, 9, 173, 191, 32, 10, 240, 176, 144, 11, 224, 175, 160, 12, 217, 205, 16, 13, 192, 145, 160, 14, 185, 175, 16, 15, 169, 174, 32, 16, 153, 145, 16, 17, 137, 144, 32, 18, 121, 115, 16, 19, 105, 114, 32, 20, 89, 85, 16, 21, 73, 84, 32, 22, 57, 55, 16, 23, 41, 54, 32, 24, 34, 83, 144, 25, 9, 24, 32, 26, 2, 53, 144, 86, 53, 226, 160, 86, 229, 72, 48, 88, 30, 255, 32, 88, 197, 42, 48, 89, 254, 225, 32, 90, 165, 12, 48, 91, 222, 195, 32, 92, 132, 238, 48, 93, 190, 165, 32, 94, 100, 208, 48, 95, 158, 135, 32, 96, 77, 236, 176, 97, 135, 163, 160, 98, 45, 206, 176, 99, 103, 133, 160, 100, 13, 176, 176, 101, 71, 103, 160, 101, 237, 146, 176, 103, 39, 73, 160, 103, 205, 116, 176, 105, 7, 43, 160, 105, 173, 86, 176, 106, 231, 13, 160, 107, 150, 115, 48, 108, 208, 42, 32, 109, 118, 85, 48, 110, 176, 12, 32, 111, 86, 55, 48, 112, 143, 238, 32, 113, 54, 25, 48, 114, 111, 208, 32, 115, 21, 251, 48, 116, 79, 178, 32, 116, 255, 23, 176, 118, 56, 206, 160, 118, 222, 249, 176, 120, 24, 176, 160, 120, 190, 219, 176, 121, 248, 146, 160, 122, 158, 189, 176, 123, 216, 116, 160, 124, 126, 159, 176, 125, 184, 86, 160, 126, 94, 129, 176, 127, 152, 56, 160, 1, 2, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 255, 255, 132, 166, 0, 0, 255, 255, 143, 128, 0, 4, 255, 255, 157, 144, 1, 8, 255, 255, 157, 144, 1, 12, 255, 255, 157, 144, 1, 16, 255, 255, 129, 112, 0, 20, 255, 255, 143, 128, 1, 25, 76, 77, 84, 0, 80, 83, 84, 0, 80, 87, 84, 0, 80, 80, 84, 0, 80, 68, 84, 0, 65, 75, 83, 84, 0, 65, 75, 68, 84, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 10, 65, 75, 83, 84, 57, 65, 75, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Mexico_City": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 99, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 165, 182, 232, 112, 175, 242, 110, 224, 182, 102, 86, 96, 183, 67, 210, 96, 184, 12, 54, 96, 184, 253, 134, 240, 197, 222, 176, 96, 198, 151, 52, 80, 201, 85, 241, 224, 201, 234, 221, 80, 207, 2, 198, 224, 207, 183, 86, 80, 218, 153, 21, 224, 219, 118, 131, 208, 49, 103, 118, 0, 50, 115, 8, 112, 51, 71, 88, 0, 52, 82, 234, 112, 53, 39, 58, 0, 54, 50, 204, 112, 55, 7, 28, 0, 56, 27, 232, 240, 56, 230, 254, 0, 57, 251, 202, 240, 58, 245, 4, 128, 59, 182, 194, 240, 60, 175, 252, 128, 61, 187, 142, 240, 62, 143, 222, 128, 63, 155, 112, 240, 64, 111, 192, 128, 65, 132, 141, 112, 66, 79, 162, 128, 67, 100, 111, 112, 68, 47, 132, 128, 69, 68, 81, 112, 70, 15, 102, 128, 71, 36, 51, 112, 71, 248, 131, 0, 73, 4, 21, 112, 73, 216, 101, 0, 74, 227, 247, 112, 75, 184, 71, 0, 76, 205, 19, 240, 77, 152, 41, 0, 78, 172, 245, 240, 79, 120, 11, 0, 80, 140, 215, 240, 81, 97, 39, 128, 82, 108, 185, 240, 83, 65, 9, 128, 84, 76, 155, 240, 85, 32, 235, 128, 86, 44, 125, 240, 87, 0, 205, 128, 88, 21, 154, 112, 88, 224, 175, 128, 89, 245, 124, 112, 90, 192, 145, 128, 91, 213, 94, 112, 92, 169, 174, 0, 93, 181, 64, 112, 94, 137, 144, 0, 95, 149, 34, 112, 96, 105, 114, 0, 97, 126, 62, 240, 98, 73, 84, 0, 99, 94, 32, 240, 100, 41, 54, 0, 101, 62, 2, 240, 102, 18, 82, 128, 103, 29, 228, 240, 103, 242, 52, 128, 104, 253, 198, 240, 105, 210, 22, 128, 106, 221, 168, 240, 107, 177, 248, 128, 108, 198, 197, 112, 109, 145, 218, 128, 110, 166, 167, 112, 111, 113, 188, 128, 112, 134, 137, 112, 113, 90, 217, 0, 114, 102, 107, 112, 115, 58, 187, 0, 116, 70, 77, 112, 117, 26, 157, 0, 118, 47, 105, 240, 118, 250, 127, 0, 120, 15, 75, 240, 120, 218, 97, 0, 121, 239, 45, 240, 122, 186, 67, 0, 123, 207, 15, 240, 124, 163, 95, 128, 125, 174, 241, 240, 126, 131, 65, 128, 127, 142, 211, 240, 0, 1, 2, 1, 2, 1, 2, 3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 255, 255, 163, 12, 0, 0, 255, 255, 157, 144, 0, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 76, 77, 84, 0, 77, 83, 84, 0, 67, 83, 84, 0, 67, 68, 84, 0, 67, 87, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 52, 46, 49, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/America/Miquelon": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 106, 0, 0, 0, 4, 0, 0, 0, 16, 128, 0, 0, 0, 145, 182, 56, 168, 19, 110, 99, 192, 32, 117, 228, 208, 33, 129, 119, 64, 34, 85, 198, 208, 35, 106, 147, 192, 36, 53, 168, 208, 37, 74, 117, 192, 38, 21, 138, 208, 39, 42, 87, 192, 39, 254, 167, 80, 41, 10, 57, 192, 41, 222, 137, 80, 42, 234, 27, 192, 43, 190, 107, 80, 44, 211, 56, 64, 45, 158, 77, 80, 46, 179, 26, 64, 47, 126, 47, 80, 48, 146, 252, 64, 49, 103, 75, 208, 50, 114, 222, 64, 51, 71, 45, 208, 52, 82, 192, 64, 53, 39, 15, 208, 54, 50, 162, 64, 55, 6, 241, 208, 56, 27, 190, 192, 56, 230, 211, 208, 57, 251, 160, 192, 58, 198, 181, 208, 59, 219, 130, 192, 60, 175, 210, 80, 61, 187, 100, 192, 62, 143, 180, 80, 63, 155, 70, 192, 64, 111, 150, 80, 65, 132, 99, 64, 66, 79, 120, 80, 67, 100, 69, 64, 68, 47, 90, 80, 69, 68, 39, 64, 69, 243, 140, 208, 71, 45, 67, 192, 71, 211, 110, 208, 73, 13, 37, 192, 73, 179, 80, 208, 74, 237, 7, 192, 75, 156, 109, 80, 76, 214, 36, 64, 77, 124, 79, 80, 78, 182, 6, 64, 79, 92, 49, 80, 80, 149, 232, 64, 81, 60, 19, 80, 82, 117, 202, 64, 83, 27, 245, 80, 84, 85, 172, 64, 84, 251, 215, 80, 86, 53, 142, 64, 86, 228, 243, 208, 88, 30, 170, 192, 88, 196, 213, 208, 89, 254, 140, 192, 90, 164, 183, 208, 91, 222, 110, 192, 92, 132, 153, 208, 93, 190, 80, 192, 94, 100, 123, 208, 95, 158, 50, 192, 96, 77, 152, 80, 97, 135, 79, 64, 98, 45, 122, 80, 99, 103, 49, 64, 100, 13, 92, 80, 101, 71, 19, 64, 101, 237, 62, 80, 103, 38, 245, 64, 103, 205, 32, 80, 105, 6, 215, 64, 105, 173, 2, 80, 106, 230, 185, 64, 107, 150, 30, 208, 108, 207, 213, 192, 109, 118, 0, 208, 110, 175, 183, 192, 111, 85, 226, 208, 112, 143, 153, 192, 113, 53, 196, 208, 114, 111, 123, 192, 115, 21, 166, 208, 116, 79, 93, 192, 116, 254, 195, 80, 118, 56, 122, 64, 118, 222, 165, 80, 120, 24, 92, 64, 120, 190, 135, 80, 121, 248, 62, 64, 122, 158, 105, 80, 123, 216, 32, 64, 124, 126, 75, 80, 125, 184, 2, 64, 126, 94, 45, 80, 127, 151, 228, 64, 127, 255, 255, 255, 0, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 2, 255, 255, 203, 88, 0, 0, 255, 255, 199, 192, 0, 4, 255, 255, 213, 208, 0, 8, 255, 255, 227, 224, 1, 12, 76, 77, 84, 0, 65, 83, 84, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 60, 45, 48, 50, 62, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Moncton": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 207, 0, 0, 0, 6, 0, 0, 0, 24, 128, 0, 0, 0, 128, 241, 182, 80, 158, 184, 133, 96, 159, 186, 221, 80, 187, 60, 56, 208, 187, 180, 35, 64, 189, 28, 26, 208, 189, 148, 5, 64, 190, 251, 252, 208, 191, 115, 231, 64, 192, 219, 222, 208, 193, 83, 201, 64, 194, 187, 192, 208, 195, 51, 171, 64, 196, 155, 162, 208, 197, 19, 141, 64, 198, 112, 248, 208, 199, 13, 205, 64, 200, 72, 241, 208, 200, 237, 175, 64, 202, 22, 94, 208, 202, 214, 203, 192, 203, 136, 226, 96, 210, 35, 244, 112, 210, 96, 237, 208, 211, 117, 214, 224, 212, 64, 207, 208, 213, 85, 184, 224, 214, 32, 177, 208, 215, 53, 154, 224, 216, 0, 147, 208, 217, 21, 124, 224, 217, 224, 117, 208, 218, 254, 153, 96, 219, 192, 87, 208, 220, 222, 123, 96, 221, 169, 116, 80, 222, 190, 93, 96, 223, 137, 86, 80, 224, 158, 63, 96, 225, 105, 56, 80, 226, 126, 33, 96, 227, 73, 26, 80, 228, 94, 3, 96, 229, 40, 252, 80, 230, 71, 31, 224, 231, 18, 24, 208, 232, 39, 1, 224, 233, 22, 228, 208, 234, 6, 227, 224, 234, 246, 198, 208, 235, 230, 197, 224, 236, 214, 168, 208, 237, 198, 167, 224, 238, 191, 197, 80, 239, 175, 196, 96, 240, 159, 167, 80, 241, 143, 166, 96, 242, 127, 137, 80, 243, 111, 136, 96, 244, 95, 107, 80, 245, 79, 106, 96, 246, 63, 77, 80, 247, 47, 76, 96, 248, 40, 105, 208, 249, 15, 46, 96, 250, 8, 75, 208, 250, 248, 74, 224, 251, 232, 45, 208, 252, 216, 44, 224, 253, 200, 15, 208, 254, 184, 14, 224, 255, 167, 241, 208, 0, 151, 240, 224, 1, 135, 211, 208, 2, 119, 210, 224, 3, 112, 240, 80, 4, 96, 239, 96, 5, 80, 210, 80, 8, 32, 179, 96, 9, 16, 150, 80, 10, 0, 149, 96, 10, 240, 120, 80, 11, 224, 119, 96, 12, 217, 148, 208, 13, 192, 89, 96, 14, 185, 118, 208, 15, 169, 117, 224, 16, 153, 88, 208, 17, 137, 87, 224, 18, 121, 58, 208, 19, 105, 57, 224, 20, 89, 28, 208, 21, 73, 27, 224, 22, 56, 254, 208, 23, 40, 253, 224, 24, 34, 27, 80, 25, 8, 223, 224, 26, 1, 253, 80, 26, 241, 252, 96, 27, 225, 223, 80, 28, 209, 222, 96, 29, 193, 193, 80, 30, 177, 192, 96, 31, 161, 163, 80, 32, 117, 242, 224, 33, 129, 133, 80, 34, 85, 212, 224, 35, 106, 161, 208, 36, 53, 182, 224, 37, 74, 131, 208, 38, 21, 152, 224, 39, 42, 101, 208, 39, 254, 181, 96, 41, 10, 71, 208, 41, 222, 151, 96, 42, 234, 41, 208, 43, 190, 93, 124, 44, 211, 42, 108, 45, 158, 63, 124, 46, 179, 12, 108, 47, 126, 33, 124, 48, 146, 238, 108, 49, 103, 61, 252, 50, 114, 208, 108, 51, 71, 31, 252, 52, 82, 178, 108, 53, 39, 1, 252, 54, 50, 148, 108, 55, 6, 227, 252, 56, 27, 176, 236, 56, 230, 197, 252, 57, 251, 146, 236, 58, 198, 167, 252, 59, 219, 116, 236, 60, 175, 196, 124, 61, 187, 86, 236, 62, 143, 166, 124, 63, 155, 56, 236, 64, 111, 136, 124, 65, 132, 85, 108, 66, 79, 106, 124, 67, 100, 55, 108, 68, 47, 76, 124, 69, 68, 25, 108, 69, 243, 154, 224, 71, 45, 81, 208, 71, 211, 124, 224, 73, 13, 51, 208, 73, 179, 94, 224, 74, 237, 21, 208, 75, 156, 123, 96, 76, 214, 50, 80, 77, 124, 93, 96, 78, 182, 20, 80, 79, 92, 63, 96, 80, 149, 246, 80, 81, 60, 33, 96, 82, 117, 216, 80, 83, 28, 3, 96, 84, 85, 186, 80, 84, 251, 229, 96, 86, 53, 156, 80, 86, 229, 1, 224, 88, 30, 184, 208, 88, 196, 227, 224, 89, 254, 154, 208, 90, 164, 197, 224, 91, 222, 124, 208, 92, 132, 167, 224, 93, 190, 94, 208, 94, 100, 137, 224, 95, 158, 64, 208, 96, 77, 166, 96, 97, 135, 93, 80, 98, 45, 136, 96, 99, 103, 63, 80, 100, 13, 106, 96, 101, 71, 33, 80, 101, 237, 76, 96, 103, 39, 3, 80, 103, 205, 46, 96, 105, 6, 229, 80, 105, 173, 16, 96, 106, 230, 199, 80, 107, 150, 44, 224, 108, 207, 227, 208, 109, 118, 14, 224, 110, 175, 197, 208, 111, 85, 240, 224, 112, 143, 167, 208, 113, 53, 210, 224, 114, 111, 137, 208, 115, 21, 180, 224, 116, 79, 107, 208, 116, 254, 209, 96, 118, 56, 136, 80, 118, 222, 179, 96, 120, 24, 106, 80, 120, 190, 149, 96, 121, 248, 76, 80, 122, 158, 119, 96, 123, 216, 46, 80, 124, 126, 89, 96, 125, 184, 16, 80, 126, 94, 59, 96, 127, 151, 242, 80, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 4, 5, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 255, 255, 195, 68, 0, 0, 255, 255, 185, 176, 0, 4, 255, 255, 213, 208, 1, 8, 255, 255, 199, 192, 0, 12, 255, 255, 213, 208, 1, 16, 255, 255, 213, 208, 1, 20, 76, 77, 84, 0, 69, 83, 84, 0, 65, 68, 84, 0, 65, 83, 84, 0, 65, 87, 84, 0, 65, 80, 84, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 10, 65, 83, 84, 52, 65, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Monterrey": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 88, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 165, 182, 218, 96, 34, 85, 241, 0, 35, 106, 189, 240, 49, 103, 118, 0, 50, 115, 8, 112, 51, 71, 88, 0, 52, 82, 234, 112, 53, 39, 58, 0, 54, 50, 204, 112, 55, 7, 28, 0, 56, 27, 232, 240, 56, 230, 254, 0, 57, 251, 202, 240, 58, 245, 4, 128, 59, 182, 194, 240, 60, 175, 252, 128, 61, 187, 142, 240, 62, 143, 222, 128, 63, 155, 112, 240, 64, 111, 192, 128, 65, 132, 141, 112, 66, 79, 162, 128, 67, 100, 111, 112, 68, 47, 132, 128, 69, 68, 81, 112, 70, 15, 102, 128, 71, 36, 51, 112, 71, 248, 131, 0, 73, 4, 21, 112, 73, 216, 101, 0, 74, 227, 247, 112, 75, 184, 71, 0, 76, 205, 19, 240, 77, 152, 41, 0, 78, 172, 245, 240, 79, 120, 11, 0, 80, 140, 215, 240, 81, 97, 39, 128, 82, 108, 185, 240, 83, 65, 9, 128, 84, 76, 155, 240, 85, 32, 235, 128, 86, 44, 125, 240, 87, 0, 205, 128, 88, 21, 154, 112, 88, 224, 175, 128, 89, 245, 124, 112, 90, 192, 145, 128, 91, 213, 94, 112, 92, 169, 174, 0, 93, 181, 64, 112, 94, 137, 144, 0, 95, 149, 34, 112, 96, 105, 114, 0, 97, 126, 62, 240, 98, 73, 84, 0, 99, 94, 32, 240, 100, 41, 54, 0, 101, 62, 2, 240, 102, 18, 82, 128, 103, 29, 228, 240, 103, 242, 52, 128, 104, 253, 198, 240, 105, 210, 22, 128, 106, 221, 168, 240, 107, 177, 248, 128, 108, 198, 197, 112, 109, 145, 218, 128, 110, 166, 167, 112, 111, 113, 188, 128, 112, 134, 137, 112, 113, 90, 217, 0, 114, 102, 107, 112, 115, 58, 187, 0, 116, 70, 77, 112, 117, 26, 157, 0, 118, 47, 105, 240, 118, 250, 127, 0, 120, 15, 75, 240, 120, 218, 97, 0, 121, 239, 45, 240, 122, 186, 67, 0, 123, 207, 15, 240, 124, 163, 95, 128, 125, 174, 241, 240, 126, 131, 65, 128, 127, 142, 211, 240, 0, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 255, 255, 161, 244, 0, 0, 255, 255, 171, 160, 0, 4, 255, 255, 185, 176, 1, 8, 76, 77, 84, 0, 67, 83, 84, 0, 67, 68, 84, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 52, 46, 49, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/America/Montevideo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 88, 0, 0, 0, 9, 0, 0, 0, 28, 128, 0, 0, 0, 162, 146, 135, 172, 169, 1, 37, 184, 169, 241, 15, 176, 170, 226, 89, 56, 171, 210, 67, 48, 172, 195, 140, 184, 173, 179, 118, 176, 187, 244, 181, 184, 188, 191, 181, 176, 189, 212, 151, 184, 190, 159, 151, 176, 191, 180, 121, 184, 192, 127, 121, 176, 193, 157, 150, 56, 194, 95, 91, 176, 195, 125, 120, 56, 196, 63, 61, 176, 197, 93, 90, 56, 198, 31, 31, 176, 199, 61, 60, 56, 200, 8, 60, 48, 201, 29, 30, 56, 201, 232, 30, 48, 202, 139, 159, 56, 203, 85, 77, 176, 205, 30, 205, 56, 205, 149, 95, 32, 236, 11, 133, 176, 236, 242, 46, 32, 237, 69, 74, 176, 237, 133, 214, 32, 247, 19, 114, 176, 247, 250, 27, 32, 248, 243, 84, 176, 250, 9, 115, 32, 250, 211, 54, 176, 251, 234, 166, 160, 252, 254, 62, 48, 253, 247, 98, 168, 254, 223, 113, 176, 255, 216, 150, 40, 0, 192, 165, 48, 1, 185, 201, 168, 4, 88, 220, 48, 4, 237, 199, 160, 7, 223, 239, 176, 9, 90, 71, 40, 12, 177, 221, 160, 14, 231, 127, 48, 15, 131, 2, 32, 18, 85, 134, 48, 19, 110, 71, 160, 33, 195, 84, 48, 34, 59, 62, 160, 35, 161, 228, 176, 36, 25, 207, 32, 37, 74, 103, 176, 37, 240, 118, 160, 39, 33, 15, 48, 39, 208, 88, 160, 41, 10, 43, 176, 41, 176, 58, 160, 42, 224, 211, 48, 43, 144, 28, 160, 65, 76, 246, 48, 66, 70, 47, 192, 67, 72, 163, 208, 68, 19, 156, 192, 69, 31, 75, 80, 69, 243, 126, 192, 71, 8, 103, 208, 71, 211, 96, 192, 72, 232, 73, 208, 73, 179, 66, 192, 74, 200, 43, 208, 75, 156, 95, 64, 76, 168, 13, 208, 77, 124, 65, 64, 78, 135, 239, 208, 79, 92, 35, 64, 80, 113, 12, 80, 81, 60, 5, 64, 82, 80, 238, 80, 83, 27, 231, 64, 84, 48, 208, 80, 84, 251, 201, 64, 127, 255, 255, 255, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 2, 4, 2, 4, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 7, 5, 7, 5, 7, 5, 6, 5, 7, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 5, 255, 255, 203, 84, 0, 0, 255, 255, 203, 84, 0, 4, 255, 255, 213, 208, 1, 8, 255, 255, 206, 200, 0, 12, 255, 255, 206, 200, 0, 12, 255, 255, 213, 208, 0, 8, 255, 255, 227, 224, 1, 18, 255, 255, 220, 216, 1, 22, 255, 255, 227, 224, 1, 18, 76, 77, 84, 0, 77, 77, 84, 0, 45, 48, 51, 0, 45, 48, 51, 51, 48, 0, 45, 48, 50, 0, 45, 48, 50, 51, 48, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Montreal": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 233, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 158, 184, 147, 112, 159, 186, 235, 96, 160, 135, 46, 200, 161, 154, 177, 64, 162, 148, 6, 240, 163, 85, 169, 64, 164, 134, 93, 240, 165, 40, 120, 96, 166, 102, 63, 240, 167, 12, 78, 224, 168, 70, 33, 240, 168, 236, 48, 224, 170, 28, 201, 112, 170, 213, 77, 96, 171, 252, 171, 112, 172, 181, 47, 96, 173, 220, 141, 112, 174, 149, 17, 96, 175, 188, 111, 112, 176, 126, 45, 224, 177, 156, 81, 112, 178, 103, 74, 96, 179, 124, 51, 112, 180, 71, 44, 96, 181, 92, 21, 112, 182, 39, 14, 96, 183, 59, 247, 112, 184, 6, 240, 96, 185, 37, 19, 240, 185, 230, 210, 96, 187, 4, 245, 240, 187, 207, 238, 224, 188, 228, 215, 240, 189, 175, 208, 224, 190, 196, 185, 240, 191, 143, 178, 224, 192, 164, 155, 240, 193, 111, 148, 224, 194, 132, 125, 240, 195, 79, 118, 224, 196, 100, 95, 240, 197, 47, 88, 224, 198, 77, 124, 112, 199, 15, 58, 224, 200, 45, 94, 112, 203, 136, 240, 112, 210, 35, 244, 112, 210, 96, 251, 224, 211, 117, 228, 240, 212, 64, 221, 224, 213, 85, 170, 208, 214, 32, 163, 192, 215, 53, 140, 208, 216, 0, 133, 192, 217, 21, 110, 208, 218, 51, 118, 64, 218, 254, 167, 112, 220, 19, 116, 96, 220, 222, 137, 112, 221, 169, 130, 96, 222, 190, 107, 112, 223, 137, 100, 96, 224, 158, 77, 112, 225, 105, 70, 96, 226, 126, 47, 112, 227, 73, 40, 96, 228, 94, 17, 112, 229, 41, 10, 96, 230, 71, 45, 240, 231, 18, 38, 224, 232, 39, 15, 240, 233, 22, 242, 224, 234, 6, 241, 240, 234, 246, 212, 224, 235, 230, 211, 240, 236, 214, 182, 224, 237, 198, 181, 240, 238, 191, 211, 96, 239, 175, 210, 112, 240, 159, 181, 96, 241, 143, 180, 112, 242, 127, 151, 96, 243, 111, 150, 112, 244, 95, 121, 96, 245, 79, 120, 112, 246, 63, 91, 96, 247, 47, 90, 112, 248, 40, 119, 224, 249, 15, 60, 112, 250, 8, 89, 224, 250, 248, 88, 240, 251, 232, 59, 224, 252, 216, 58, 240, 253, 200, 29, 224, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 2, 119, 224, 240, 3, 112, 254, 96, 4, 96, 253, 112, 5, 80, 224, 96, 6, 64, 223, 112, 7, 48, 194, 96, 8, 32, 193, 112, 9, 16, 164, 96, 10, 0, 163, 112, 10, 240, 134, 96, 11, 224, 133, 112, 12, 217, 162, 224, 13, 192, 103, 112, 14, 185, 132, 224, 15, 169, 131, 240, 16, 153, 102, 224, 17, 137, 101, 240, 18, 121, 72, 224, 19, 105, 71, 240, 20, 89, 42, 224, 21, 73, 41, 240, 22, 57, 12, 224, 23, 41, 11, 240, 24, 34, 41, 96, 25, 8, 237, 240, 26, 2, 11, 96, 26, 242, 10, 112, 27, 225, 237, 96, 28, 209, 236, 112, 29, 193, 207, 96, 30, 177, 206, 112, 31, 161, 177, 96, 32, 118, 0, 240, 33, 129, 147, 96, 34, 85, 226, 240, 35, 106, 175, 224, 36, 53, 196, 240, 37, 74, 145, 224, 38, 21, 166, 240, 39, 42, 115, 224, 39, 254, 195, 112, 41, 10, 85, 224, 41, 222, 165, 112, 42, 234, 55, 224, 43, 190, 135, 112, 44, 211, 84, 96, 45, 158, 105, 112, 46, 179, 54, 96, 47, 126, 75, 112, 48, 147, 24, 96, 49, 103, 103, 240, 50, 114, 250, 96, 51, 71, 73, 240, 52, 82, 220, 96, 53, 39, 43, 240, 54, 50, 190, 96, 55, 7, 13, 240, 56, 27, 218, 224, 56, 230, 239, 240, 57, 251, 188, 224, 58, 198, 209, 240, 59, 219, 158, 224, 60, 175, 238, 112, 61, 187, 128, 224, 62, 143, 208, 112, 63, 155, 98, 224, 64, 111, 178, 112, 65, 132, 127, 96, 66, 79, 148, 112, 67, 100, 97, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 181, 148, 0, 0, 255, 255, 199, 192, 1, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 1, 12, 255, 255, 199, 192, 1, 16, 76, 77, 84, 0, 69, 68, 84, 0, 69, 83, 84, 0, 69, 87, 84, 0, 69, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Montserrat": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 147, 55, 51, 172, 0, 1, 255, 255, 198, 84, 0, 0, 255, 255, 199, 192, 0, 4, 76, 77, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Nassau": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 150, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 147, 55, 66, 138, 245, 79, 120, 112, 246, 63, 91, 96, 247, 47, 90, 112, 248, 40, 119, 224, 249, 15, 60, 112, 250, 8, 89, 224, 250, 248, 88, 240, 251, 232, 59, 224, 252, 216, 58, 240, 253, 200, 29, 224, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 2, 119, 224, 240, 3, 112, 254, 96, 4, 96, 253, 112, 5, 80, 224, 96, 6, 64, 223, 112, 7, 48, 194, 96, 8, 32, 193, 112, 9, 16, 164, 96, 10, 0, 163, 112, 10, 240, 134, 96, 11, 224, 133, 112, 12, 217, 162, 224, 13, 192, 103, 112, 14, 185, 132, 224, 15, 169, 131, 240, 16, 153, 102, 224, 17, 137, 101, 240, 18, 121, 72, 224, 19, 105, 71, 240, 20, 89, 42, 224, 21, 73, 41, 240, 22, 57, 12, 224, 23, 41, 11, 240, 24, 34, 41, 96, 25, 8, 237, 240, 26, 2, 11, 96, 26, 242, 10, 112, 27, 225, 237, 96, 28, 209, 236, 112, 29, 193, 207, 96, 30, 177, 206, 112, 31, 161, 177, 96, 32, 118, 0, 240, 33, 129, 147, 96, 34, 85, 226, 240, 35, 106, 175, 224, 36, 53, 196, 240, 37, 74, 145, 224, 38, 21, 166, 240, 39, 42, 115, 224, 39, 254, 195, 112, 41, 10, 85, 224, 41, 222, 165, 112, 42, 234, 55, 224, 43, 190, 135, 112, 44, 211, 84, 96, 45, 158, 105, 112, 46, 179, 54, 96, 47, 126, 75, 112, 48, 147, 24, 96, 49, 103, 103, 240, 50, 114, 250, 96, 51, 71, 73, 240, 52, 82, 220, 96, 53, 39, 43, 240, 54, 50, 190, 96, 55, 7, 13, 240, 56, 27, 218, 224, 56, 230, 239, 240, 57, 251, 188, 224, 58, 198, 209, 240, 59, 219, 158, 224, 60, 175, 238, 112, 61, 187, 128, 224, 62, 143, 208, 112, 63, 155, 98, 224, 64, 111, 178, 112, 65, 132, 127, 96, 66, 79, 148, 112, 67, 100, 97, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 183, 118, 0, 0, 255, 255, 199, 192, 1, 4, 255, 255, 185, 176, 0, 8, 76, 77, 84, 0, 69, 68, 84, 0, 69, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/New_York": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 236, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 158, 166, 30, 112, 159, 186, 235, 96, 160, 134, 0, 112, 161, 154, 205, 96, 162, 101, 226, 112, 163, 131, 233, 224, 164, 106, 174, 112, 165, 53, 167, 96, 166, 83, 202, 240, 167, 21, 137, 96, 168, 51, 172, 240, 168, 254, 165, 224, 170, 19, 142, 240, 170, 222, 135, 224, 171, 243, 112, 240, 172, 190, 105, 224, 173, 211, 82, 240, 174, 158, 75, 224, 175, 179, 52, 240, 176, 126, 45, 224, 177, 156, 81, 112, 178, 103, 74, 96, 179, 124, 51, 112, 180, 71, 44, 96, 181, 92, 21, 112, 182, 39, 14, 96, 183, 59, 247, 112, 184, 6, 240, 96, 185, 27, 217, 112, 185, 230, 210, 96, 187, 4, 245, 240, 187, 198, 180, 96, 188, 228, 215, 240, 189, 175, 208, 224, 190, 196, 185, 240, 191, 143, 178, 224, 192, 164, 155, 240, 193, 111, 148, 224, 194, 132, 125, 240, 195, 79, 118, 224, 196, 100, 95, 240, 197, 47, 88, 224, 198, 77, 124, 112, 199, 15, 58, 224, 200, 45, 94, 112, 200, 248, 87, 96, 202, 13, 64, 112, 202, 216, 57, 96, 203, 136, 240, 112, 210, 35, 244, 112, 210, 96, 251, 224, 211, 117, 228, 240, 212, 64, 221, 224, 213, 85, 198, 240, 214, 32, 191, 224, 215, 53, 168, 240, 216, 0, 161, 224, 217, 21, 138, 240, 217, 224, 131, 224, 218, 254, 167, 112, 219, 192, 101, 224, 220, 222, 137, 112, 221, 169, 130, 96, 222, 190, 107, 112, 223, 137, 100, 96, 224, 158, 77, 112, 225, 105, 70, 96, 226, 126, 47, 112, 227, 73, 40, 96, 228, 94, 17, 112, 229, 87, 46, 224, 230, 71, 45, 240, 231, 55, 16, 224, 232, 39, 15, 240, 233, 22, 242, 224, 234, 6, 241, 240, 234, 246, 212, 224, 235, 230, 211, 240, 236, 214, 182, 224, 237, 198, 181, 240, 238, 191, 211, 96, 239, 175, 210, 112, 240, 159, 181, 96, 241, 143, 180, 112, 242, 127, 151, 96, 243, 111, 150, 112, 244, 95, 121, 96, 245, 79, 120, 112, 246, 63, 91, 96, 247, 47, 90, 112, 248, 40, 119, 224, 249, 15, 60, 112, 250, 8, 89, 224, 250, 248, 88, 240, 251, 232, 59, 224, 252, 216, 58, 240, 253, 200, 29, 224, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 2, 119, 224, 240, 3, 112, 254, 96, 4, 96, 253, 112, 5, 80, 224, 96, 6, 64, 223, 112, 7, 48, 194, 96, 7, 141, 25, 112, 9, 16, 164, 96, 9, 173, 148, 240, 10, 240, 134, 96, 11, 224, 133, 112, 12, 217, 162, 224, 13, 192, 103, 112, 14, 185, 132, 224, 15, 169, 131, 240, 16, 153, 102, 224, 17, 137, 101, 240, 18, 121, 72, 224, 19, 105, 71, 240, 20, 89, 42, 224, 21, 73, 41, 240, 22, 57, 12, 224, 23, 41, 11, 240, 24, 34, 41, 96, 25, 8, 237, 240, 26, 2, 11, 96, 26, 242, 10, 112, 27, 225, 237, 96, 28, 209, 236, 112, 29, 193, 207, 96, 30, 177, 206, 112, 31, 161, 177, 96, 32, 118, 0, 240, 33, 129, 147, 96, 34, 85, 226, 240, 35, 106, 175, 224, 36, 53, 196, 240, 37, 74, 145, 224, 38, 21, 166, 240, 39, 42, 115, 224, 39, 254, 195, 112, 41, 10, 85, 224, 41, 222, 165, 112, 42, 234, 55, 224, 43, 190, 135, 112, 44, 211, 84, 96, 45, 158, 105, 112, 46, 179, 54, 96, 47, 126, 75, 112, 48, 147, 24, 96, 49, 103, 103, 240, 50, 114, 250, 96, 51, 71, 73, 240, 52, 82, 220, 96, 53, 39, 43, 240, 54, 50, 190, 96, 55, 7, 13, 240, 56, 27, 218, 224, 56, 230, 239, 240, 57, 251, 188, 224, 58, 198, 209, 240, 59, 219, 158, 224, 60, 175, 238, 112, 61, 187, 128, 224, 62, 143, 208, 112, 63, 155, 98, 224, 64, 111, 178, 112, 65, 132, 127, 96, 66, 79, 148, 112, 67, 100, 97, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 186, 158, 0, 0, 255, 255, 199, 192, 1, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 1, 12, 255, 255, 199, 192, 1, 16, 76, 77, 84, 0, 69, 68, 84, 0, 69, 83, 84, 0, 69, 87, 84, 0, 69, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Nipigon": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 135, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 158, 184, 147, 112, 159, 186, 235, 96, 200, 248, 73, 80, 203, 136, 240, 112, 210, 35, 244, 112, 210, 96, 251, 224, 8, 32, 193, 112, 9, 16, 164, 96, 10, 0, 163, 112, 10, 240, 134, 96, 11, 224, 133, 112, 12, 217, 162, 224, 13, 192, 103, 112, 14, 185, 132, 224, 15, 169, 131, 240, 16, 153, 102, 224, 17, 137, 101, 240, 18, 121, 72, 224, 19, 105, 71, 240, 20, 89, 42, 224, 21, 73, 41, 240, 22, 57, 12, 224, 23, 41, 11, 240, 24, 34, 41, 96, 25, 8, 237, 240, 26, 2, 11, 96, 26, 242, 10, 112, 27, 225, 237, 96, 28, 209, 236, 112, 29, 193, 207, 96, 30, 177, 206, 112, 31, 161, 177, 96, 32, 118, 0, 240, 33, 129, 147, 96, 34, 85, 226, 240, 35, 106, 175, 224, 36, 53, 196, 240, 37, 74, 145, 224, 38, 21, 166, 240, 39, 42, 115, 224, 39, 254, 195, 112, 41, 10, 85, 224, 41, 222, 165, 112, 42, 234, 55, 224, 43, 190, 135, 112, 44, 211, 84, 96, 45, 158, 105, 112, 46, 179, 54, 96, 47, 126, 75, 112, 48, 147, 24, 96, 49, 103, 103, 240, 50, 114, 250, 96, 51, 71, 73, 240, 52, 82, 220, 96, 53, 39, 43, 240, 54, 50, 190, 96, 55, 7, 13, 240, 56, 27, 218, 224, 56, 230, 239, 240, 57, 251, 188, 224, 58, 198, 209, 240, 59, 219, 158, 224, 60, 175, 238, 112, 61, 187, 128, 224, 62, 143, 208, 112, 63, 155, 98, 224, 64, 111, 178, 112, 65, 132, 127, 96, 66, 79, 148, 112, 67, 100, 97, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 173, 64, 0, 0, 255, 255, 199, 192, 1, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 1, 12, 255, 255, 199, 192, 1, 16, 76, 77, 84, 0, 69, 68, 84, 0, 69, 83, 84, 0, 69, 87, 84, 0, 69, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Nome": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 144, 0, 0, 0, 9, 0, 0, 0, 38, 128, 0, 0, 0, 203, 137, 68, 208, 210, 35, 244, 112, 210, 97, 80, 64, 250, 210, 85, 176, 254, 184, 113, 80, 255, 168, 84, 64, 0, 152, 83, 80, 1, 136, 54, 64, 2, 120, 53, 80, 3, 113, 82, 192, 4, 97, 81, 208, 5, 81, 52, 192, 6, 65, 51, 208, 7, 49, 22, 192, 7, 141, 109, 208, 9, 16, 248, 192, 9, 173, 233, 80, 10, 240, 218, 192, 11, 224, 217, 208, 12, 217, 247, 64, 13, 192, 187, 208, 14, 185, 217, 64, 15, 169, 216, 80, 16, 153, 187, 64, 17, 137, 186, 80, 18, 121, 157, 64, 19, 105, 156, 80, 20, 89, 127, 64, 21, 73, 126, 80, 22, 57, 97, 64, 23, 41, 96, 80, 24, 34, 125, 192, 25, 9, 66, 80, 26, 2, 95, 192, 26, 43, 20, 16, 26, 242, 66, 176, 27, 226, 37, 160, 28, 210, 36, 176, 29, 194, 7, 160, 30, 178, 6, 176, 31, 161, 233, 160, 32, 118, 57, 48, 33, 129, 203, 160, 34, 86, 27, 48, 35, 106, 232, 32, 36, 53, 253, 48, 37, 74, 202, 32, 38, 21, 223, 48, 39, 42, 172, 32, 39, 254, 251, 176, 41, 10, 142, 32, 41, 222, 221, 176, 42, 234, 112, 32, 43, 190, 191, 176, 44, 211, 140, 160, 45, 158, 161, 176, 46, 179, 110, 160, 47, 126, 131, 176, 48, 147, 80, 160, 49, 103, 160, 48, 50, 115, 50, 160, 51, 71, 130, 48, 52, 83, 20, 160, 53, 39, 100, 48, 54, 50, 246, 160, 55, 7, 70, 48, 56, 28, 19, 32, 56, 231, 40, 48, 57, 251, 245, 32, 58, 199, 10, 48, 59, 219, 215, 32, 60, 176, 38, 176, 61, 187, 185, 32, 62, 144, 8, 176, 63, 155, 155, 32, 64, 111, 234, 176, 65, 132, 183, 160, 66, 79, 204, 176, 67, 100, 153, 160, 68, 47, 174, 176, 69, 68, 123, 160, 69, 243, 225, 48, 71, 45, 152, 32, 71, 211, 195, 48, 73, 13, 122, 32, 73, 179, 165, 48, 74, 237, 92, 32, 75, 156, 193, 176, 76, 214, 120, 160, 77, 124, 163, 176, 78, 182, 90, 160, 79, 92, 133, 176, 80, 150, 60, 160, 81, 60, 103, 176, 82, 118, 30, 160, 83, 28, 73, 176, 84, 86, 0, 160, 84, 252, 43, 176, 86, 53, 226, 160, 86, 229, 72, 48, 88, 30, 255, 32, 88, 197, 42, 48, 89, 254, 225, 32, 90, 165, 12, 48, 91, 222, 195, 32, 92, 132, 238, 48, 93, 190, 165, 32, 94, 100, 208, 48, 95, 158, 135, 32, 96, 77, 236, 176, 97, 135, 163, 160, 98, 45, 206, 176, 99, 103, 133, 160, 100, 13, 176, 176, 101, 71, 103, 160, 101, 237, 146, 176, 103, 39, 73, 160, 103, 205, 116, 176, 105, 7, 43, 160, 105, 173, 86, 176, 106, 231, 13, 160, 107, 150, 115, 48, 108, 208, 42, 32, 109, 118, 85, 48, 110, 176, 12, 32, 111, 86, 55, 48, 112, 143, 238, 32, 113, 54, 25, 48, 114, 111, 208, 32, 115, 21, 251, 48, 116, 79, 178, 32, 116, 255, 23, 176, 118, 56, 206, 160, 118, 222, 249, 176, 120, 24, 176, 160, 120, 190, 219, 176, 121, 248, 146, 160, 122, 158, 189, 176, 123, 216, 116, 160, 124, 126, 159, 176, 125, 184, 86, 160, 126, 94, 129, 176, 127, 152, 56, 160, 1, 2, 3, 1, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 6, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 255, 255, 100, 238, 0, 0, 255, 255, 101, 80, 0, 4, 255, 255, 115, 96, 1, 8, 255, 255, 115, 96, 1, 12, 255, 255, 101, 80, 0, 16, 255, 255, 115, 96, 1, 20, 255, 255, 129, 112, 0, 24, 255, 255, 143, 128, 1, 28, 255, 255, 129, 112, 0, 33, 76, 77, 84, 0, 78, 83, 84, 0, 78, 87, 84, 0, 78, 80, 84, 0, 66, 83, 84, 0, 66, 68, 84, 0, 89, 83, 84, 0, 65, 75, 68, 84, 0, 65, 75, 83, 84, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 10, 65, 75, 83, 84, 57, 65, 75, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Noronha": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 101, 100, 184, 15, 59, 208, 184, 253, 50, 144, 185, 241, 38, 32, 186, 222, 102, 16, 218, 56, 160, 32, 218, 235, 236, 32, 220, 25, 211, 160, 220, 185, 75, 16, 221, 251, 7, 32, 222, 155, 208, 16, 223, 221, 140, 32, 224, 84, 37, 16, 244, 151, 241, 160, 245, 5, 80, 16, 246, 192, 86, 32, 247, 14, 16, 144, 248, 81, 30, 32, 248, 199, 183, 16, 250, 10, 196, 160, 250, 168, 234, 144, 251, 235, 248, 32, 252, 139, 111, 144, 29, 201, 128, 32, 30, 120, 201, 144, 31, 160, 39, 160, 32, 51, 193, 144, 33, 129, 91, 32, 34, 11, 186, 144, 35, 88, 2, 160, 35, 226, 98, 16, 37, 55, 228, 160, 37, 212, 185, 16, 55, 246, 184, 160, 56, 184, 119, 16, 57, 223, 213, 32, 57, 233, 1, 144, 59, 200, 241, 160, 60, 111, 0, 144, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 255, 255, 225, 156, 0, 0, 255, 255, 241, 240, 1, 4, 255, 255, 227, 224, 0, 8, 76, 77, 84, 0, 45, 48, 49, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 50, 62, 50, 10}, - - "zoneinfo/America/North_Dakota/Beulah": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 150, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 158, 166, 58, 144, 159, 187, 7, 128, 160, 134, 28, 144, 161, 154, 233, 128, 203, 137, 12, 144, 210, 35, 244, 112, 210, 97, 24, 0, 250, 248, 117, 16, 251, 232, 88, 0, 252, 216, 87, 16, 253, 200, 58, 0, 254, 184, 57, 16, 255, 168, 28, 0, 0, 152, 27, 16, 1, 135, 254, 0, 2, 119, 253, 16, 3, 113, 26, 128, 4, 97, 25, 144, 5, 80, 252, 128, 6, 64, 251, 144, 7, 48, 222, 128, 7, 141, 53, 144, 9, 16, 192, 128, 9, 173, 177, 16, 10, 240, 162, 128, 11, 224, 161, 144, 12, 217, 191, 0, 13, 192, 131, 144, 14, 185, 161, 0, 15, 169, 160, 16, 16, 153, 131, 0, 17, 137, 130, 16, 18, 121, 101, 0, 19, 105, 100, 16, 20, 89, 71, 0, 21, 73, 70, 16, 22, 57, 41, 0, 23, 41, 40, 16, 24, 34, 69, 128, 25, 9, 10, 16, 26, 2, 39, 128, 26, 242, 38, 144, 27, 226, 9, 128, 28, 210, 8, 144, 29, 193, 235, 128, 30, 177, 234, 144, 31, 161, 205, 128, 32, 118, 29, 16, 33, 129, 175, 128, 34, 85, 255, 16, 35, 106, 204, 0, 36, 53, 225, 16, 37, 74, 174, 0, 38, 21, 195, 16, 39, 42, 144, 0, 39, 254, 223, 144, 41, 10, 114, 0, 41, 222, 193, 144, 42, 234, 84, 0, 43, 190, 163, 144, 44, 211, 112, 128, 45, 158, 133, 144, 46, 179, 82, 128, 47, 126, 103, 144, 48, 147, 52, 128, 49, 103, 132, 16, 50, 115, 22, 128, 51, 71, 102, 16, 52, 82, 248, 128, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 231, 12, 16, 57, 251, 217, 0, 58, 198, 238, 16, 59, 219, 187, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 206, 144, 65, 132, 155, 128, 66, 79, 176, 144, 67, 100, 125, 128, 68, 47, 146, 144, 69, 68, 95, 128, 69, 243, 197, 16, 71, 45, 124, 0, 71, 211, 167, 16, 73, 13, 94, 0, 73, 179, 137, 16, 74, 237, 64, 0, 75, 156, 165, 144, 76, 214, 92, 128, 77, 124, 121, 128, 78, 182, 48, 112, 79, 92, 91, 128, 80, 150, 18, 112, 81, 60, 61, 128, 82, 117, 244, 112, 83, 28, 31, 128, 84, 85, 214, 112, 84, 252, 1, 128, 86, 53, 184, 112, 86, 229, 30, 0, 88, 30, 212, 240, 88, 197, 0, 0, 89, 254, 182, 240, 90, 164, 226, 0, 91, 222, 152, 240, 92, 132, 196, 0, 93, 190, 122, 240, 94, 100, 166, 0, 95, 158, 92, 240, 96, 77, 194, 128, 97, 135, 121, 112, 98, 45, 164, 128, 99, 103, 91, 112, 100, 13, 134, 128, 101, 71, 61, 112, 101, 237, 104, 128, 103, 39, 31, 112, 103, 205, 74, 128, 105, 7, 1, 112, 105, 173, 44, 128, 106, 230, 227, 112, 107, 150, 73, 0, 108, 207, 255, 240, 109, 118, 43, 0, 110, 175, 225, 240, 111, 86, 13, 0, 112, 143, 195, 240, 113, 53, 239, 0, 114, 111, 165, 240, 115, 21, 209, 0, 116, 79, 135, 240, 116, 254, 237, 128, 118, 56, 164, 112, 118, 222, 207, 128, 120, 24, 134, 112, 120, 190, 177, 128, 121, 248, 104, 112, 122, 158, 147, 128, 123, 216, 74, 112, 124, 126, 117, 128, 125, 184, 44, 112, 126, 94, 87, 128, 127, 152, 14, 112, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 255, 255, 160, 149, 0, 0, 255, 255, 171, 160, 1, 4, 255, 255, 157, 144, 0, 8, 255, 255, 171, 160, 1, 12, 255, 255, 171, 160, 1, 16, 255, 255, 185, 176, 1, 20, 255, 255, 171, 160, 0, 24, 76, 77, 84, 0, 77, 68, 84, 0, 77, 83, 84, 0, 77, 87, 84, 0, 77, 80, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/North_Dakota/Center": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 150, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 158, 166, 58, 144, 159, 187, 7, 128, 160, 134, 28, 144, 161, 154, 233, 128, 203, 137, 12, 144, 210, 35, 244, 112, 210, 97, 24, 0, 250, 248, 117, 16, 251, 232, 88, 0, 252, 216, 87, 16, 253, 200, 58, 0, 254, 184, 57, 16, 255, 168, 28, 0, 0, 152, 27, 16, 1, 135, 254, 0, 2, 119, 253, 16, 3, 113, 26, 128, 4, 97, 25, 144, 5, 80, 252, 128, 6, 64, 251, 144, 7, 48, 222, 128, 7, 141, 53, 144, 9, 16, 192, 128, 9, 173, 177, 16, 10, 240, 162, 128, 11, 224, 161, 144, 12, 217, 191, 0, 13, 192, 131, 144, 14, 185, 161, 0, 15, 169, 160, 16, 16, 153, 131, 0, 17, 137, 130, 16, 18, 121, 101, 0, 19, 105, 100, 16, 20, 89, 71, 0, 21, 73, 70, 16, 22, 57, 41, 0, 23, 41, 40, 16, 24, 34, 69, 128, 25, 9, 10, 16, 26, 2, 39, 128, 26, 242, 38, 144, 27, 226, 9, 128, 28, 210, 8, 144, 29, 193, 235, 128, 30, 177, 234, 144, 31, 161, 205, 128, 32, 118, 29, 16, 33, 129, 175, 128, 34, 85, 255, 16, 35, 106, 204, 0, 36, 53, 225, 16, 37, 74, 174, 0, 38, 21, 195, 16, 39, 42, 144, 0, 39, 254, 223, 144, 41, 10, 114, 0, 41, 222, 193, 144, 42, 234, 84, 0, 43, 190, 149, 128, 44, 211, 98, 112, 45, 158, 119, 128, 46, 179, 68, 112, 47, 126, 89, 128, 48, 147, 38, 112, 49, 103, 118, 0, 50, 115, 8, 112, 51, 71, 88, 0, 52, 82, 234, 112, 53, 39, 58, 0, 54, 50, 204, 112, 55, 7, 28, 0, 56, 27, 232, 240, 56, 230, 254, 0, 57, 251, 202, 240, 58, 198, 224, 0, 59, 219, 172, 240, 60, 175, 252, 128, 61, 187, 142, 240, 62, 143, 222, 128, 63, 155, 112, 240, 64, 111, 192, 128, 65, 132, 141, 112, 66, 79, 162, 128, 67, 100, 111, 112, 68, 47, 132, 128, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 109, 240, 71, 211, 153, 0, 73, 13, 79, 240, 73, 179, 123, 0, 74, 237, 49, 240, 75, 156, 151, 128, 76, 214, 78, 112, 77, 124, 121, 128, 78, 182, 48, 112, 79, 92, 91, 128, 80, 150, 18, 112, 81, 60, 61, 128, 82, 117, 244, 112, 83, 28, 31, 128, 84, 85, 214, 112, 84, 252, 1, 128, 86, 53, 184, 112, 86, 229, 30, 0, 88, 30, 212, 240, 88, 197, 0, 0, 89, 254, 182, 240, 90, 164, 226, 0, 91, 222, 152, 240, 92, 132, 196, 0, 93, 190, 122, 240, 94, 100, 166, 0, 95, 158, 92, 240, 96, 77, 194, 128, 97, 135, 121, 112, 98, 45, 164, 128, 99, 103, 91, 112, 100, 13, 134, 128, 101, 71, 61, 112, 101, 237, 104, 128, 103, 39, 31, 112, 103, 205, 74, 128, 105, 7, 1, 112, 105, 173, 44, 128, 106, 230, 227, 112, 107, 150, 73, 0, 108, 207, 255, 240, 109, 118, 43, 0, 110, 175, 225, 240, 111, 86, 13, 0, 112, 143, 195, 240, 113, 53, 239, 0, 114, 111, 165, 240, 115, 21, 209, 0, 116, 79, 135, 240, 116, 254, 237, 128, 118, 56, 164, 112, 118, 222, 207, 128, 120, 24, 134, 112, 120, 190, 177, 128, 121, 248, 104, 112, 122, 158, 147, 128, 123, 216, 74, 112, 124, 126, 117, 128, 125, 184, 44, 112, 126, 94, 87, 128, 127, 152, 14, 112, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 255, 255, 161, 8, 0, 0, 255, 255, 171, 160, 1, 4, 255, 255, 157, 144, 0, 8, 255, 255, 171, 160, 1, 12, 255, 255, 171, 160, 1, 16, 255, 255, 185, 176, 1, 20, 255, 255, 171, 160, 0, 24, 76, 77, 84, 0, 77, 68, 84, 0, 77, 83, 84, 0, 77, 87, 84, 0, 77, 80, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/North_Dakota/New_Salem": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 150, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 158, 166, 58, 144, 159, 187, 7, 128, 160, 134, 28, 144, 161, 154, 233, 128, 203, 137, 12, 144, 210, 35, 244, 112, 210, 97, 24, 0, 250, 248, 117, 16, 251, 232, 88, 0, 252, 216, 87, 16, 253, 200, 58, 0, 254, 184, 57, 16, 255, 168, 28, 0, 0, 152, 27, 16, 1, 135, 254, 0, 2, 119, 253, 16, 3, 113, 26, 128, 4, 97, 25, 144, 5, 80, 252, 128, 6, 64, 251, 144, 7, 48, 222, 128, 7, 141, 53, 144, 9, 16, 192, 128, 9, 173, 177, 16, 10, 240, 162, 128, 11, 224, 161, 144, 12, 217, 191, 0, 13, 192, 131, 144, 14, 185, 161, 0, 15, 169, 160, 16, 16, 153, 131, 0, 17, 137, 130, 16, 18, 121, 101, 0, 19, 105, 100, 16, 20, 89, 71, 0, 21, 73, 70, 16, 22, 57, 41, 0, 23, 41, 40, 16, 24, 34, 69, 128, 25, 9, 10, 16, 26, 2, 39, 128, 26, 242, 38, 144, 27, 226, 9, 128, 28, 210, 8, 144, 29, 193, 235, 128, 30, 177, 234, 144, 31, 161, 205, 128, 32, 118, 29, 16, 33, 129, 175, 128, 34, 85, 255, 16, 35, 106, 204, 0, 36, 53, 225, 16, 37, 74, 174, 0, 38, 21, 195, 16, 39, 42, 144, 0, 39, 254, 223, 144, 41, 10, 114, 0, 41, 222, 193, 144, 42, 234, 84, 0, 43, 190, 163, 144, 44, 211, 112, 128, 45, 158, 133, 144, 46, 179, 82, 128, 47, 126, 103, 144, 48, 147, 52, 128, 49, 103, 132, 16, 50, 115, 22, 128, 51, 71, 102, 16, 52, 82, 248, 128, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 231, 12, 16, 57, 251, 217, 0, 58, 198, 238, 16, 59, 219, 187, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 192, 128, 65, 132, 141, 112, 66, 79, 162, 128, 67, 100, 111, 112, 68, 47, 132, 128, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 109, 240, 71, 211, 153, 0, 73, 13, 79, 240, 73, 179, 123, 0, 74, 237, 49, 240, 75, 156, 151, 128, 76, 214, 78, 112, 77, 124, 121, 128, 78, 182, 48, 112, 79, 92, 91, 128, 80, 150, 18, 112, 81, 60, 61, 128, 82, 117, 244, 112, 83, 28, 31, 128, 84, 85, 214, 112, 84, 252, 1, 128, 86, 53, 184, 112, 86, 229, 30, 0, 88, 30, 212, 240, 88, 197, 0, 0, 89, 254, 182, 240, 90, 164, 226, 0, 91, 222, 152, 240, 92, 132, 196, 0, 93, 190, 122, 240, 94, 100, 166, 0, 95, 158, 92, 240, 96, 77, 194, 128, 97, 135, 121, 112, 98, 45, 164, 128, 99, 103, 91, 112, 100, 13, 134, 128, 101, 71, 61, 112, 101, 237, 104, 128, 103, 39, 31, 112, 103, 205, 74, 128, 105, 7, 1, 112, 105, 173, 44, 128, 106, 230, 227, 112, 107, 150, 73, 0, 108, 207, 255, 240, 109, 118, 43, 0, 110, 175, 225, 240, 111, 86, 13, 0, 112, 143, 195, 240, 113, 53, 239, 0, 114, 111, 165, 240, 115, 21, 209, 0, 116, 79, 135, 240, 116, 254, 237, 128, 118, 56, 164, 112, 118, 222, 207, 128, 120, 24, 134, 112, 120, 190, 177, 128, 121, 248, 104, 112, 122, 158, 147, 128, 123, 216, 74, 112, 124, 126, 117, 128, 125, 184, 44, 112, 126, 94, 87, 128, 127, 152, 14, 112, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 255, 255, 160, 237, 0, 0, 255, 255, 171, 160, 1, 4, 255, 255, 157, 144, 0, 8, 255, 255, 171, 160, 1, 12, 255, 255, 171, 160, 1, 16, 255, 255, 185, 176, 1, 20, 255, 255, 171, 160, 0, 24, 76, 77, 84, 0, 77, 68, 84, 0, 77, 83, 84, 0, 77, 87, 84, 0, 77, 80, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Ojinaga": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 91, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 165, 182, 232, 112, 175, 242, 110, 224, 182, 102, 86, 96, 183, 67, 210, 96, 184, 12, 54, 96, 184, 253, 134, 240, 49, 103, 118, 0, 50, 115, 8, 112, 51, 71, 88, 0, 52, 82, 234, 112, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 231, 12, 16, 57, 251, 217, 0, 58, 245, 18, 144, 59, 182, 209, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 206, 144, 65, 132, 155, 128, 66, 79, 176, 144, 67, 100, 125, 128, 68, 47, 146, 144, 69, 68, 95, 128, 70, 15, 116, 144, 71, 36, 65, 128, 71, 248, 145, 16, 73, 4, 35, 128, 73, 216, 115, 16, 74, 228, 5, 128, 75, 156, 165, 144, 76, 214, 92, 128, 77, 124, 135, 144, 78, 182, 62, 128, 79, 92, 105, 144, 80, 150, 32, 128, 81, 60, 75, 144, 82, 118, 2, 128, 83, 28, 45, 144, 84, 85, 228, 128, 84, 252, 15, 144, 86, 53, 198, 128, 86, 229, 44, 16, 88, 30, 227, 0, 88, 197, 14, 16, 89, 254, 197, 0, 90, 164, 240, 16, 91, 222, 167, 0, 92, 132, 210, 16, 93, 190, 137, 0, 94, 100, 180, 16, 95, 158, 107, 0, 96, 77, 208, 144, 97, 135, 135, 128, 98, 45, 178, 144, 99, 103, 105, 128, 100, 13, 148, 144, 101, 71, 75, 128, 101, 237, 118, 144, 103, 39, 45, 128, 103, 205, 88, 144, 105, 7, 15, 128, 105, 173, 58, 144, 106, 230, 241, 128, 107, 150, 87, 16, 108, 208, 14, 0, 109, 118, 57, 16, 110, 175, 240, 0, 111, 86, 27, 16, 112, 143, 210, 0, 113, 53, 253, 16, 114, 111, 180, 0, 115, 21, 223, 16, 116, 79, 150, 0, 116, 254, 251, 144, 118, 56, 178, 128, 118, 222, 221, 144, 120, 24, 148, 128, 120, 190, 191, 144, 121, 248, 118, 128, 122, 158, 161, 144, 123, 216, 88, 128, 124, 126, 131, 144, 125, 184, 58, 128, 126, 94, 101, 144, 127, 152, 28, 128, 0, 1, 2, 1, 2, 1, 2, 3, 2, 3, 2, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 255, 255, 158, 28, 0, 0, 255, 255, 157, 144, 0, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 171, 160, 1, 16, 255, 255, 157, 144, 0, 4, 76, 77, 84, 0, 77, 83, 84, 0, 67, 83, 84, 0, 67, 68, 84, 0, 77, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 77, 83, 84, 55, 77, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Panama": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 139, 244, 97, 232, 1, 2, 255, 255, 181, 112, 0, 0, 255, 255, 181, 24, 0, 4, 255, 255, 185, 176, 0, 8, 76, 77, 84, 0, 67, 77, 84, 0, 69, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 69, 83, 84, 53, 10}, - - "zoneinfo/America/Pangnirtung": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 123, 0, 0, 0, 12, 0, 0, 0, 41, 128, 0, 0, 0, 163, 213, 82, 128, 203, 136, 226, 96, 210, 35, 244, 112, 210, 96, 237, 208, 247, 47, 48, 64, 248, 40, 91, 192, 19, 105, 57, 224, 20, 89, 28, 208, 21, 73, 27, 224, 22, 56, 254, 208, 23, 40, 253, 224, 24, 34, 27, 80, 25, 8, 223, 224, 26, 1, 253, 80, 26, 241, 252, 96, 27, 225, 223, 80, 28, 209, 222, 96, 29, 193, 193, 80, 30, 177, 192, 96, 31, 161, 163, 80, 32, 117, 242, 224, 33, 129, 133, 80, 34, 85, 212, 224, 35, 106, 161, 208, 36, 53, 182, 224, 37, 74, 131, 208, 38, 21, 152, 224, 39, 42, 101, 208, 39, 254, 181, 96, 41, 10, 71, 208, 41, 222, 151, 96, 42, 234, 41, 208, 43, 190, 121, 96, 44, 211, 70, 80, 45, 158, 91, 96, 46, 179, 40, 80, 47, 126, 61, 96, 48, 147, 24, 96, 49, 103, 103, 240, 50, 114, 250, 96, 51, 71, 73, 240, 52, 82, 220, 96, 53, 39, 43, 240, 54, 50, 190, 96, 55, 7, 13, 240, 56, 27, 218, 224, 56, 230, 254, 0, 57, 251, 202, 240, 58, 198, 209, 240, 59, 219, 158, 224, 60, 175, 238, 112, 61, 187, 128, 224, 62, 143, 208, 112, 63, 155, 98, 224, 64, 111, 178, 112, 65, 132, 127, 96, 66, 79, 148, 112, 67, 100, 97, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 0, 3, 1, 2, 3, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 6, 7, 6, 7, 6, 7, 6, 7, 6, 8, 9, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 0, 0, 0, 0, 0, 0, 255, 255, 213, 208, 1, 4, 255, 255, 213, 208, 1, 8, 255, 255, 199, 192, 0, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 1, 21, 255, 255, 199, 192, 1, 25, 255, 255, 185, 176, 0, 29, 255, 255, 171, 160, 0, 33, 255, 255, 185, 176, 1, 37, 255, 255, 199, 192, 1, 25, 255, 255, 185, 176, 0, 29, 45, 48, 48, 0, 65, 87, 84, 0, 65, 80, 84, 0, 65, 83, 84, 0, 65, 68, 68, 84, 0, 65, 68, 84, 0, 69, 68, 84, 0, 69, 83, 84, 0, 67, 83, 84, 0, 67, 68, 84, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Paramaribo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 5, 0, 0, 0, 18, 128, 0, 0, 0, 145, 5, 142, 184, 190, 42, 75, 196, 210, 98, 44, 180, 27, 190, 49, 184, 127, 255, 255, 255, 0, 1, 2, 3, 4, 4, 255, 255, 204, 72, 0, 0, 255, 255, 204, 60, 0, 4, 255, 255, 204, 76, 0, 4, 255, 255, 206, 200, 0, 8, 255, 255, 213, 208, 0, 14, 76, 77, 84, 0, 80, 77, 84, 0, 45, 48, 51, 51, 48, 0, 45, 48, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Phoenix": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 4, 0, 0, 0, 16, 128, 0, 0, 0, 158, 166, 58, 144, 159, 187, 7, 128, 160, 134, 28, 144, 161, 154, 233, 128, 203, 137, 12, 144, 207, 23, 223, 28, 207, 143, 229, 172, 208, 129, 26, 28, 250, 248, 117, 16, 251, 232, 88, 0, 2, 1, 2, 1, 2, 3, 2, 3, 2, 1, 2, 255, 255, 150, 238, 0, 0, 255, 255, 171, 160, 1, 4, 255, 255, 157, 144, 0, 8, 255, 255, 171, 160, 1, 12, 76, 77, 84, 0, 77, 68, 84, 0, 77, 83, 84, 0, 77, 87, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 77, 83, 84, 55, 10}, - - "zoneinfo/America/Port-au-Prince": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 86, 0, 0, 0, 6, 0, 0, 0, 17, 128, 0, 0, 0, 156, 110, 113, 252, 25, 27, 70, 208, 26, 1, 239, 64, 26, 241, 238, 80, 27, 225, 209, 64, 28, 209, 208, 80, 29, 193, 179, 64, 30, 177, 178, 80, 31, 161, 149, 64, 32, 145, 148, 80, 33, 129, 119, 64, 34, 85, 212, 224, 35, 106, 175, 224, 36, 53, 182, 224, 37, 74, 145, 224, 38, 21, 152, 224, 39, 42, 115, 224, 39, 254, 181, 96, 41, 10, 85, 224, 41, 222, 151, 96, 42, 234, 55, 224, 43, 190, 121, 96, 44, 211, 84, 96, 45, 158, 91, 96, 46, 179, 54, 96, 47, 126, 61, 96, 48, 147, 24, 96, 49, 103, 89, 224, 50, 114, 250, 96, 51, 71, 59, 224, 52, 82, 220, 96, 66, 79, 120, 80, 67, 100, 69, 64, 68, 47, 90, 80, 69, 68, 39, 64, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 255, 255, 188, 48, 0, 0, 255, 255, 188, 68, 0, 4, 255, 255, 199, 192, 1, 9, 255, 255, 185, 176, 0, 13, 255, 255, 199, 192, 1, 9, 255, 255, 185, 176, 0, 13, 76, 77, 84, 0, 80, 80, 77, 84, 0, 69, 68, 84, 0, 69, 83, 84, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Port_of_Spain": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 147, 55, 51, 172, 0, 1, 255, 255, 198, 84, 0, 0, 255, 255, 199, 192, 0, 4, 76, 77, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Porto_Acre": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, 5, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 134, 144, 184, 15, 102, 0, 184, 253, 92, 192, 185, 241, 80, 80, 186, 222, 144, 64, 218, 56, 202, 80, 218, 236, 22, 80, 220, 25, 253, 208, 220, 185, 117, 64, 221, 251, 49, 80, 222, 155, 250, 64, 223, 221, 182, 80, 224, 84, 79, 64, 244, 152, 27, 208, 245, 5, 122, 64, 246, 192, 128, 80, 247, 14, 58, 192, 248, 81, 72, 80, 248, 199, 225, 64, 250, 10, 238, 208, 250, 169, 20, 192, 251, 236, 34, 80, 252, 139, 153, 192, 29, 201, 170, 80, 30, 120, 243, 192, 31, 160, 81, 208, 32, 51, 235, 192, 33, 129, 133, 80, 34, 11, 228, 192, 72, 96, 127, 80, 82, 127, 4, 192, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 2, 255, 255, 192, 112, 0, 0, 255, 255, 199, 192, 1, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 0, 4, 255, 255, 185, 176, 0, 8, 76, 77, 84, 0, 45, 48, 52, 0, 45, 48, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 53, 62, 53, 10}, - - "zoneinfo/America/Porto_Velho": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 31, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 130, 232, 184, 15, 87, 240, 184, 253, 78, 176, 185, 241, 66, 64, 186, 222, 130, 48, 218, 56, 188, 64, 218, 236, 8, 64, 220, 25, 239, 192, 220, 185, 103, 48, 221, 251, 35, 64, 222, 155, 236, 48, 223, 221, 168, 64, 224, 84, 65, 48, 244, 152, 13, 192, 245, 5, 108, 48, 246, 192, 114, 64, 247, 14, 44, 176, 248, 81, 58, 64, 248, 199, 211, 48, 250, 10, 224, 192, 250, 169, 6, 176, 251, 236, 20, 64, 252, 139, 139, 176, 29, 201, 156, 64, 30, 120, 229, 176, 31, 160, 67, 192, 32, 51, 221, 176, 33, 129, 119, 64, 34, 11, 214, 176, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 255, 255, 196, 24, 0, 0, 255, 255, 213, 208, 1, 4, 255, 255, 199, 192, 0, 8, 76, 77, 84, 0, 45, 48, 51, 0, 45, 48, 52, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 52, 62, 52, 10}, - - "zoneinfo/America/Puerto_Rico": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 16, 128, 0, 0, 0, 203, 246, 50, 192, 210, 35, 244, 112, 210, 96, 237, 208, 1, 3, 2, 1, 255, 255, 194, 7, 0, 0, 255, 255, 199, 192, 0, 4, 255, 255, 213, 208, 1, 8, 255, 255, 213, 208, 1, 12, 76, 77, 84, 0, 65, 83, 84, 0, 65, 80, 84, 0, 65, 87, 84, 0, 0, 0, 1, 0, 0, 0, 1, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Punta_Arenas": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 117, 0, 0, 0, 8, 0, 0, 0, 20, 128, 0, 0, 0, 143, 48, 71, 70, 155, 92, 229, 80, 159, 124, 226, 198, 161, 0, 113, 192, 176, 94, 119, 198, 177, 119, 61, 64, 178, 65, 0, 208, 179, 88, 112, 192, 180, 34, 52, 80, 181, 57, 164, 64, 182, 3, 103, 208, 183, 26, 215, 192, 183, 228, 155, 80, 184, 253, 92, 192, 185, 199, 32, 80, 204, 28, 110, 64, 204, 108, 231, 208, 213, 51, 85, 192, 213, 118, 146, 64, 253, 209, 60, 64, 254, 146, 250, 176, 255, 204, 205, 192, 0, 114, 220, 176, 1, 117, 80, 192, 2, 64, 73, 176, 3, 85, 50, 192, 4, 32, 43, 176, 5, 62, 79, 64, 6, 0, 13, 176, 7, 11, 188, 64, 7, 223, 239, 176, 8, 254, 19, 64, 9, 191, 209, 176, 10, 221, 245, 64, 11, 168, 238, 48, 12, 189, 215, 64, 13, 136, 208, 48, 14, 157, 185, 64, 15, 104, 178, 48, 16, 134, 213, 192, 17, 72, 148, 48, 18, 102, 183, 192, 19, 40, 118, 48, 20, 70, 153, 192, 21, 17, 146, 176, 22, 38, 123, 192, 22, 241, 116, 176, 24, 6, 93, 192, 24, 209, 86, 176, 25, 230, 63, 192, 26, 177, 56, 176, 27, 207, 92, 64, 28, 145, 26, 176, 29, 175, 62, 64, 30, 112, 252, 176, 31, 143, 32, 64, 32, 127, 3, 48, 33, 111, 2, 64, 34, 57, 251, 48, 35, 78, 228, 64, 36, 25, 221, 48, 37, 56, 0, 192, 37, 249, 191, 48, 38, 242, 248, 192, 39, 217, 161, 48, 40, 247, 196, 192, 41, 194, 189, 176, 42, 215, 166, 192, 43, 162, 159, 176, 44, 183, 136, 192, 45, 130, 129, 176, 46, 151, 106, 192, 47, 98, 99, 176, 48, 128, 135, 64, 49, 66, 69, 176, 50, 96, 105, 64, 51, 61, 215, 48, 52, 64, 75, 64, 53, 11, 68, 48, 54, 13, 184, 64, 55, 6, 213, 176, 56, 0, 15, 64, 56, 203, 8, 48, 57, 233, 43, 192, 58, 170, 234, 48, 59, 201, 13, 192, 60, 138, 204, 48, 61, 168, 239, 192, 62, 106, 174, 48, 63, 136, 209, 192, 64, 83, 202, 176, 65, 104, 179, 192, 66, 51, 172, 176, 67, 72, 149, 192, 68, 19, 142, 176, 69, 49, 178, 64, 69, 243, 112, 176, 71, 17, 148, 64, 71, 239, 2, 48, 72, 241, 118, 64, 73, 188, 111, 48, 74, 209, 88, 64, 75, 184, 0, 176, 76, 177, 58, 64, 77, 198, 7, 48, 78, 80, 130, 192, 79, 156, 174, 176, 80, 66, 217, 192, 81, 124, 144, 176, 82, 43, 246, 64, 83, 92, 114, 176, 84, 11, 216, 64, 87, 55, 230, 48, 87, 175, 236, 192, 88, 67, 134, 176, 127, 255, 255, 255, 1, 2, 1, 3, 1, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 3, 2, 3, 2, 3, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 7, 7, 255, 255, 189, 132, 0, 0, 255, 255, 189, 186, 0, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 0, 12, 255, 255, 199, 192, 1, 12, 255, 255, 213, 208, 1, 16, 255, 255, 199, 192, 0, 12, 255, 255, 213, 208, 0, 16, 76, 77, 84, 0, 83, 77, 84, 0, 45, 48, 53, 0, 45, 48, 52, 0, 45, 48, 51, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Rainy_River": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 135, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 158, 184, 161, 128, 159, 186, 249, 112, 200, 248, 87, 96, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 8, 32, 207, 128, 9, 16, 178, 112, 10, 0, 177, 128, 10, 240, 148, 112, 11, 224, 147, 128, 12, 217, 176, 240, 13, 192, 117, 128, 14, 185, 146, 240, 15, 169, 146, 0, 16, 153, 116, 240, 17, 137, 116, 0, 18, 121, 86, 240, 19, 105, 86, 0, 20, 89, 56, 240, 21, 73, 56, 0, 22, 57, 26, 240, 23, 41, 26, 0, 24, 34, 55, 112, 25, 8, 252, 0, 26, 2, 25, 112, 26, 242, 24, 128, 27, 225, 251, 112, 28, 209, 250, 128, 29, 193, 221, 112, 30, 177, 220, 128, 31, 161, 191, 112, 32, 118, 15, 0, 33, 129, 161, 112, 34, 85, 241, 0, 35, 106, 189, 240, 36, 53, 211, 0, 37, 74, 159, 240, 38, 21, 181, 0, 39, 42, 129, 240, 39, 254, 209, 128, 41, 10, 99, 240, 41, 222, 179, 128, 42, 234, 69, 240, 43, 190, 149, 128, 44, 211, 98, 112, 45, 158, 119, 128, 46, 179, 68, 112, 47, 126, 89, 128, 48, 147, 38, 112, 49, 103, 118, 0, 50, 115, 8, 112, 51, 71, 88, 0, 52, 82, 234, 112, 53, 39, 58, 0, 54, 50, 204, 112, 55, 7, 28, 0, 56, 27, 232, 240, 56, 230, 254, 0, 57, 251, 202, 240, 58, 198, 224, 0, 59, 219, 172, 240, 60, 175, 252, 128, 61, 187, 142, 240, 62, 143, 222, 128, 63, 155, 112, 240, 64, 111, 192, 128, 65, 132, 141, 112, 66, 79, 162, 128, 67, 100, 111, 112, 68, 47, 132, 128, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 109, 240, 71, 211, 153, 0, 73, 13, 79, 240, 73, 179, 123, 0, 74, 237, 49, 240, 75, 156, 151, 128, 76, 214, 78, 112, 77, 124, 121, 128, 78, 182, 48, 112, 79, 92, 91, 128, 80, 150, 18, 112, 81, 60, 61, 128, 82, 117, 244, 112, 83, 28, 31, 128, 84, 85, 214, 112, 84, 252, 1, 128, 86, 53, 184, 112, 86, 229, 30, 0, 88, 30, 212, 240, 88, 197, 0, 0, 89, 254, 182, 240, 90, 164, 226, 0, 91, 222, 152, 240, 92, 132, 196, 0, 93, 190, 122, 240, 94, 100, 166, 0, 95, 158, 92, 240, 96, 77, 194, 128, 97, 135, 121, 112, 98, 45, 164, 128, 99, 103, 91, 112, 100, 13, 134, 128, 101, 71, 61, 112, 101, 237, 104, 128, 103, 39, 31, 112, 103, 205, 74, 128, 105, 7, 1, 112, 105, 173, 44, 128, 106, 230, 227, 112, 107, 150, 73, 0, 108, 207, 255, 240, 109, 118, 43, 0, 110, 175, 225, 240, 111, 86, 13, 0, 112, 143, 195, 240, 113, 53, 239, 0, 114, 111, 165, 240, 115, 21, 209, 0, 116, 79, 135, 240, 116, 254, 237, 128, 118, 56, 164, 112, 118, 222, 207, 128, 120, 24, 134, 112, 120, 190, 177, 128, 121, 248, 104, 112, 122, 158, 147, 128, 123, 216, 74, 112, 124, 126, 117, 128, 125, 184, 44, 112, 126, 94, 87, 128, 127, 152, 14, 112, 2, 1, 2, 1, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 167, 88, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Rankin_Inlet": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 120, 0, 0, 0, 6, 0, 0, 0, 21, 128, 0, 0, 0, 231, 140, 110, 0, 247, 47, 76, 96, 248, 40, 119, 224, 19, 105, 86, 0, 20, 89, 56, 240, 21, 73, 56, 0, 22, 57, 26, 240, 23, 41, 26, 0, 24, 34, 55, 112, 25, 8, 252, 0, 26, 2, 25, 112, 26, 242, 24, 128, 27, 225, 251, 112, 28, 209, 250, 128, 29, 193, 221, 112, 30, 177, 220, 128, 31, 161, 191, 112, 32, 118, 15, 0, 33, 129, 161, 112, 34, 85, 241, 0, 35, 106, 189, 240, 36, 53, 211, 0, 37, 74, 159, 240, 38, 21, 181, 0, 39, 42, 129, 240, 39, 254, 209, 128, 41, 10, 99, 240, 41, 222, 179, 128, 42, 234, 69, 240, 43, 190, 149, 128, 44, 211, 98, 112, 45, 158, 119, 128, 46, 179, 68, 112, 47, 126, 89, 128, 48, 147, 38, 112, 49, 103, 118, 0, 50, 115, 8, 112, 51, 71, 88, 0, 52, 82, 234, 112, 53, 39, 58, 0, 54, 50, 204, 112, 55, 7, 28, 0, 56, 27, 232, 240, 56, 230, 254, 0, 57, 251, 202, 240, 58, 198, 224, 0, 59, 219, 172, 240, 60, 175, 252, 128, 61, 187, 142, 240, 62, 143, 222, 128, 63, 155, 112, 240, 64, 111, 192, 128, 65, 132, 141, 112, 66, 79, 162, 128, 67, 100, 111, 112, 68, 47, 132, 128, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 109, 240, 71, 211, 153, 0, 73, 13, 79, 240, 73, 179, 123, 0, 74, 237, 49, 240, 75, 156, 151, 128, 76, 214, 78, 112, 77, 124, 121, 128, 78, 182, 48, 112, 79, 92, 91, 128, 80, 150, 18, 112, 81, 60, 61, 128, 82, 117, 244, 112, 83, 28, 31, 128, 84, 85, 214, 112, 84, 252, 1, 128, 86, 53, 184, 112, 86, 229, 30, 0, 88, 30, 212, 240, 88, 197, 0, 0, 89, 254, 182, 240, 90, 164, 226, 0, 91, 222, 152, 240, 92, 132, 196, 0, 93, 190, 122, 240, 94, 100, 166, 0, 95, 158, 92, 240, 96, 77, 194, 128, 97, 135, 121, 112, 98, 45, 164, 128, 99, 103, 91, 112, 100, 13, 134, 128, 101, 71, 61, 112, 101, 237, 104, 128, 103, 39, 31, 112, 103, 205, 74, 128, 105, 7, 1, 112, 105, 173, 44, 128, 106, 230, 227, 112, 107, 150, 73, 0, 108, 207, 255, 240, 109, 118, 43, 0, 110, 175, 225, 240, 111, 86, 13, 0, 112, 143, 195, 240, 113, 53, 239, 0, 114, 111, 165, 240, 115, 21, 209, 0, 116, 79, 135, 240, 116, 254, 237, 128, 118, 56, 164, 112, 118, 222, 207, 128, 120, 24, 134, 112, 120, 190, 177, 128, 121, 248, 104, 112, 122, 158, 147, 128, 123, 216, 74, 112, 124, 126, 117, 128, 125, 184, 44, 112, 126, 94, 87, 128, 127, 152, 14, 112, 0, 2, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 4, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 0, 0, 0, 0, 0, 0, 255, 255, 199, 192, 1, 4, 255, 255, 171, 160, 0, 9, 255, 255, 185, 176, 1, 13, 255, 255, 185, 176, 0, 17, 255, 255, 171, 160, 0, 9, 45, 48, 48, 0, 67, 68, 68, 84, 0, 67, 83, 84, 0, 67, 68, 84, 0, 69, 83, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Recife": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 103, 184, 184, 15, 73, 224, 184, 253, 64, 160, 185, 241, 52, 48, 186, 222, 116, 32, 218, 56, 174, 48, 218, 235, 250, 48, 220, 25, 225, 176, 220, 185, 89, 32, 221, 251, 21, 48, 222, 155, 222, 32, 223, 221, 154, 48, 224, 84, 51, 32, 244, 151, 255, 176, 245, 5, 94, 32, 246, 192, 100, 48, 247, 14, 30, 160, 248, 81, 44, 48, 248, 199, 197, 32, 250, 10, 210, 176, 250, 168, 248, 160, 251, 236, 6, 48, 252, 139, 125, 160, 29, 201, 142, 48, 30, 120, 215, 160, 31, 160, 53, 176, 32, 51, 207, 160, 33, 129, 105, 48, 34, 11, 200, 160, 35, 88, 16, 176, 35, 226, 112, 32, 37, 55, 242, 176, 37, 212, 199, 32, 55, 246, 198, 176, 56, 184, 133, 32, 57, 223, 227, 48, 57, 233, 15, 160, 59, 200, 255, 176, 60, 111, 14, 160, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 255, 255, 223, 72, 0, 0, 255, 255, 227, 224, 1, 4, 255, 255, 213, 208, 0, 8, 76, 77, 84, 0, 45, 48, 50, 0, 45, 48, 51, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Regina": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 0, 6, 0, 0, 0, 24, 128, 0, 0, 0, 134, 253, 147, 28, 158, 184, 175, 144, 159, 187, 7, 128, 181, 101, 79, 240, 182, 48, 72, 224, 183, 69, 49, 240, 184, 16, 42, 224, 185, 37, 19, 240, 185, 240, 12, 224, 187, 14, 48, 112, 187, 207, 238, 224, 188, 238, 18, 112, 189, 185, 11, 96, 194, 114, 8, 240, 195, 97, 235, 224, 196, 81, 234, 240, 197, 56, 147, 96, 198, 49, 204, 240, 199, 33, 175, 224, 200, 26, 233, 112, 201, 10, 204, 96, 201, 250, 203, 112, 202, 234, 174, 96, 203, 137, 12, 144, 210, 35, 244, 112, 210, 97, 24, 0, 211, 99, 140, 16, 212, 83, 111, 0, 213, 85, 227, 16, 214, 32, 220, 0, 215, 53, 197, 16, 216, 0, 190, 0, 217, 21, 167, 16, 217, 224, 160, 0, 218, 254, 195, 144, 219, 192, 130, 0, 220, 222, 165, 144, 221, 169, 158, 128, 222, 190, 135, 144, 223, 137, 128, 128, 224, 158, 105, 144, 225, 105, 98, 128, 226, 126, 75, 144, 227, 73, 68, 128, 228, 94, 45, 144, 229, 41, 38, 128, 230, 71, 74, 16, 231, 18, 67, 0, 232, 39, 44, 16, 232, 242, 37, 0, 235, 230, 240, 16, 236, 214, 211, 0, 237, 198, 210, 16, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 255, 255, 157, 228, 0, 0, 255, 255, 171, 160, 1, 4, 255, 255, 157, 144, 0, 8, 255, 255, 171, 160, 1, 12, 255, 255, 171, 160, 1, 16, 255, 255, 171, 160, 0, 20, 76, 77, 84, 0, 77, 68, 84, 0, 77, 83, 84, 0, 77, 87, 84, 0, 77, 80, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 10, 67, 83, 84, 54, 10}, - - "zoneinfo/America/Resolute": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 120, 0, 0, 0, 6, 0, 0, 0, 21, 128, 0, 0, 0, 213, 251, 129, 128, 247, 47, 76, 96, 248, 40, 119, 224, 19, 105, 86, 0, 20, 89, 56, 240, 21, 73, 56, 0, 22, 57, 26, 240, 23, 41, 26, 0, 24, 34, 55, 112, 25, 8, 252, 0, 26, 2, 25, 112, 26, 242, 24, 128, 27, 225, 251, 112, 28, 209, 250, 128, 29, 193, 221, 112, 30, 177, 220, 128, 31, 161, 191, 112, 32, 118, 15, 0, 33, 129, 161, 112, 34, 85, 241, 0, 35, 106, 189, 240, 36, 53, 211, 0, 37, 74, 159, 240, 38, 21, 181, 0, 39, 42, 129, 240, 39, 254, 209, 128, 41, 10, 99, 240, 41, 222, 179, 128, 42, 234, 69, 240, 43, 190, 149, 128, 44, 211, 98, 112, 45, 158, 119, 128, 46, 179, 68, 112, 47, 126, 89, 128, 48, 147, 38, 112, 49, 103, 118, 0, 50, 115, 8, 112, 51, 71, 88, 0, 52, 82, 234, 112, 53, 39, 58, 0, 54, 50, 204, 112, 55, 7, 28, 0, 56, 27, 232, 240, 56, 230, 254, 0, 57, 251, 202, 240, 58, 198, 224, 0, 59, 219, 172, 240, 60, 175, 252, 128, 61, 187, 142, 240, 62, 143, 222, 128, 63, 155, 112, 240, 64, 111, 192, 128, 65, 132, 141, 112, 66, 79, 162, 128, 67, 100, 111, 112, 68, 47, 132, 128, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 109, 240, 71, 211, 153, 0, 73, 13, 79, 240, 73, 179, 123, 0, 74, 237, 49, 240, 75, 156, 151, 128, 76, 214, 78, 112, 77, 124, 121, 128, 78, 182, 48, 112, 79, 92, 91, 128, 80, 150, 18, 112, 81, 60, 61, 128, 82, 117, 244, 112, 83, 28, 31, 128, 84, 85, 214, 112, 84, 252, 1, 128, 86, 53, 184, 112, 86, 229, 30, 0, 88, 30, 212, 240, 88, 197, 0, 0, 89, 254, 182, 240, 90, 164, 226, 0, 91, 222, 152, 240, 92, 132, 196, 0, 93, 190, 122, 240, 94, 100, 166, 0, 95, 158, 92, 240, 96, 77, 194, 128, 97, 135, 121, 112, 98, 45, 164, 128, 99, 103, 91, 112, 100, 13, 134, 128, 101, 71, 61, 112, 101, 237, 104, 128, 103, 39, 31, 112, 103, 205, 74, 128, 105, 7, 1, 112, 105, 173, 44, 128, 106, 230, 227, 112, 107, 150, 73, 0, 108, 207, 255, 240, 109, 118, 43, 0, 110, 175, 225, 240, 111, 86, 13, 0, 112, 143, 195, 240, 113, 53, 239, 0, 114, 111, 165, 240, 115, 21, 209, 0, 116, 79, 135, 240, 116, 254, 237, 128, 118, 56, 164, 112, 118, 222, 207, 128, 120, 24, 134, 112, 120, 190, 177, 128, 121, 248, 104, 112, 122, 158, 147, 128, 123, 216, 74, 112, 124, 126, 117, 128, 125, 184, 44, 112, 126, 94, 87, 128, 127, 152, 14, 112, 0, 2, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 4, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 4, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 0, 0, 0, 0, 0, 0, 255, 255, 199, 192, 1, 4, 255, 255, 171, 160, 0, 9, 255, 255, 185, 176, 1, 13, 255, 255, 185, 176, 0, 17, 255, 255, 171, 160, 0, 9, 45, 48, 48, 0, 67, 68, 68, 84, 0, 67, 83, 84, 0, 67, 68, 84, 0, 69, 83, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Rio_Branco": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, 5, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 134, 144, 184, 15, 102, 0, 184, 253, 92, 192, 185, 241, 80, 80, 186, 222, 144, 64, 218, 56, 202, 80, 218, 236, 22, 80, 220, 25, 253, 208, 220, 185, 117, 64, 221, 251, 49, 80, 222, 155, 250, 64, 223, 221, 182, 80, 224, 84, 79, 64, 244, 152, 27, 208, 245, 5, 122, 64, 246, 192, 128, 80, 247, 14, 58, 192, 248, 81, 72, 80, 248, 199, 225, 64, 250, 10, 238, 208, 250, 169, 20, 192, 251, 236, 34, 80, 252, 139, 153, 192, 29, 201, 170, 80, 30, 120, 243, 192, 31, 160, 81, 208, 32, 51, 235, 192, 33, 129, 133, 80, 34, 11, 228, 192, 72, 96, 127, 80, 82, 127, 4, 192, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 2, 255, 255, 192, 112, 0, 0, 255, 255, 199, 192, 1, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 0, 4, 255, 255, 185, 176, 0, 8, 76, 77, 84, 0, 45, 48, 52, 0, 45, 48, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 53, 62, 53, 10}, - - "zoneinfo/America/Rosario": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 62, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 162, 146, 143, 48, 182, 123, 82, 64, 183, 26, 201, 176, 184, 30, 143, 64, 184, 212, 112, 48, 186, 23, 125, 192, 186, 181, 163, 176, 187, 248, 177, 64, 188, 150, 215, 48, 189, 217, 228, 192, 190, 120, 10, 176, 191, 187, 24, 64, 192, 90, 143, 176, 193, 157, 157, 64, 194, 59, 195, 48, 195, 126, 208, 192, 196, 28, 246, 176, 197, 96, 4, 64, 197, 254, 42, 48, 199, 65, 55, 192, 199, 224, 175, 48, 200, 129, 148, 64, 202, 77, 161, 176, 202, 238, 134, 192, 206, 77, 255, 48, 206, 176, 237, 192, 211, 41, 53, 176, 212, 67, 100, 192, 244, 61, 8, 48, 244, 159, 246, 192, 245, 5, 108, 48, 246, 50, 16, 64, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 35, 148, 181, 176, 36, 16, 148, 160, 37, 55, 242, 176, 37, 240, 118, 160, 39, 33, 15, 48, 39, 208, 88, 160, 41, 0, 255, 64, 41, 176, 58, 160, 42, 224, 211, 48, 43, 153, 87, 32, 55, 246, 198, 176, 56, 191, 42, 176, 71, 119, 9, 176, 71, 220, 127, 32, 72, 250, 162, 176, 73, 188, 97, 32, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 4, 5, 4, 5, 4, 5, 4, 2, 4, 5, 4, 5, 3, 5, 4, 5, 4, 5, 5, 255, 255, 195, 208, 0, 0, 255, 255, 195, 208, 0, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 12, 76, 77, 84, 0, 67, 77, 84, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Santa_Isabel": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 150, 0, 0, 0, 6, 0, 0, 0, 24, 128, 0, 0, 0, 165, 182, 246, 128, 169, 121, 79, 112, 175, 242, 124, 240, 182, 102, 100, 112, 183, 27, 16, 0, 184, 10, 242, 240, 203, 234, 141, 128, 210, 35, 244, 112, 210, 153, 186, 112, 215, 27, 89, 0, 216, 145, 180, 240, 226, 126, 75, 144, 227, 73, 82, 144, 228, 94, 45, 144, 229, 41, 52, 144, 230, 71, 74, 16, 231, 18, 81, 16, 232, 39, 44, 16, 232, 242, 51, 16, 234, 7, 14, 16, 234, 210, 21, 16, 235, 230, 240, 16, 236, 177, 247, 16, 237, 198, 210, 16, 238, 145, 217, 16, 11, 224, 175, 160, 12, 217, 205, 16, 13, 192, 145, 160, 14, 185, 175, 16, 15, 169, 174, 32, 16, 153, 145, 16, 17, 137, 144, 32, 18, 121, 115, 16, 19, 105, 114, 32, 20, 89, 85, 16, 21, 73, 84, 32, 22, 57, 55, 16, 23, 41, 54, 32, 24, 34, 83, 144, 25, 9, 24, 32, 26, 2, 53, 144, 26, 242, 52, 160, 27, 226, 23, 144, 28, 210, 22, 160, 29, 193, 249, 144, 30, 177, 248, 160, 31, 161, 219, 144, 32, 118, 43, 32, 33, 129, 189, 144, 34, 86, 13, 32, 35, 106, 218, 16, 36, 53, 239, 32, 37, 74, 188, 16, 38, 21, 209, 32, 39, 42, 158, 16, 39, 254, 237, 160, 41, 10, 128, 16, 41, 222, 207, 160, 42, 234, 98, 16, 43, 190, 177, 160, 44, 211, 126, 144, 45, 158, 147, 160, 46, 179, 96, 144, 47, 126, 117, 160, 48, 147, 66, 144, 49, 103, 146, 32, 50, 115, 36, 144, 51, 71, 116, 32, 52, 83, 6, 144, 53, 39, 86, 32, 54, 50, 232, 144, 55, 7, 56, 32, 56, 28, 5, 16, 56, 231, 26, 32, 57, 251, 231, 16, 58, 198, 252, 32, 59, 219, 201, 16, 60, 176, 24, 160, 61, 187, 171, 16, 62, 143, 250, 160, 63, 155, 141, 16, 64, 111, 220, 160, 65, 132, 169, 144, 66, 79, 190, 160, 67, 100, 139, 144, 68, 47, 160, 160, 69, 68, 109, 144, 70, 15, 130, 160, 71, 36, 79, 144, 71, 248, 159, 32, 73, 4, 49, 144, 73, 216, 129, 32, 74, 228, 19, 144, 75, 156, 179, 160, 76, 214, 106, 144, 77, 124, 149, 160, 78, 182, 76, 144, 79, 92, 119, 160, 80, 150, 46, 144, 81, 60, 89, 160, 82, 118, 16, 144, 83, 28, 59, 160, 84, 85, 242, 144, 84, 252, 29, 160, 86, 53, 212, 144, 86, 229, 58, 32, 88, 30, 241, 16, 88, 197, 28, 32, 89, 254, 211, 16, 90, 164, 254, 32, 91, 222, 181, 16, 92, 132, 224, 32, 93, 190, 151, 16, 94, 100, 194, 32, 95, 158, 121, 16, 96, 77, 222, 160, 97, 135, 149, 144, 98, 45, 192, 160, 99, 103, 119, 144, 100, 13, 162, 160, 101, 71, 89, 144, 101, 237, 132, 160, 103, 39, 59, 144, 103, 205, 102, 160, 105, 7, 29, 144, 105, 173, 72, 160, 106, 230, 255, 144, 107, 150, 101, 32, 108, 208, 28, 16, 109, 118, 71, 32, 110, 175, 254, 16, 111, 86, 41, 32, 112, 143, 224, 16, 113, 54, 11, 32, 114, 111, 194, 16, 115, 21, 237, 32, 116, 79, 164, 16, 116, 255, 9, 160, 118, 56, 192, 144, 118, 222, 235, 160, 120, 24, 162, 144, 120, 190, 205, 160, 121, 248, 132, 144, 122, 158, 175, 160, 123, 216, 102, 144, 124, 126, 145, 160, 125, 184, 72, 144, 126, 94, 115, 160, 127, 152, 42, 144, 0, 1, 2, 1, 2, 3, 2, 4, 5, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 255, 255, 146, 76, 0, 0, 255, 255, 157, 144, 0, 4, 255, 255, 143, 128, 0, 8, 255, 255, 157, 144, 1, 12, 255, 255, 157, 144, 1, 16, 255, 255, 157, 144, 1, 20, 76, 77, 84, 0, 77, 83, 84, 0, 80, 83, 84, 0, 80, 68, 84, 0, 80, 87, 84, 0, 80, 80, 84, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 10, 80, 83, 84, 56, 80, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Santarem": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 32, 0, 0, 0, 4, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 122, 72, 184, 15, 87, 240, 184, 253, 78, 176, 185, 241, 66, 64, 186, 222, 130, 48, 218, 56, 188, 64, 218, 236, 8, 64, 220, 25, 239, 192, 220, 185, 103, 48, 221, 251, 35, 64, 222, 155, 236, 48, 223, 221, 168, 64, 224, 84, 65, 48, 244, 152, 13, 192, 245, 5, 108, 48, 246, 192, 114, 64, 247, 14, 44, 176, 248, 81, 58, 64, 248, 199, 211, 48, 250, 10, 224, 192, 250, 169, 6, 176, 251, 236, 20, 64, 252, 139, 139, 176, 29, 201, 156, 64, 30, 120, 229, 176, 31, 160, 67, 192, 32, 51, 221, 176, 33, 129, 119, 64, 34, 11, 214, 176, 72, 96, 113, 64, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 3, 255, 255, 204, 184, 0, 0, 255, 255, 213, 208, 1, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 0, 4, 76, 77, 84, 0, 45, 48, 51, 0, 45, 48, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/America/Santiago": []byte{84, 90, 105, 102, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 160, 0, 0, 0, 8, 0, 0, 0, 20, 128, 0, 0, 0, 143, 48, 71, 70, 155, 92, 229, 80, 159, 124, 226, 198, 161, 0, 113, 192, 176, 94, 119, 198, 177, 119, 61, 64, 178, 65, 0, 208, 179, 88, 112, 192, 180, 34, 52, 80, 181, 57, 164, 64, 182, 3, 103, 208, 183, 26, 215, 192, 183, 228, 155, 80, 184, 253, 92, 192, 185, 199, 32, 80, 204, 28, 110, 64, 204, 108, 231, 208, 211, 220, 143, 192, 212, 27, 201, 176, 213, 51, 85, 192, 213, 118, 146, 64, 253, 209, 60, 64, 254, 146, 250, 176, 255, 204, 205, 192, 0, 114, 220, 176, 1, 117, 80, 192, 2, 64, 73, 176, 3, 85, 50, 192, 4, 32, 43, 176, 5, 62, 79, 64, 6, 0, 13, 176, 7, 11, 188, 64, 7, 223, 239, 176, 8, 254, 19, 64, 9, 191, 209, 176, 10, 221, 245, 64, 11, 168, 238, 48, 12, 189, 215, 64, 13, 136, 208, 48, 14, 157, 185, 64, 15, 104, 178, 48, 16, 134, 213, 192, 17, 72, 148, 48, 18, 102, 183, 192, 19, 40, 118, 48, 20, 70, 153, 192, 21, 17, 146, 176, 22, 38, 123, 192, 22, 241, 116, 176, 24, 6, 93, 192, 24, 209, 86, 176, 25, 230, 63, 192, 26, 177, 56, 176, 27, 207, 92, 64, 28, 145, 26, 176, 29, 175, 62, 64, 30, 112, 252, 176, 31, 143, 32, 64, 32, 127, 3, 48, 33, 111, 2, 64, 34, 57, 251, 48, 35, 78, 228, 64, 36, 25, 221, 48, 37, 56, 0, 192, 37, 249, 191, 48, 38, 242, 248, 192, 39, 217, 161, 48, 40, 247, 196, 192, 41, 194, 189, 176, 42, 215, 166, 192, 43, 162, 159, 176, 44, 183, 136, 192, 45, 130, 129, 176, 46, 151, 106, 192, 47, 98, 99, 176, 48, 128, 135, 64, 49, 66, 69, 176, 50, 96, 105, 64, 51, 61, 215, 48, 52, 64, 75, 64, 53, 11, 68, 48, 54, 13, 184, 64, 55, 6, 213, 176, 56, 0, 15, 64, 56, 203, 8, 48, 57, 233, 43, 192, 58, 170, 234, 48, 59, 201, 13, 192, 60, 138, 204, 48, 61, 168, 239, 192, 62, 106, 174, 48, 63, 136, 209, 192, 64, 83, 202, 176, 65, 104, 179, 192, 66, 51, 172, 176, 67, 72, 149, 192, 68, 19, 142, 176, 69, 49, 178, 64, 69, 243, 112, 176, 71, 17, 148, 64, 71, 239, 2, 48, 72, 241, 118, 64, 73, 188, 111, 48, 74, 209, 88, 64, 75, 184, 0, 176, 76, 177, 58, 64, 77, 198, 7, 48, 78, 80, 130, 192, 79, 156, 174, 176, 80, 66, 217, 192, 81, 124, 144, 176, 82, 43, 246, 64, 83, 92, 114, 176, 84, 11, 216, 64, 87, 55, 230, 48, 87, 175, 236, 192, 89, 23, 200, 48, 89, 143, 206, 192, 90, 247, 170, 48, 91, 111, 176, 192, 92, 215, 140, 48, 93, 79, 146, 192, 94, 183, 110, 48, 95, 47, 116, 192, 96, 151, 80, 48, 97, 24, 145, 64, 98, 128, 108, 176, 98, 248, 115, 64, 100, 96, 78, 176, 100, 216, 85, 64, 102, 64, 48, 176, 102, 184, 55, 64, 104, 32, 18, 176, 104, 152, 25, 64, 105, 255, 244, 176, 106, 119, 251, 64, 107, 223, 214, 176, 108, 97, 23, 192, 109, 200, 243, 48, 110, 64, 249, 192, 111, 168, 213, 48, 112, 32, 219, 192, 113, 136, 183, 48, 114, 0, 189, 192, 115, 104, 153, 48, 115, 224, 159, 192, 117, 72, 123, 48, 117, 201, 188, 64, 119, 49, 151, 176, 119, 169, 158, 64, 121, 17, 121, 176, 121, 137, 128, 64, 122, 241, 91, 176, 123, 105, 98, 64, 124, 209, 61, 176, 125, 73, 68, 64, 126, 177, 31, 176, 127, 41, 38, 64, 127, 255, 255, 255, 1, 2, 1, 3, 1, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 3, 2, 3, 5, 3, 2, 3, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 6, 255, 255, 189, 186, 0, 0, 255, 255, 189, 186, 0, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 0, 12, 255, 255, 199, 192, 1, 12, 255, 255, 213, 208, 1, 16, 255, 255, 213, 208, 1, 16, 255, 255, 199, 192, 0, 12, 76, 77, 84, 0, 83, 77, 84, 0, 45, 48, 53, 0, 45, 48, 52, 0, 45, 48, 51, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 10, 60, 45, 48, 52, 62, 52, 60, 45, 48, 51, 62, 44, 77, 56, 46, 50, 46, 54, 47, 50, 52, 44, 77, 53, 46, 50, 46, 54, 47, 50, 52, 10}, - - "zoneinfo/America/Santo_Domingo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 6, 0, 0, 0, 27, 128, 0, 0, 0, 186, 223, 66, 96, 250, 8, 75, 208, 250, 167, 195, 64, 255, 167, 241, 208, 0, 67, 123, 200, 1, 135, 211, 208, 1, 250, 127, 72, 3, 112, 240, 80, 3, 221, 4, 72, 5, 80, 210, 80, 5, 191, 137, 72, 7, 48, 180, 80, 7, 160, 188, 200, 9, 16, 150, 80, 57, 251, 188, 224, 58, 41, 225, 96, 1, 3, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 5, 3, 5, 255, 255, 190, 120, 0, 0, 255, 255, 190, 96, 0, 4, 255, 255, 199, 192, 1, 9, 255, 255, 185, 176, 0, 13, 255, 255, 192, 184, 1, 17, 255, 255, 199, 192, 0, 23, 76, 77, 84, 0, 83, 68, 77, 84, 0, 69, 68, 84, 0, 69, 83, 84, 0, 45, 48, 52, 51, 48, 0, 65, 83, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Sao_Paulo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 129, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 114, 180, 184, 15, 73, 224, 184, 253, 64, 160, 185, 241, 52, 48, 186, 222, 116, 32, 218, 56, 174, 48, 218, 235, 250, 48, 220, 25, 225, 176, 220, 185, 89, 32, 221, 251, 21, 48, 222, 155, 222, 32, 223, 221, 154, 48, 224, 84, 51, 32, 244, 90, 9, 48, 245, 5, 94, 32, 246, 192, 100, 48, 247, 14, 30, 160, 248, 81, 44, 48, 248, 199, 197, 32, 250, 10, 210, 176, 250, 168, 248, 160, 251, 236, 6, 48, 252, 139, 125, 160, 29, 201, 142, 48, 30, 120, 215, 160, 31, 160, 53, 176, 32, 51, 207, 160, 33, 129, 105, 48, 34, 11, 200, 160, 35, 88, 16, 176, 35, 226, 112, 32, 37, 55, 242, 176, 37, 212, 199, 32, 39, 33, 15, 48, 39, 189, 227, 160, 41, 0, 241, 48, 41, 148, 139, 32, 42, 234, 13, 176, 43, 107, 50, 160, 44, 192, 181, 48, 45, 102, 196, 32, 46, 160, 151, 48, 47, 70, 166, 32, 48, 128, 121, 48, 49, 29, 77, 160, 50, 87, 32, 176, 51, 6, 106, 32, 52, 56, 84, 48, 52, 248, 193, 32, 54, 32, 31, 48, 54, 207, 104, 160, 55, 246, 198, 176, 56, 184, 133, 32, 57, 223, 227, 48, 58, 143, 44, 160, 59, 200, 255, 176, 60, 111, 14, 160, 61, 196, 145, 48, 62, 78, 240, 160, 63, 145, 254, 48, 64, 46, 210, 160, 65, 134, 248, 48, 66, 23, 239, 32, 67, 81, 194, 48, 67, 247, 209, 32, 69, 77, 83, 176, 69, 224, 237, 160, 71, 17, 134, 48, 71, 183, 149, 32, 72, 250, 162, 176, 73, 151, 119, 32, 74, 218, 132, 176, 75, 128, 147, 160, 76, 186, 102, 176, 77, 96, 117, 160, 78, 154, 72, 176, 79, 73, 146, 32, 80, 131, 101, 48, 81, 32, 57, 160, 82, 99, 71, 48, 83, 0, 27, 160, 84, 67, 41, 48, 84, 233, 56, 32, 86, 35, 11, 48, 86, 201, 26, 32, 88, 2, 237, 48, 88, 168, 252, 32, 89, 226, 207, 48, 90, 136, 222, 32, 91, 203, 235, 176, 92, 104, 192, 32, 93, 171, 205, 176, 94, 72, 162, 32, 95, 139, 175, 176, 96, 49, 190, 160, 97, 107, 145, 176, 98, 17, 160, 160, 99, 75, 115, 176, 99, 250, 189, 32, 101, 43, 85, 176, 101, 209, 100, 160, 103, 20, 114, 48, 103, 177, 70, 160, 104, 244, 84, 48, 105, 154, 99, 32, 106, 212, 54, 48, 107, 122, 69, 32, 108, 180, 24, 48, 109, 90, 39, 32, 110, 147, 250, 48, 111, 58, 9, 32, 112, 125, 22, 176, 113, 25, 235, 32, 114, 92, 248, 176, 114, 249, 205, 32, 116, 60, 218, 176, 116, 217, 175, 32, 118, 28, 188, 176, 118, 194, 203, 160, 119, 252, 158, 176, 120, 171, 232, 32, 121, 220, 128, 176, 122, 130, 143, 160, 123, 197, 157, 48, 124, 98, 113, 160, 125, 165, 127, 48, 126, 75, 142, 32, 127, 133, 97, 48, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 255, 255, 212, 76, 0, 0, 255, 255, 227, 224, 1, 4, 255, 255, 213, 208, 0, 8, 76, 77, 84, 0, 45, 48, 50, 0, 45, 48, 51, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 60, 45, 48, 50, 62, 44, 77, 49, 48, 46, 51, 46, 48, 47, 48, 44, 77, 50, 46, 51, 46, 48, 47, 48, 10}, - - "zoneinfo/America/Scoresbysund": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 119, 0, 0, 0, 7, 0, 0, 0, 16, 128, 0, 0, 0, 155, 128, 76, 24, 19, 77, 110, 64, 20, 52, 36, 192, 21, 35, 249, 160, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 127, 255, 255, 255, 0, 1, 2, 3, 6, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 4, 255, 255, 235, 104, 0, 0, 255, 255, 227, 224, 0, 4, 255, 255, 241, 240, 1, 8, 255, 255, 227, 224, 0, 4, 255, 255, 241, 240, 0, 8, 0, 0, 0, 0, 1, 12, 0, 0, 0, 0, 1, 12, 76, 77, 84, 0, 45, 48, 50, 0, 45, 48, 49, 0, 43, 48, 48, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 10, 60, 45, 48, 49, 62, 49, 60, 43, 48, 48, 62, 44, 77, 51, 46, 53, 46, 48, 47, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 49, 10}, - - "zoneinfo/America/Shiprock": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 158, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 158, 166, 58, 144, 159, 187, 7, 128, 160, 134, 28, 144, 161, 154, 233, 128, 162, 101, 254, 144, 163, 132, 6, 0, 164, 69, 224, 144, 164, 143, 166, 128, 203, 137, 12, 144, 210, 35, 244, 112, 210, 97, 24, 0, 247, 47, 118, 144, 248, 40, 148, 0, 249, 15, 88, 144, 250, 8, 118, 0, 250, 248, 117, 16, 251, 232, 88, 0, 252, 216, 87, 16, 253, 200, 58, 0, 254, 184, 57, 16, 255, 168, 28, 0, 0, 152, 27, 16, 1, 135, 254, 0, 2, 119, 253, 16, 3, 113, 26, 128, 4, 97, 25, 144, 5, 80, 252, 128, 6, 64, 251, 144, 7, 48, 222, 128, 7, 141, 53, 144, 9, 16, 192, 128, 9, 173, 177, 16, 10, 240, 162, 128, 11, 224, 161, 144, 12, 217, 191, 0, 13, 192, 131, 144, 14, 185, 161, 0, 15, 169, 160, 16, 16, 153, 131, 0, 17, 137, 130, 16, 18, 121, 101, 0, 19, 105, 100, 16, 20, 89, 71, 0, 21, 73, 70, 16, 22, 57, 41, 0, 23, 41, 40, 16, 24, 34, 69, 128, 25, 9, 10, 16, 26, 2, 39, 128, 26, 242, 38, 144, 27, 226, 9, 128, 28, 210, 8, 144, 29, 193, 235, 128, 30, 177, 234, 144, 31, 161, 205, 128, 32, 118, 29, 16, 33, 129, 175, 128, 34, 85, 255, 16, 35, 106, 204, 0, 36, 53, 225, 16, 37, 74, 174, 0, 38, 21, 195, 16, 39, 42, 144, 0, 39, 254, 223, 144, 41, 10, 114, 0, 41, 222, 193, 144, 42, 234, 84, 0, 43, 190, 163, 144, 44, 211, 112, 128, 45, 158, 133, 144, 46, 179, 82, 128, 47, 126, 103, 144, 48, 147, 52, 128, 49, 103, 132, 16, 50, 115, 22, 128, 51, 71, 102, 16, 52, 82, 248, 128, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 231, 12, 16, 57, 251, 217, 0, 58, 198, 238, 16, 59, 219, 187, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 206, 144, 65, 132, 155, 128, 66, 79, 176, 144, 67, 100, 125, 128, 68, 47, 146, 144, 69, 68, 95, 128, 69, 243, 197, 16, 71, 45, 124, 0, 71, 211, 167, 16, 73, 13, 94, 0, 73, 179, 137, 16, 74, 237, 64, 0, 75, 156, 165, 144, 76, 214, 92, 128, 77, 124, 135, 144, 78, 182, 62, 128, 79, 92, 105, 144, 80, 150, 32, 128, 81, 60, 75, 144, 82, 118, 2, 128, 83, 28, 45, 144, 84, 85, 228, 128, 84, 252, 15, 144, 86, 53, 198, 128, 86, 229, 44, 16, 88, 30, 227, 0, 88, 197, 14, 16, 89, 254, 197, 0, 90, 164, 240, 16, 91, 222, 167, 0, 92, 132, 210, 16, 93, 190, 137, 0, 94, 100, 180, 16, 95, 158, 107, 0, 96, 77, 208, 144, 97, 135, 135, 128, 98, 45, 178, 144, 99, 103, 105, 128, 100, 13, 148, 144, 101, 71, 75, 128, 101, 237, 118, 144, 103, 39, 45, 128, 103, 205, 88, 144, 105, 7, 15, 128, 105, 173, 58, 144, 106, 230, 241, 128, 107, 150, 87, 16, 108, 208, 14, 0, 109, 118, 57, 16, 110, 175, 240, 0, 111, 86, 27, 16, 112, 143, 210, 0, 113, 53, 253, 16, 114, 111, 180, 0, 115, 21, 223, 16, 116, 79, 150, 0, 116, 254, 251, 144, 118, 56, 178, 128, 118, 222, 221, 144, 120, 24, 148, 128, 120, 190, 191, 144, 121, 248, 118, 128, 122, 158, 161, 144, 123, 216, 88, 128, 124, 126, 131, 144, 125, 184, 58, 128, 126, 94, 101, 144, 127, 152, 28, 128, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 157, 148, 0, 0, 255, 255, 171, 160, 1, 4, 255, 255, 157, 144, 0, 8, 255, 255, 171, 160, 1, 12, 255, 255, 171, 160, 1, 16, 76, 77, 84, 0, 77, 68, 84, 0, 77, 83, 84, 0, 77, 87, 84, 0, 77, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 77, 83, 84, 55, 77, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Sitka": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 143, 0, 0, 0, 8, 0, 0, 0, 34, 128, 0, 0, 0, 203, 137, 26, 160, 210, 35, 244, 112, 210, 97, 38, 16, 254, 184, 71, 32, 255, 168, 42, 16, 0, 152, 41, 32, 1, 136, 12, 16, 2, 120, 11, 32, 3, 113, 40, 144, 4, 97, 39, 160, 5, 81, 10, 144, 6, 65, 9, 160, 7, 48, 236, 144, 7, 141, 67, 160, 9, 16, 206, 144, 9, 173, 191, 32, 10, 240, 176, 144, 11, 224, 175, 160, 12, 217, 205, 16, 13, 192, 145, 160, 14, 185, 175, 16, 15, 169, 174, 32, 16, 153, 145, 16, 17, 137, 144, 32, 18, 121, 115, 16, 19, 105, 114, 32, 20, 89, 85, 16, 21, 73, 84, 32, 22, 57, 55, 16, 23, 41, 54, 32, 24, 34, 83, 144, 25, 9, 24, 32, 26, 2, 53, 144, 26, 43, 20, 16, 26, 242, 66, 176, 27, 226, 37, 160, 28, 210, 36, 176, 29, 194, 7, 160, 30, 178, 6, 176, 31, 161, 233, 160, 32, 118, 57, 48, 33, 129, 203, 160, 34, 86, 27, 48, 35, 106, 232, 32, 36, 53, 253, 48, 37, 74, 202, 32, 38, 21, 223, 48, 39, 42, 172, 32, 39, 254, 251, 176, 41, 10, 142, 32, 41, 222, 221, 176, 42, 234, 112, 32, 43, 190, 191, 176, 44, 211, 140, 160, 45, 158, 161, 176, 46, 179, 110, 160, 47, 126, 131, 176, 48, 147, 80, 160, 49, 103, 160, 48, 50, 115, 50, 160, 51, 71, 130, 48, 52, 83, 20, 160, 53, 39, 100, 48, 54, 50, 246, 160, 55, 7, 70, 48, 56, 28, 19, 32, 56, 231, 40, 48, 57, 251, 245, 32, 58, 199, 10, 48, 59, 219, 215, 32, 60, 176, 38, 176, 61, 187, 185, 32, 62, 144, 8, 176, 63, 155, 155, 32, 64, 111, 234, 176, 65, 132, 183, 160, 66, 79, 204, 176, 67, 100, 153, 160, 68, 47, 174, 176, 69, 68, 123, 160, 69, 243, 225, 48, 71, 45, 152, 32, 71, 211, 195, 48, 73, 13, 122, 32, 73, 179, 165, 48, 74, 237, 92, 32, 75, 156, 193, 176, 76, 214, 120, 160, 77, 124, 163, 176, 78, 182, 90, 160, 79, 92, 133, 176, 80, 150, 60, 160, 81, 60, 103, 176, 82, 118, 30, 160, 83, 28, 73, 176, 84, 86, 0, 160, 84, 252, 43, 176, 86, 53, 226, 160, 86, 229, 72, 48, 88, 30, 255, 32, 88, 197, 42, 48, 89, 254, 225, 32, 90, 165, 12, 48, 91, 222, 195, 32, 92, 132, 238, 48, 93, 190, 165, 32, 94, 100, 208, 48, 95, 158, 135, 32, 96, 77, 236, 176, 97, 135, 163, 160, 98, 45, 206, 176, 99, 103, 133, 160, 100, 13, 176, 176, 101, 71, 103, 160, 101, 237, 146, 176, 103, 39, 73, 160, 103, 205, 116, 176, 105, 7, 43, 160, 105, 173, 86, 176, 106, 231, 13, 160, 107, 150, 115, 48, 108, 208, 42, 32, 109, 118, 85, 48, 110, 176, 12, 32, 111, 86, 55, 48, 112, 143, 238, 32, 113, 54, 25, 48, 114, 111, 208, 32, 115, 21, 251, 48, 116, 79, 178, 32, 116, 255, 23, 176, 118, 56, 206, 160, 118, 222, 249, 176, 120, 24, 176, 160, 120, 190, 219, 176, 121, 248, 146, 160, 122, 158, 189, 176, 123, 216, 116, 160, 124, 126, 159, 176, 125, 184, 86, 160, 126, 94, 129, 176, 127, 152, 56, 160, 1, 2, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 5, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 255, 255, 129, 39, 0, 0, 255, 255, 143, 128, 0, 4, 255, 255, 157, 144, 1, 8, 255, 255, 157, 144, 1, 12, 255, 255, 157, 144, 1, 16, 255, 255, 129, 112, 0, 20, 255, 255, 143, 128, 1, 24, 255, 255, 129, 112, 0, 29, 76, 77, 84, 0, 80, 83, 84, 0, 80, 87, 84, 0, 80, 80, 84, 0, 80, 68, 84, 0, 89, 83, 84, 0, 65, 75, 68, 84, 0, 65, 75, 83, 84, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 10, 65, 75, 83, 84, 57, 65, 75, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/St_Barthelemy": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 147, 55, 51, 172, 0, 1, 255, 255, 198, 84, 0, 0, 255, 255, 199, 192, 0, 4, 76, 77, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/St_Johns": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 239, 0, 0, 0, 9, 0, 0, 0, 25, 128, 0, 0, 0, 156, 207, 98, 12, 157, 164, 230, 252, 158, 184, 126, 140, 159, 186, 214, 124, 160, 182, 136, 220, 161, 56, 255, 76, 162, 149, 25, 92, 163, 132, 252, 76, 164, 116, 251, 92, 165, 100, 222, 76, 166, 94, 23, 220, 167, 68, 192, 76, 168, 61, 249, 220, 169, 36, 162, 76, 170, 29, 219, 220, 171, 4, 132, 76, 171, 253, 189, 220, 172, 228, 102, 76, 173, 221, 159, 220, 174, 205, 130, 204, 175, 189, 129, 220, 176, 173, 100, 204, 177, 166, 158, 92, 178, 141, 70, 204, 179, 134, 128, 92, 180, 109, 40, 204, 181, 102, 98, 92, 182, 77, 10, 204, 183, 70, 68, 92, 184, 44, 236, 204, 185, 38, 38, 92, 186, 22, 9, 76, 187, 15, 66, 220, 187, 245, 235, 76, 188, 239, 36, 220, 189, 213, 205, 76, 190, 158, 77, 108, 190, 207, 6, 168, 191, 181, 175, 24, 192, 184, 49, 56, 193, 121, 239, 168, 194, 152, 19, 56, 195, 89, 209, 168, 196, 119, 245, 56, 197, 57, 179, 168, 198, 97, 17, 184, 199, 25, 149, 168, 200, 64, 243, 184, 201, 2, 178, 40, 202, 32, 213, 184, 202, 226, 148, 40, 204, 0, 183, 184, 210, 35, 244, 112, 210, 96, 230, 200, 211, 136, 68, 216, 212, 74, 3, 72, 213, 104, 38, 216, 214, 41, 229, 72, 215, 72, 8, 216, 216, 9, 199, 72, 217, 39, 234, 216, 217, 233, 169, 72, 219, 17, 7, 88, 219, 210, 197, 200, 220, 222, 116, 88, 221, 169, 109, 72, 222, 190, 86, 88, 223, 137, 79, 72, 224, 158, 56, 88, 225, 105, 49, 72, 226, 126, 26, 88, 227, 73, 19, 72, 228, 93, 252, 88, 229, 40, 245, 72, 230, 71, 24, 216, 231, 18, 17, 200, 232, 38, 250, 216, 232, 241, 243, 200, 234, 6, 220, 216, 234, 209, 213, 200, 235, 230, 190, 216, 236, 177, 183, 200, 237, 198, 160, 216, 238, 191, 190, 72, 239, 175, 189, 88, 240, 159, 160, 72, 241, 143, 159, 88, 242, 127, 130, 72, 243, 111, 129, 88, 244, 95, 100, 72, 245, 79, 99, 88, 246, 63, 70, 72, 247, 47, 69, 88, 248, 40, 98, 200, 249, 15, 39, 88, 250, 8, 68, 200, 250, 248, 67, 216, 251, 232, 38, 200, 252, 216, 37, 216, 253, 200, 8, 200, 254, 184, 7, 216, 255, 167, 234, 200, 0, 151, 233, 216, 1, 135, 204, 200, 2, 119, 203, 216, 3, 112, 233, 72, 4, 96, 232, 88, 5, 80, 203, 72, 6, 64, 202, 88, 7, 48, 173, 72, 8, 32, 172, 88, 9, 16, 143, 72, 10, 0, 142, 88, 10, 240, 113, 72, 11, 224, 112, 88, 12, 217, 141, 200, 13, 192, 82, 88, 14, 185, 111, 200, 15, 169, 110, 216, 16, 153, 81, 200, 17, 137, 80, 216, 18, 121, 51, 200, 19, 105, 50, 216, 20, 89, 21, 200, 21, 73, 20, 216, 22, 56, 247, 200, 23, 40, 246, 216, 24, 34, 20, 72, 25, 8, 216, 216, 26, 1, 246, 72, 26, 241, 245, 88, 27, 225, 216, 72, 28, 209, 215, 88, 29, 193, 186, 72, 30, 177, 185, 88, 31, 161, 156, 72, 32, 117, 207, 244, 33, 129, 98, 100, 34, 85, 177, 244, 35, 106, 112, 212, 36, 53, 147, 244, 37, 74, 96, 228, 38, 21, 117, 244, 39, 42, 66, 228, 39, 254, 146, 116, 41, 10, 36, 228, 41, 222, 116, 116, 42, 234, 6, 228, 43, 190, 86, 116, 44, 211, 35, 100, 45, 158, 56, 116, 46, 179, 5, 100, 47, 126, 26, 116, 48, 146, 231, 100, 49, 103, 54, 244, 50, 114, 201, 100, 51, 71, 24, 244, 52, 82, 171, 100, 53, 38, 250, 244, 54, 50, 141, 100, 55, 6, 220, 244, 56, 27, 169, 228, 56, 230, 190, 244, 57, 251, 139, 228, 58, 198, 160, 244, 59, 219, 109, 228, 60, 175, 189, 116, 61, 187, 79, 228, 62, 143, 159, 116, 63, 155, 49, 228, 64, 111, 129, 116, 65, 132, 78, 100, 66, 79, 99, 116, 67, 100, 48, 100, 68, 47, 69, 116, 69, 68, 18, 100, 69, 243, 119, 244, 71, 45, 46, 228, 71, 211, 89, 244, 73, 13, 16, 228, 73, 179, 59, 244, 74, 236, 242, 228, 75, 156, 88, 116, 76, 214, 15, 100, 77, 124, 58, 116, 78, 182, 13, 72, 79, 92, 56, 88, 80, 149, 239, 72, 81, 60, 26, 88, 82, 117, 209, 72, 83, 27, 252, 88, 84, 85, 179, 72, 84, 251, 222, 88, 86, 53, 149, 72, 86, 228, 250, 216, 88, 30, 177, 200, 88, 196, 220, 216, 89, 254, 147, 200, 90, 164, 190, 216, 91, 222, 117, 200, 92, 132, 160, 216, 93, 190, 87, 200, 94, 100, 130, 216, 95, 158, 57, 200, 96, 77, 159, 88, 97, 135, 86, 72, 98, 45, 129, 88, 99, 103, 56, 72, 100, 13, 99, 88, 101, 71, 26, 72, 101, 237, 69, 88, 103, 38, 252, 72, 103, 205, 39, 88, 105, 6, 222, 72, 105, 173, 9, 88, 106, 230, 192, 72, 107, 150, 37, 216, 108, 207, 220, 200, 109, 118, 7, 216, 110, 175, 190, 200, 111, 85, 233, 216, 112, 143, 160, 200, 113, 53, 203, 216, 114, 111, 130, 200, 115, 21, 173, 216, 116, 79, 100, 200, 116, 254, 202, 88, 118, 56, 129, 72, 118, 222, 172, 88, 120, 24, 99, 72, 120, 190, 142, 88, 121, 248, 69, 72, 122, 158, 112, 88, 123, 216, 39, 72, 124, 126, 82, 88, 125, 184, 9, 72, 126, 94, 52, 88, 127, 151, 235, 72, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 6, 5, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 7, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 255, 255, 206, 148, 0, 0, 255, 255, 220, 164, 1, 4, 255, 255, 206, 148, 0, 8, 255, 255, 220, 216, 1, 4, 255, 255, 206, 200, 0, 8, 255, 255, 220, 216, 1, 12, 255, 255, 220, 216, 1, 16, 255, 255, 234, 232, 1, 20, 255, 255, 220, 216, 1, 4, 76, 77, 84, 0, 78, 68, 84, 0, 78, 83, 84, 0, 78, 80, 84, 0, 78, 87, 84, 0, 78, 68, 68, 84, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 10, 78, 83, 84, 51, 58, 51, 48, 78, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/St_Kitts": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 147, 55, 51, 172, 0, 1, 255, 255, 198, 84, 0, 0, 255, 255, 199, 192, 0, 4, 76, 77, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/St_Lucia": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 147, 55, 51, 172, 0, 1, 255, 255, 198, 84, 0, 0, 255, 255, 199, 192, 0, 4, 76, 77, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/St_Thomas": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 147, 55, 51, 172, 0, 1, 255, 255, 198, 84, 0, 0, 255, 255, 199, 192, 0, 4, 76, 77, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/St_Vincent": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 147, 55, 51, 172, 0, 1, 255, 255, 198, 84, 0, 0, 255, 255, 199, 192, 0, 4, 76, 77, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Swift_Current": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 24, 0, 0, 0, 6, 0, 0, 0, 24, 128, 0, 0, 0, 134, 253, 150, 24, 158, 184, 175, 144, 159, 187, 7, 128, 203, 137, 12, 144, 210, 35, 244, 112, 210, 97, 24, 0, 211, 118, 1, 16, 212, 83, 111, 0, 213, 85, 227, 16, 214, 32, 220, 0, 215, 53, 197, 16, 216, 0, 190, 0, 217, 21, 167, 16, 217, 224, 160, 0, 232, 39, 44, 16, 233, 23, 15, 0, 235, 230, 240, 16, 236, 214, 211, 0, 237, 198, 210, 16, 238, 145, 203, 0, 239, 175, 238, 144, 240, 113, 173, 0, 4, 97, 25, 144, 0, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 255, 255, 154, 232, 0, 0, 255, 255, 171, 160, 1, 4, 255, 255, 157, 144, 0, 8, 255, 255, 171, 160, 1, 12, 255, 255, 171, 160, 1, 16, 255, 255, 171, 160, 0, 20, 76, 77, 84, 0, 77, 68, 84, 0, 77, 83, 84, 0, 77, 87, 84, 0, 77, 80, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 10, 67, 83, 84, 54, 10}, - - "zoneinfo/America/Tegucigalpa": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 164, 76, 75, 68, 32, 154, 220, 224, 33, 92, 155, 80, 34, 122, 190, 224, 35, 60, 125, 80, 68, 93, 140, 224, 68, 214, 200, 208, 0, 2, 1, 2, 1, 2, 1, 2, 255, 255, 174, 60, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 54, 10}, - - "zoneinfo/America/Thule": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 96, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 155, 128, 119, 252, 39, 245, 122, 224, 40, 229, 93, 208, 41, 213, 92, 224, 42, 197, 63, 208, 43, 190, 121, 96, 44, 211, 70, 80, 45, 158, 91, 96, 46, 179, 40, 80, 47, 126, 61, 96, 48, 147, 10, 80, 49, 103, 89, 224, 50, 114, 236, 80, 51, 71, 59, 224, 52, 82, 206, 80, 53, 39, 29, 224, 54, 50, 176, 80, 55, 6, 255, 224, 56, 27, 204, 208, 56, 230, 225, 224, 57, 251, 174, 208, 58, 198, 195, 224, 59, 219, 144, 208, 60, 175, 224, 96, 61, 187, 114, 208, 62, 143, 194, 96, 63, 155, 84, 208, 64, 111, 164, 96, 65, 132, 113, 80, 66, 79, 134, 96, 67, 100, 83, 80, 68, 47, 104, 96, 69, 68, 53, 80, 69, 243, 154, 224, 71, 45, 81, 208, 71, 211, 124, 224, 73, 13, 51, 208, 73, 179, 94, 224, 74, 237, 21, 208, 75, 156, 123, 96, 76, 214, 50, 80, 77, 124, 93, 96, 78, 182, 20, 80, 79, 92, 63, 96, 80, 149, 246, 80, 81, 60, 33, 96, 82, 117, 216, 80, 83, 28, 3, 96, 84, 85, 186, 80, 84, 251, 229, 96, 86, 53, 156, 80, 86, 229, 1, 224, 88, 30, 184, 208, 88, 196, 227, 224, 89, 254, 154, 208, 90, 164, 197, 224, 91, 222, 124, 208, 92, 132, 167, 224, 93, 190, 94, 208, 94, 100, 137, 224, 95, 158, 64, 208, 96, 77, 166, 96, 97, 135, 93, 80, 98, 45, 136, 96, 99, 103, 63, 80, 100, 13, 106, 96, 101, 71, 33, 80, 101, 237, 76, 96, 103, 39, 3, 80, 103, 205, 46, 96, 105, 6, 229, 80, 105, 173, 16, 96, 106, 230, 199, 80, 107, 150, 44, 224, 108, 207, 227, 208, 109, 118, 14, 224, 110, 175, 197, 208, 111, 85, 240, 224, 112, 143, 167, 208, 113, 53, 210, 224, 114, 111, 137, 208, 115, 21, 180, 224, 116, 79, 107, 208, 116, 254, 209, 96, 118, 56, 136, 80, 118, 222, 179, 96, 120, 24, 106, 80, 120, 190, 149, 96, 121, 248, 76, 80, 122, 158, 119, 96, 123, 216, 46, 80, 124, 126, 89, 96, 125, 184, 16, 80, 126, 94, 59, 96, 127, 151, 242, 80, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 191, 132, 0, 0, 255, 255, 213, 208, 1, 4, 255, 255, 199, 192, 0, 8, 76, 77, 84, 0, 65, 68, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 65, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Thunder_Bay": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 139, 0, 0, 0, 6, 0, 0, 0, 24, 128, 0, 0, 0, 143, 36, 123, 224, 203, 136, 240, 112, 210, 35, 244, 112, 210, 96, 251, 224, 0, 151, 254, 240, 1, 135, 225, 224, 2, 119, 224, 240, 3, 112, 254, 96, 4, 96, 253, 112, 5, 80, 224, 96, 8, 32, 193, 112, 9, 16, 164, 96, 10, 0, 163, 112, 10, 240, 134, 96, 11, 224, 133, 112, 12, 217, 162, 224, 13, 192, 103, 112, 14, 185, 132, 224, 15, 169, 131, 240, 16, 153, 102, 224, 17, 137, 101, 240, 18, 121, 72, 224, 19, 105, 71, 240, 20, 89, 42, 224, 21, 73, 41, 240, 22, 57, 12, 224, 23, 41, 11, 240, 24, 34, 41, 96, 25, 8, 237, 240, 26, 2, 11, 96, 26, 242, 10, 112, 27, 225, 237, 96, 28, 209, 236, 112, 29, 193, 207, 96, 30, 177, 206, 112, 31, 161, 177, 96, 32, 118, 0, 240, 33, 129, 147, 96, 34, 85, 226, 240, 35, 106, 175, 224, 36, 53, 196, 240, 37, 74, 145, 224, 38, 21, 166, 240, 39, 42, 115, 224, 39, 254, 195, 112, 41, 10, 85, 224, 41, 222, 165, 112, 42, 234, 55, 224, 43, 190, 135, 112, 44, 211, 84, 96, 45, 158, 105, 112, 46, 179, 54, 96, 47, 126, 75, 112, 48, 147, 24, 96, 49, 103, 103, 240, 50, 114, 250, 96, 51, 71, 73, 240, 52, 82, 220, 96, 53, 39, 43, 240, 54, 50, 190, 96, 55, 7, 13, 240, 56, 27, 218, 224, 56, 230, 239, 240, 57, 251, 188, 224, 58, 198, 209, 240, 59, 219, 158, 224, 60, 175, 238, 112, 61, 187, 128, 224, 62, 143, 208, 112, 63, 155, 98, 224, 64, 111, 178, 112, 65, 132, 127, 96, 66, 79, 148, 112, 67, 100, 97, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 1, 2, 3, 4, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 255, 255, 172, 84, 0, 0, 255, 255, 171, 160, 0, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 1, 12, 255, 255, 199, 192, 1, 16, 255, 255, 199, 192, 1, 20, 76, 77, 84, 0, 67, 83, 84, 0, 69, 83, 84, 0, 69, 87, 84, 0, 69, 80, 84, 0, 69, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Tijuana": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 150, 0, 0, 0, 6, 0, 0, 0, 24, 128, 0, 0, 0, 165, 182, 246, 128, 169, 121, 79, 112, 175, 242, 124, 240, 182, 102, 100, 112, 183, 27, 16, 0, 184, 10, 242, 240, 203, 234, 141, 128, 210, 35, 244, 112, 210, 153, 186, 112, 215, 27, 89, 0, 216, 145, 180, 240, 226, 126, 75, 144, 227, 73, 82, 144, 228, 94, 45, 144, 229, 41, 52, 144, 230, 71, 74, 16, 231, 18, 81, 16, 232, 39, 44, 16, 232, 242, 51, 16, 234, 7, 14, 16, 234, 210, 21, 16, 235, 230, 240, 16, 236, 177, 247, 16, 237, 198, 210, 16, 238, 145, 217, 16, 11, 224, 175, 160, 12, 217, 205, 16, 13, 192, 145, 160, 14, 185, 175, 16, 15, 169, 174, 32, 16, 153, 145, 16, 17, 137, 144, 32, 18, 121, 115, 16, 19, 105, 114, 32, 20, 89, 85, 16, 21, 73, 84, 32, 22, 57, 55, 16, 23, 41, 54, 32, 24, 34, 83, 144, 25, 9, 24, 32, 26, 2, 53, 144, 26, 242, 52, 160, 27, 226, 23, 144, 28, 210, 22, 160, 29, 193, 249, 144, 30, 177, 248, 160, 31, 161, 219, 144, 32, 118, 43, 32, 33, 129, 189, 144, 34, 86, 13, 32, 35, 106, 218, 16, 36, 53, 239, 32, 37, 74, 188, 16, 38, 21, 209, 32, 39, 42, 158, 16, 39, 254, 237, 160, 41, 10, 128, 16, 41, 222, 207, 160, 42, 234, 98, 16, 43, 190, 177, 160, 44, 211, 126, 144, 45, 158, 147, 160, 46, 179, 96, 144, 47, 126, 117, 160, 48, 147, 66, 144, 49, 103, 146, 32, 50, 115, 36, 144, 51, 71, 116, 32, 52, 83, 6, 144, 53, 39, 86, 32, 54, 50, 232, 144, 55, 7, 56, 32, 56, 28, 5, 16, 56, 231, 26, 32, 57, 251, 231, 16, 58, 198, 252, 32, 59, 219, 201, 16, 60, 176, 24, 160, 61, 187, 171, 16, 62, 143, 250, 160, 63, 155, 141, 16, 64, 111, 220, 160, 65, 132, 169, 144, 66, 79, 190, 160, 67, 100, 139, 144, 68, 47, 160, 160, 69, 68, 109, 144, 70, 15, 130, 160, 71, 36, 79, 144, 71, 248, 159, 32, 73, 4, 49, 144, 73, 216, 129, 32, 74, 228, 19, 144, 75, 156, 179, 160, 76, 214, 106, 144, 77, 124, 149, 160, 78, 182, 76, 144, 79, 92, 119, 160, 80, 150, 46, 144, 81, 60, 89, 160, 82, 118, 16, 144, 83, 28, 59, 160, 84, 85, 242, 144, 84, 252, 29, 160, 86, 53, 212, 144, 86, 229, 58, 32, 88, 30, 241, 16, 88, 197, 28, 32, 89, 254, 211, 16, 90, 164, 254, 32, 91, 222, 181, 16, 92, 132, 224, 32, 93, 190, 151, 16, 94, 100, 194, 32, 95, 158, 121, 16, 96, 77, 222, 160, 97, 135, 149, 144, 98, 45, 192, 160, 99, 103, 119, 144, 100, 13, 162, 160, 101, 71, 89, 144, 101, 237, 132, 160, 103, 39, 59, 144, 103, 205, 102, 160, 105, 7, 29, 144, 105, 173, 72, 160, 106, 230, 255, 144, 107, 150, 101, 32, 108, 208, 28, 16, 109, 118, 71, 32, 110, 175, 254, 16, 111, 86, 41, 32, 112, 143, 224, 16, 113, 54, 11, 32, 114, 111, 194, 16, 115, 21, 237, 32, 116, 79, 164, 16, 116, 255, 9, 160, 118, 56, 192, 144, 118, 222, 235, 160, 120, 24, 162, 144, 120, 190, 205, 160, 121, 248, 132, 144, 122, 158, 175, 160, 123, 216, 102, 144, 124, 126, 145, 160, 125, 184, 72, 144, 126, 94, 115, 160, 127, 152, 42, 144, 0, 1, 2, 1, 2, 3, 2, 4, 5, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 255, 255, 146, 76, 0, 0, 255, 255, 157, 144, 0, 4, 255, 255, 143, 128, 0, 8, 255, 255, 157, 144, 1, 12, 255, 255, 157, 144, 1, 16, 255, 255, 157, 144, 1, 20, 76, 77, 84, 0, 77, 83, 84, 0, 80, 83, 84, 0, 80, 68, 84, 0, 80, 87, 84, 0, 80, 80, 84, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 10, 80, 83, 84, 56, 80, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Toronto": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 233, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 158, 184, 147, 112, 159, 186, 235, 96, 160, 135, 46, 200, 161, 154, 177, 64, 162, 148, 6, 240, 163, 85, 169, 64, 164, 134, 93, 240, 165, 40, 120, 96, 166, 102, 63, 240, 167, 12, 78, 224, 168, 70, 33, 240, 168, 236, 48, 224, 170, 28, 201, 112, 170, 213, 77, 96, 171, 252, 171, 112, 172, 181, 47, 96, 173, 220, 141, 112, 174, 149, 17, 96, 175, 188, 111, 112, 176, 126, 45, 224, 177, 156, 81, 112, 178, 103, 74, 96, 179, 124, 51, 112, 180, 71, 44, 96, 181, 92, 21, 112, 182, 39, 14, 96, 183, 59, 247, 112, 184, 6, 240, 96, 185, 37, 19, 240, 185, 230, 210, 96, 187, 4, 245, 240, 187, 207, 238, 224, 188, 228, 215, 240, 189, 175, 208, 224, 190, 196, 185, 240, 191, 143, 178, 224, 192, 164, 155, 240, 193, 111, 148, 224, 194, 132, 125, 240, 195, 79, 118, 224, 196, 100, 95, 240, 197, 47, 88, 224, 198, 77, 124, 112, 199, 15, 58, 224, 200, 45, 94, 112, 203, 136, 240, 112, 210, 35, 244, 112, 210, 96, 251, 224, 211, 117, 228, 240, 212, 64, 221, 224, 213, 85, 170, 208, 214, 32, 163, 192, 215, 53, 140, 208, 216, 0, 133, 192, 217, 21, 110, 208, 218, 51, 118, 64, 218, 254, 167, 112, 220, 19, 116, 96, 220, 222, 137, 112, 221, 169, 130, 96, 222, 190, 107, 112, 223, 137, 100, 96, 224, 158, 77, 112, 225, 105, 70, 96, 226, 126, 47, 112, 227, 73, 40, 96, 228, 94, 17, 112, 229, 41, 10, 96, 230, 71, 45, 240, 231, 18, 38, 224, 232, 39, 15, 240, 233, 22, 242, 224, 234, 6, 241, 240, 234, 246, 212, 224, 235, 230, 211, 240, 236, 214, 182, 224, 237, 198, 181, 240, 238, 191, 211, 96, 239, 175, 210, 112, 240, 159, 181, 96, 241, 143, 180, 112, 242, 127, 151, 96, 243, 111, 150, 112, 244, 95, 121, 96, 245, 79, 120, 112, 246, 63, 91, 96, 247, 47, 90, 112, 248, 40, 119, 224, 249, 15, 60, 112, 250, 8, 89, 224, 250, 248, 88, 240, 251, 232, 59, 224, 252, 216, 58, 240, 253, 200, 29, 224, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 2, 119, 224, 240, 3, 112, 254, 96, 4, 96, 253, 112, 5, 80, 224, 96, 6, 64, 223, 112, 7, 48, 194, 96, 8, 32, 193, 112, 9, 16, 164, 96, 10, 0, 163, 112, 10, 240, 134, 96, 11, 224, 133, 112, 12, 217, 162, 224, 13, 192, 103, 112, 14, 185, 132, 224, 15, 169, 131, 240, 16, 153, 102, 224, 17, 137, 101, 240, 18, 121, 72, 224, 19, 105, 71, 240, 20, 89, 42, 224, 21, 73, 41, 240, 22, 57, 12, 224, 23, 41, 11, 240, 24, 34, 41, 96, 25, 8, 237, 240, 26, 2, 11, 96, 26, 242, 10, 112, 27, 225, 237, 96, 28, 209, 236, 112, 29, 193, 207, 96, 30, 177, 206, 112, 31, 161, 177, 96, 32, 118, 0, 240, 33, 129, 147, 96, 34, 85, 226, 240, 35, 106, 175, 224, 36, 53, 196, 240, 37, 74, 145, 224, 38, 21, 166, 240, 39, 42, 115, 224, 39, 254, 195, 112, 41, 10, 85, 224, 41, 222, 165, 112, 42, 234, 55, 224, 43, 190, 135, 112, 44, 211, 84, 96, 45, 158, 105, 112, 46, 179, 54, 96, 47, 126, 75, 112, 48, 147, 24, 96, 49, 103, 103, 240, 50, 114, 250, 96, 51, 71, 73, 240, 52, 82, 220, 96, 53, 39, 43, 240, 54, 50, 190, 96, 55, 7, 13, 240, 56, 27, 218, 224, 56, 230, 239, 240, 57, 251, 188, 224, 58, 198, 209, 240, 59, 219, 158, 224, 60, 175, 238, 112, 61, 187, 128, 224, 62, 143, 208, 112, 63, 155, 98, 224, 64, 111, 178, 112, 65, 132, 127, 96, 66, 79, 148, 112, 67, 100, 97, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 181, 148, 0, 0, 255, 255, 199, 192, 1, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 1, 12, 255, 255, 199, 192, 1, 16, 76, 77, 84, 0, 69, 68, 84, 0, 69, 83, 84, 0, 69, 87, 84, 0, 69, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Tortola": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 147, 55, 51, 172, 0, 1, 255, 255, 198, 84, 0, 0, 255, 255, 199, 192, 0, 4, 76, 77, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Vancouver": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 190, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 158, 184, 189, 160, 159, 187, 21, 144, 203, 137, 26, 160, 210, 35, 244, 112, 210, 97, 38, 16, 211, 118, 15, 32, 212, 83, 125, 16, 213, 85, 241, 32, 214, 32, 234, 16, 215, 53, 211, 32, 216, 0, 204, 16, 217, 21, 181, 32, 217, 224, 174, 16, 218, 254, 209, 160, 219, 192, 144, 16, 220, 222, 179, 160, 221, 169, 172, 144, 222, 190, 149, 160, 223, 137, 142, 144, 224, 158, 119, 160, 225, 105, 112, 144, 226, 126, 89, 160, 227, 73, 82, 144, 228, 94, 59, 160, 229, 41, 52, 144, 230, 71, 88, 32, 231, 18, 81, 16, 232, 39, 58, 32, 232, 242, 51, 16, 234, 7, 28, 32, 234, 210, 21, 16, 235, 230, 254, 32, 236, 177, 247, 16, 237, 198, 224, 32, 238, 145, 217, 16, 239, 175, 252, 160, 240, 113, 187, 16, 241, 143, 222, 160, 242, 127, 193, 144, 243, 111, 192, 160, 244, 95, 163, 144, 245, 79, 162, 160, 246, 63, 133, 144, 247, 47, 132, 160, 248, 40, 162, 16, 249, 15, 102, 160, 250, 8, 132, 16, 250, 248, 131, 32, 251, 232, 102, 16, 252, 216, 101, 32, 253, 200, 72, 16, 254, 184, 71, 32, 255, 168, 42, 16, 0, 152, 41, 32, 1, 136, 12, 16, 2, 120, 11, 32, 3, 113, 40, 144, 4, 97, 39, 160, 5, 81, 10, 144, 6, 65, 9, 160, 7, 48, 236, 144, 8, 32, 235, 160, 9, 16, 206, 144, 10, 0, 205, 160, 10, 240, 176, 144, 11, 224, 175, 160, 12, 217, 205, 16, 13, 192, 145, 160, 14, 185, 175, 16, 15, 169, 174, 32, 16, 153, 145, 16, 17, 137, 144, 32, 18, 121, 115, 16, 19, 105, 114, 32, 20, 89, 85, 16, 21, 73, 84, 32, 22, 57, 55, 16, 23, 41, 54, 32, 24, 34, 83, 144, 25, 9, 24, 32, 26, 2, 53, 144, 26, 242, 52, 160, 27, 226, 23, 144, 28, 210, 22, 160, 29, 193, 249, 144, 30, 177, 248, 160, 31, 161, 219, 144, 32, 118, 43, 32, 33, 129, 189, 144, 34, 86, 13, 32, 35, 106, 218, 16, 36, 53, 239, 32, 37, 74, 188, 16, 38, 21, 209, 32, 39, 42, 158, 16, 39, 254, 237, 160, 41, 10, 128, 16, 41, 222, 207, 160, 42, 234, 98, 16, 43, 190, 177, 160, 44, 211, 126, 144, 45, 158, 147, 160, 46, 179, 96, 144, 47, 126, 117, 160, 48, 147, 66, 144, 49, 103, 146, 32, 50, 115, 36, 144, 51, 71, 116, 32, 52, 83, 6, 144, 53, 39, 86, 32, 54, 50, 232, 144, 55, 7, 56, 32, 56, 28, 5, 16, 56, 231, 26, 32, 57, 251, 231, 16, 58, 198, 252, 32, 59, 219, 201, 16, 60, 176, 24, 160, 61, 187, 171, 16, 62, 143, 250, 160, 63, 155, 141, 16, 64, 111, 220, 160, 65, 132, 169, 144, 66, 79, 190, 160, 67, 100, 139, 144, 68, 47, 160, 160, 69, 68, 109, 144, 69, 243, 211, 32, 71, 45, 138, 16, 71, 211, 181, 32, 73, 13, 108, 16, 73, 179, 151, 32, 74, 237, 78, 16, 75, 156, 179, 160, 76, 214, 106, 144, 77, 124, 149, 160, 78, 182, 76, 144, 79, 92, 119, 160, 80, 150, 46, 144, 81, 60, 89, 160, 82, 118, 16, 144, 83, 28, 59, 160, 84, 85, 242, 144, 84, 252, 29, 160, 86, 53, 212, 144, 86, 229, 58, 32, 88, 30, 241, 16, 88, 197, 28, 32, 89, 254, 211, 16, 90, 164, 254, 32, 91, 222, 181, 16, 92, 132, 224, 32, 93, 190, 151, 16, 94, 100, 194, 32, 95, 158, 121, 16, 96, 77, 222, 160, 97, 135, 149, 144, 98, 45, 192, 160, 99, 103, 119, 144, 100, 13, 162, 160, 101, 71, 89, 144, 101, 237, 132, 160, 103, 39, 59, 144, 103, 205, 102, 160, 105, 7, 29, 144, 105, 173, 72, 160, 106, 230, 255, 144, 107, 150, 101, 32, 108, 208, 28, 16, 109, 118, 71, 32, 110, 175, 254, 16, 111, 86, 41, 32, 112, 143, 224, 16, 113, 54, 11, 32, 114, 111, 194, 16, 115, 21, 237, 32, 116, 79, 164, 16, 116, 255, 9, 160, 118, 56, 192, 144, 118, 222, 235, 160, 120, 24, 162, 144, 120, 190, 205, 160, 121, 248, 132, 144, 122, 158, 175, 160, 123, 216, 102, 144, 124, 126, 145, 160, 125, 184, 72, 144, 126, 94, 115, 160, 127, 152, 42, 144, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 140, 148, 0, 0, 255, 255, 157, 144, 1, 4, 255, 255, 143, 128, 0, 8, 255, 255, 157, 144, 1, 12, 255, 255, 157, 144, 1, 16, 76, 77, 84, 0, 80, 68, 84, 0, 80, 83, 84, 0, 80, 87, 84, 0, 80, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 80, 83, 84, 56, 80, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Virgin": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 147, 55, 51, 172, 0, 1, 255, 255, 198, 84, 0, 0, 255, 255, 199, 192, 0, 4, 76, 77, 84, 0, 65, 83, 84, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 10}, - - "zoneinfo/America/Whitehorse": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 127, 0, 0, 0, 8, 0, 0, 0, 33, 128, 0, 0, 0, 158, 184, 203, 176, 159, 187, 35, 160, 160, 208, 12, 176, 161, 162, 210, 128, 203, 137, 40, 176, 210, 35, 244, 112, 210, 97, 52, 32, 247, 47, 118, 144, 248, 40, 162, 16, 251, 29, 95, 16, 19, 105, 114, 32, 20, 89, 85, 16, 21, 73, 84, 32, 22, 57, 55, 16, 23, 41, 54, 32, 24, 34, 83, 144, 25, 9, 24, 32, 26, 2, 53, 144, 26, 242, 52, 160, 27, 226, 23, 144, 28, 210, 22, 160, 29, 193, 249, 144, 30, 177, 248, 160, 31, 161, 219, 144, 32, 118, 43, 32, 33, 129, 189, 144, 34, 86, 13, 32, 35, 106, 218, 16, 36, 53, 239, 32, 37, 74, 188, 16, 38, 21, 209, 32, 39, 42, 158, 16, 39, 254, 237, 160, 41, 10, 128, 16, 41, 222, 207, 160, 42, 234, 98, 16, 43, 190, 177, 160, 44, 211, 126, 144, 45, 158, 147, 160, 46, 179, 96, 144, 47, 126, 117, 160, 48, 147, 66, 144, 49, 103, 146, 32, 50, 115, 36, 144, 51, 71, 116, 32, 52, 83, 6, 144, 53, 39, 86, 32, 54, 50, 232, 144, 55, 7, 56, 32, 56, 28, 5, 16, 56, 231, 26, 32, 57, 251, 231, 16, 58, 198, 252, 32, 59, 219, 201, 16, 60, 176, 24, 160, 61, 187, 171, 16, 62, 143, 250, 160, 63, 155, 141, 16, 64, 111, 220, 160, 65, 132, 169, 144, 66, 79, 190, 160, 67, 100, 139, 144, 68, 47, 160, 160, 69, 68, 109, 144, 69, 243, 211, 32, 71, 45, 138, 16, 71, 211, 181, 32, 73, 13, 108, 16, 73, 179, 151, 32, 74, 237, 78, 16, 75, 156, 179, 160, 76, 214, 106, 144, 77, 124, 149, 160, 78, 182, 76, 144, 79, 92, 119, 160, 80, 150, 46, 144, 81, 60, 89, 160, 82, 118, 16, 144, 83, 28, 59, 160, 84, 85, 242, 144, 84, 252, 29, 160, 86, 53, 212, 144, 86, 229, 58, 32, 88, 30, 241, 16, 88, 197, 28, 32, 89, 254, 211, 16, 90, 164, 254, 32, 91, 222, 181, 16, 92, 132, 224, 32, 93, 190, 151, 16, 94, 100, 194, 32, 95, 158, 121, 16, 96, 77, 222, 160, 97, 135, 149, 144, 98, 45, 192, 160, 99, 103, 119, 144, 100, 13, 162, 160, 101, 71, 89, 144, 101, 237, 132, 160, 103, 39, 59, 144, 103, 205, 102, 160, 105, 7, 29, 144, 105, 173, 72, 160, 106, 230, 255, 144, 107, 150, 101, 32, 108, 208, 28, 16, 109, 118, 71, 32, 110, 175, 254, 16, 111, 86, 41, 32, 112, 143, 224, 16, 113, 54, 11, 32, 114, 111, 194, 16, 115, 21, 237, 32, 116, 79, 164, 16, 116, 255, 9, 160, 118, 56, 192, 144, 118, 222, 235, 160, 120, 24, 162, 144, 120, 190, 205, 160, 121, 248, 132, 144, 122, 158, 175, 160, 123, 216, 102, 144, 124, 126, 145, 160, 125, 184, 72, 144, 126, 94, 115, 160, 127, 152, 42, 144, 2, 1, 2, 1, 2, 3, 4, 2, 5, 2, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 255, 255, 129, 100, 0, 0, 255, 255, 143, 128, 1, 4, 255, 255, 129, 112, 0, 8, 255, 255, 143, 128, 1, 12, 255, 255, 143, 128, 1, 16, 255, 255, 157, 144, 1, 20, 255, 255, 143, 128, 0, 25, 255, 255, 157, 144, 1, 29, 76, 77, 84, 0, 89, 68, 84, 0, 89, 83, 84, 0, 89, 87, 84, 0, 89, 80, 84, 0, 89, 68, 68, 84, 0, 80, 83, 84, 0, 80, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 10, 80, 83, 84, 56, 80, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Winnipeg": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 187, 0, 0, 0, 7, 0, 0, 0, 20, 128, 0, 0, 0, 155, 1, 251, 224, 155, 195, 186, 80, 158, 184, 161, 128, 159, 186, 249, 112, 194, 160, 59, 128, 195, 79, 132, 240, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 211, 136, 104, 0, 212, 83, 96, 240, 213, 85, 213, 0, 214, 32, 205, 240, 215, 53, 183, 0, 216, 0, 175, 240, 217, 21, 153, 0, 217, 224, 145, 240, 219, 0, 7, 0, 219, 200, 92, 240, 220, 222, 151, 128, 221, 169, 144, 112, 222, 190, 121, 128, 223, 137, 114, 112, 224, 158, 91, 128, 225, 105, 84, 112, 226, 126, 61, 128, 227, 73, 54, 112, 228, 94, 31, 128, 229, 41, 24, 112, 230, 71, 60, 0, 231, 18, 52, 240, 232, 39, 30, 0, 232, 242, 22, 240, 234, 7, 0, 0, 234, 209, 248, 240, 235, 230, 226, 0, 236, 214, 196, 240, 237, 198, 196, 0, 238, 145, 188, 240, 243, 111, 164, 128, 244, 49, 98, 240, 249, 15, 74, 128, 250, 8, 118, 0, 250, 248, 103, 0, 251, 232, 88, 0, 252, 216, 73, 0, 253, 200, 58, 0, 254, 184, 43, 0, 255, 168, 28, 0, 0, 152, 13, 0, 1, 135, 254, 0, 2, 119, 239, 0, 3, 113, 26, 128, 4, 97, 11, 128, 5, 80, 252, 128, 6, 64, 237, 128, 7, 48, 222, 128, 8, 32, 207, 128, 9, 16, 192, 128, 10, 0, 177, 128, 10, 240, 162, 128, 11, 224, 147, 128, 12, 217, 191, 0, 13, 192, 117, 128, 14, 185, 161, 0, 15, 169, 146, 0, 16, 153, 131, 0, 17, 137, 116, 0, 18, 121, 101, 0, 19, 105, 86, 0, 20, 89, 71, 0, 21, 73, 56, 0, 22, 57, 41, 0, 23, 41, 26, 0, 24, 34, 69, 128, 25, 8, 252, 0, 26, 2, 39, 128, 26, 242, 24, 128, 27, 226, 9, 128, 28, 209, 250, 128, 29, 193, 235, 128, 30, 177, 220, 128, 31, 161, 205, 128, 32, 118, 15, 0, 33, 129, 175, 128, 34, 85, 241, 0, 35, 106, 204, 0, 36, 53, 211, 0, 37, 74, 174, 0, 38, 21, 181, 0, 39, 42, 144, 0, 39, 254, 209, 128, 41, 10, 114, 0, 41, 222, 179, 128, 42, 234, 84, 0, 43, 190, 149, 128, 44, 211, 112, 128, 45, 158, 119, 128, 46, 179, 82, 128, 47, 126, 89, 128, 48, 147, 52, 128, 49, 103, 118, 0, 50, 115, 22, 128, 51, 71, 88, 0, 52, 82, 248, 128, 53, 39, 58, 0, 54, 50, 218, 128, 55, 7, 28, 0, 56, 27, 247, 0, 56, 230, 254, 0, 57, 251, 217, 0, 58, 198, 224, 0, 59, 219, 187, 0, 60, 175, 252, 128, 61, 187, 157, 0, 62, 143, 222, 128, 63, 155, 127, 0, 64, 111, 192, 128, 65, 132, 155, 128, 66, 79, 162, 128, 67, 100, 125, 128, 67, 183, 111, 224, 68, 47, 132, 128, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 109, 240, 71, 211, 153, 0, 73, 13, 79, 240, 73, 179, 123, 0, 74, 237, 49, 240, 75, 156, 151, 128, 76, 214, 78, 112, 77, 124, 121, 128, 78, 182, 48, 112, 79, 92, 91, 128, 80, 150, 18, 112, 81, 60, 61, 128, 82, 117, 244, 112, 83, 28, 31, 128, 84, 85, 214, 112, 84, 252, 1, 128, 86, 53, 184, 112, 86, 229, 30, 0, 88, 30, 212, 240, 88, 197, 0, 0, 89, 254, 182, 240, 90, 164, 226, 0, 91, 222, 152, 240, 92, 132, 196, 0, 93, 190, 122, 240, 94, 100, 166, 0, 95, 158, 92, 240, 96, 77, 194, 128, 97, 135, 121, 112, 98, 45, 164, 128, 99, 103, 91, 112, 100, 13, 134, 128, 101, 71, 61, 112, 101, 237, 104, 128, 103, 39, 31, 112, 103, 205, 74, 128, 105, 7, 1, 112, 105, 173, 44, 128, 106, 230, 227, 112, 107, 150, 73, 0, 108, 207, 255, 240, 109, 118, 43, 0, 110, 175, 225, 240, 111, 86, 13, 0, 112, 143, 195, 240, 113, 53, 239, 0, 114, 111, 165, 240, 115, 21, 209, 0, 116, 79, 135, 240, 116, 254, 237, 128, 118, 56, 164, 112, 118, 222, 207, 128, 120, 24, 134, 112, 120, 190, 177, 128, 121, 248, 104, 112, 122, 158, 147, 128, 123, 216, 74, 112, 124, 126, 117, 128, 125, 184, 44, 112, 126, 94, 87, 128, 127, 152, 14, 112, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 164, 236, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Yakutat": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 143, 0, 0, 0, 7, 0, 0, 0, 30, 128, 0, 0, 0, 203, 137, 40, 176, 210, 35, 244, 112, 210, 97, 52, 32, 254, 184, 85, 48, 255, 168, 56, 32, 0, 152, 55, 48, 1, 136, 26, 32, 2, 120, 25, 48, 3, 113, 54, 160, 4, 97, 53, 176, 5, 81, 24, 160, 6, 65, 23, 176, 7, 48, 250, 160, 7, 141, 81, 176, 9, 16, 220, 160, 9, 173, 205, 48, 10, 240, 190, 160, 11, 224, 189, 176, 12, 217, 219, 32, 13, 192, 159, 176, 14, 185, 189, 32, 15, 169, 188, 48, 16, 153, 159, 32, 17, 137, 158, 48, 18, 121, 129, 32, 19, 105, 128, 48, 20, 89, 99, 32, 21, 73, 98, 48, 22, 57, 69, 32, 23, 41, 68, 48, 24, 34, 97, 160, 25, 9, 38, 48, 26, 2, 67, 160, 26, 43, 20, 16, 26, 242, 66, 176, 27, 226, 37, 160, 28, 210, 36, 176, 29, 194, 7, 160, 30, 178, 6, 176, 31, 161, 233, 160, 32, 118, 57, 48, 33, 129, 203, 160, 34, 86, 27, 48, 35, 106, 232, 32, 36, 53, 253, 48, 37, 74, 202, 32, 38, 21, 223, 48, 39, 42, 172, 32, 39, 254, 251, 176, 41, 10, 142, 32, 41, 222, 221, 176, 42, 234, 112, 32, 43, 190, 191, 176, 44, 211, 140, 160, 45, 158, 161, 176, 46, 179, 110, 160, 47, 126, 131, 176, 48, 147, 80, 160, 49, 103, 160, 48, 50, 115, 50, 160, 51, 71, 130, 48, 52, 83, 20, 160, 53, 39, 100, 48, 54, 50, 246, 160, 55, 7, 70, 48, 56, 28, 19, 32, 56, 231, 40, 48, 57, 251, 245, 32, 58, 199, 10, 48, 59, 219, 215, 32, 60, 176, 38, 176, 61, 187, 185, 32, 62, 144, 8, 176, 63, 155, 155, 32, 64, 111, 234, 176, 65, 132, 183, 160, 66, 79, 204, 176, 67, 100, 153, 160, 68, 47, 174, 176, 69, 68, 123, 160, 69, 243, 225, 48, 71, 45, 152, 32, 71, 211, 195, 48, 73, 13, 122, 32, 73, 179, 165, 48, 74, 237, 92, 32, 75, 156, 193, 176, 76, 214, 120, 160, 77, 124, 163, 176, 78, 182, 90, 160, 79, 92, 133, 176, 80, 150, 60, 160, 81, 60, 103, 176, 82, 118, 30, 160, 83, 28, 73, 176, 84, 86, 0, 160, 84, 252, 43, 176, 86, 53, 226, 160, 86, 229, 72, 48, 88, 30, 255, 32, 88, 197, 42, 48, 89, 254, 225, 32, 90, 165, 12, 48, 91, 222, 195, 32, 92, 132, 238, 48, 93, 190, 165, 32, 94, 100, 208, 48, 95, 158, 135, 32, 96, 77, 236, 176, 97, 135, 163, 160, 98, 45, 206, 176, 99, 103, 133, 160, 100, 13, 176, 176, 101, 71, 103, 160, 101, 237, 146, 176, 103, 39, 73, 160, 103, 205, 116, 176, 105, 7, 43, 160, 105, 173, 86, 176, 106, 231, 13, 160, 107, 150, 115, 48, 108, 208, 42, 32, 109, 118, 85, 48, 110, 176, 12, 32, 111, 86, 55, 48, 112, 143, 238, 32, 113, 54, 25, 48, 114, 111, 208, 32, 115, 21, 251, 48, 116, 79, 178, 32, 116, 255, 23, 176, 118, 56, 206, 160, 118, 222, 249, 176, 120, 24, 176, 160, 120, 190, 219, 176, 121, 248, 146, 160, 122, 158, 189, 176, 123, 216, 116, 160, 124, 126, 159, 176, 125, 184, 86, 160, 126, 94, 129, 176, 127, 152, 56, 160, 1, 2, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 255, 255, 125, 1, 0, 0, 255, 255, 129, 112, 0, 4, 255, 255, 143, 128, 1, 8, 255, 255, 143, 128, 1, 12, 255, 255, 143, 128, 1, 16, 255, 255, 143, 128, 1, 20, 255, 255, 129, 112, 0, 25, 76, 77, 84, 0, 89, 83, 84, 0, 89, 87, 84, 0, 89, 80, 84, 0, 89, 68, 84, 0, 65, 75, 68, 84, 0, 65, 75, 83, 84, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 10, 65, 75, 83, 84, 57, 65, 75, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/America/Yellowknife": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 123, 0, 0, 0, 6, 0, 0, 0, 25, 128, 0, 0, 0, 190, 42, 24, 0, 203, 137, 12, 144, 210, 35, 244, 112, 210, 97, 24, 0, 247, 47, 90, 112, 248, 40, 133, 240, 19, 105, 100, 16, 20, 89, 71, 0, 21, 73, 70, 16, 22, 57, 41, 0, 23, 41, 40, 16, 24, 34, 69, 128, 25, 9, 10, 16, 26, 2, 39, 128, 26, 242, 38, 144, 27, 226, 9, 128, 28, 210, 8, 144, 29, 193, 235, 128, 30, 177, 234, 144, 31, 161, 205, 128, 32, 118, 29, 16, 33, 129, 175, 128, 34, 85, 255, 16, 35, 106, 204, 0, 36, 53, 225, 16, 37, 74, 174, 0, 38, 21, 195, 16, 39, 42, 144, 0, 39, 254, 223, 144, 41, 10, 114, 0, 41, 222, 193, 144, 42, 234, 84, 0, 43, 190, 163, 144, 44, 211, 112, 128, 45, 158, 133, 144, 46, 179, 82, 128, 47, 126, 103, 144, 48, 147, 52, 128, 49, 103, 132, 16, 50, 115, 22, 128, 51, 71, 102, 16, 52, 82, 248, 128, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 231, 12, 16, 57, 251, 217, 0, 58, 198, 238, 16, 59, 219, 187, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 206, 144, 65, 132, 155, 128, 66, 79, 176, 144, 67, 100, 125, 128, 68, 47, 146, 144, 69, 68, 95, 128, 69, 243, 197, 16, 71, 45, 124, 0, 71, 211, 167, 16, 73, 13, 94, 0, 73, 179, 137, 16, 74, 237, 64, 0, 75, 156, 165, 144, 76, 214, 92, 128, 77, 124, 135, 144, 78, 182, 62, 128, 79, 92, 105, 144, 80, 150, 32, 128, 81, 60, 75, 144, 82, 118, 2, 128, 83, 28, 45, 144, 84, 85, 228, 128, 84, 252, 15, 144, 86, 53, 198, 128, 86, 229, 44, 16, 88, 30, 227, 0, 88, 197, 14, 16, 89, 254, 197, 0, 90, 164, 240, 16, 91, 222, 167, 0, 92, 132, 210, 16, 93, 190, 137, 0, 94, 100, 180, 16, 95, 158, 107, 0, 96, 77, 208, 144, 97, 135, 135, 128, 98, 45, 178, 144, 99, 103, 105, 128, 100, 13, 148, 144, 101, 71, 75, 128, 101, 237, 118, 144, 103, 39, 45, 128, 103, 205, 88, 144, 105, 7, 15, 128, 105, 173, 58, 144, 106, 230, 241, 128, 107, 150, 87, 16, 108, 208, 14, 0, 109, 118, 57, 16, 110, 175, 240, 0, 111, 86, 27, 16, 112, 143, 210, 0, 113, 53, 253, 16, 114, 111, 180, 0, 115, 21, 223, 16, 116, 79, 150, 0, 116, 254, 251, 144, 118, 56, 178, 128, 118, 222, 221, 144, 120, 24, 148, 128, 120, 190, 191, 144, 121, 248, 118, 128, 122, 158, 161, 144, 123, 216, 88, 128, 124, 126, 131, 144, 125, 184, 58, 128, 126, 94, 101, 144, 127, 152, 28, 128, 0, 3, 1, 2, 3, 4, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 5, 3, 0, 0, 0, 0, 0, 0, 255, 255, 171, 160, 1, 4, 255, 255, 171, 160, 1, 8, 255, 255, 157, 144, 0, 12, 255, 255, 185, 176, 1, 16, 255, 255, 171, 160, 1, 21, 45, 48, 48, 0, 77, 87, 84, 0, 77, 80, 84, 0, 77, 83, 84, 0, 77, 68, 68, 84, 0, 77, 68, 84, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 10, 77, 83, 84, 55, 77, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/Antarctica/Casey": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 5, 0, 0, 0, 12, 128, 0, 0, 0, 254, 30, 204, 128, 74, 218, 6, 32, 75, 143, 202, 240, 78, 169, 156, 32, 79, 67, 205, 144, 88, 10, 59, 128, 127, 255, 255, 255, 0, 1, 2, 1, 2, 3, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 112, 128, 0, 4, 0, 0, 154, 176, 0, 8, 0, 0, 112, 128, 0, 4, 0, 0, 154, 176, 0, 8, 45, 48, 48, 0, 43, 48, 56, 0, 43, 49, 49, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 10, 60, 43, 49, 49, 62, 45, 49, 49, 10}, - - "zoneinfo/Antarctica/Davis": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 4, 0, 0, 0, 12, 128, 0, 0, 0, 231, 156, 64, 0, 246, 71, 223, 16, 254, 71, 171, 0, 74, 218, 20, 48, 75, 151, 250, 64, 78, 169, 170, 48, 79, 67, 247, 192, 127, 255, 255, 255, 0, 1, 0, 1, 2, 3, 2, 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 98, 112, 0, 4, 0, 0, 70, 80, 0, 8, 0, 0, 98, 112, 0, 4, 45, 48, 48, 0, 43, 48, 55, 0, 43, 48, 53, 0, 0, 0, 0, 1, 0, 0, 0, 1, 10, 60, 43, 48, 55, 62, 45, 55, 10}, - - "zoneinfo/Antarctica/DumontDUrville": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 212, 188, 118, 128, 222, 52, 96, 96, 231, 60, 2, 128, 127, 255, 255, 255, 0, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 140, 160, 0, 4, 45, 48, 48, 0, 43, 49, 48, 0, 0, 0, 0, 0, 10, 60, 43, 49, 48, 62, 45, 49, 48, 10}, - - "zoneinfo/Antarctica/Macquarie": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 92, 0, 0, 0, 7, 0, 0, 0, 18, 128, 0, 0, 0, 155, 213, 120, 128, 156, 188, 32, 240, 160, 135, 180, 96, 215, 12, 104, 0, 251, 194, 141, 0, 252, 178, 126, 0, 253, 199, 89, 0, 254, 118, 176, 128, 255, 167, 59, 0, 0, 86, 146, 128, 1, 135, 29, 0, 2, 63, 175, 0, 3, 112, 57, 128, 4, 13, 28, 0, 5, 80, 27, 128, 5, 246, 56, 128, 7, 47, 253, 128, 7, 214, 26, 128, 9, 15, 223, 128, 9, 181, 252, 128, 10, 239, 193, 128, 11, 159, 25, 0, 12, 216, 222, 0, 13, 126, 251, 0, 14, 184, 192, 0, 15, 94, 221, 0, 16, 152, 162, 0, 17, 62, 191, 0, 18, 120, 132, 0, 19, 30, 161, 0, 20, 88, 102, 0, 20, 254, 131, 0, 22, 56, 72, 0, 23, 3, 79, 0, 24, 33, 100, 128, 24, 227, 49, 0, 26, 1, 70, 128, 26, 167, 99, 128, 27, 225, 40, 128, 28, 135, 69, 128, 29, 193, 10, 128, 30, 103, 39, 128, 31, 151, 178, 0, 32, 89, 126, 128, 33, 128, 206, 128, 34, 66, 155, 0, 35, 105, 235, 0, 36, 34, 125, 0, 37, 73, 205, 0, 38, 2, 95, 0, 39, 41, 175, 0, 39, 244, 182, 0, 40, 237, 225, 128, 41, 212, 152, 0, 42, 205, 195, 128, 43, 180, 122, 0, 44, 173, 165, 128, 45, 148, 92, 0, 46, 141, 135, 128, 47, 116, 62, 0, 48, 109, 105, 128, 49, 93, 90, 128, 50, 86, 134, 0, 51, 61, 60, 128, 52, 54, 104, 0, 53, 29, 30, 128, 54, 22, 74, 0, 54, 253, 0, 128, 55, 246, 44, 0, 56, 220, 226, 128, 57, 167, 233, 128, 58, 188, 196, 128, 59, 191, 42, 128, 60, 165, 225, 0, 61, 159, 12, 128, 62, 133, 195, 0, 63, 126, 238, 128, 64, 101, 165, 0, 65, 94, 208, 128, 66, 69, 135, 0, 67, 62, 178, 128, 68, 46, 163, 128, 69, 30, 148, 128, 70, 5, 75, 0, 71, 7, 177, 0, 71, 247, 162, 0, 72, 231, 147, 0, 73, 215, 132, 0, 74, 199, 117, 0, 75, 183, 102, 0, 127, 255, 255, 255, 1, 2, 1, 3, 1, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 6, 0, 0, 0, 0, 0, 0, 0, 0, 140, 160, 0, 4, 0, 0, 154, 176, 1, 9, 0, 0, 0, 0, 0, 0, 0, 0, 154, 176, 1, 9, 0, 0, 140, 160, 0, 4, 0, 0, 154, 176, 0, 14, 45, 48, 48, 0, 65, 69, 83, 84, 0, 65, 69, 68, 84, 0, 43, 49, 49, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 49, 62, 45, 49, 49, 10}, - - "zoneinfo/Antarctica/Mawson": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 226, 32, 50, 128, 74, 218, 34, 64, 127, 255, 255, 255, 0, 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 84, 96, 0, 4, 0, 0, 70, 80, 0, 8, 45, 48, 48, 0, 43, 48, 54, 0, 43, 48, 53, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 53, 62, 45, 53, 10}, - - "zoneinfo/Antarctica/McMurdo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, 0, 7, 0, 0, 0, 19, 128, 0, 0, 0, 176, 180, 178, 232, 177, 81, 135, 88, 178, 120, 229, 104, 179, 67, 229, 96, 180, 88, 199, 104, 181, 35, 199, 96, 182, 56, 169, 104, 183, 3, 169, 96, 184, 24, 139, 104, 184, 236, 197, 224, 185, 248, 109, 104, 186, 204, 167, 224, 187, 216, 79, 104, 188, 227, 232, 224, 189, 174, 246, 232, 190, 195, 202, 224, 191, 142, 216, 232, 192, 163, 172, 224, 193, 110, 186, 232, 194, 131, 142, 224, 195, 78, 156, 232, 196, 99, 112, 224, 197, 46, 126, 232, 198, 76, 141, 96, 199, 14, 96, 232, 200, 44, 111, 96, 200, 247, 125, 104, 210, 218, 154, 64, 9, 24, 253, 224, 9, 172, 165, 224, 10, 239, 165, 96, 11, 158, 252, 224, 12, 216, 193, 224, 13, 126, 222, 224, 14, 184, 163, 224, 15, 94, 192, 224, 16, 152, 133, 224, 17, 62, 162, 224, 18, 120, 103, 224, 19, 30, 132, 224, 20, 88, 73, 224, 20, 254, 102, 224, 22, 56, 43, 224, 22, 231, 131, 96, 24, 33, 72, 96, 24, 199, 101, 96, 26, 1, 42, 96, 26, 167, 71, 96, 27, 225, 12, 96, 28, 135, 41, 96, 29, 192, 238, 96, 30, 103, 11, 96, 31, 160, 208, 96, 32, 70, 237, 96, 33, 128, 178, 96, 34, 48, 9, 224, 35, 105, 206, 224, 36, 15, 235, 224, 37, 46, 1, 96, 38, 2, 66, 224, 39, 13, 227, 96, 39, 226, 36, 224, 40, 237, 197, 96, 41, 194, 6, 224, 42, 205, 167, 96, 43, 171, 35, 96, 44, 173, 137, 96, 45, 139, 5, 96, 46, 141, 107, 96, 47, 106, 231, 96, 48, 109, 77, 96, 49, 74, 201, 96, 50, 86, 105, 224, 51, 42, 171, 96, 52, 54, 75, 224, 53, 10, 141, 96, 54, 22, 45, 224, 54, 243, 169, 224, 55, 246, 15, 224, 56, 211, 139, 224, 57, 213, 241, 224, 58, 179, 109, 224, 59, 191, 14, 96, 60, 147, 79, 224, 61, 158, 240, 96, 62, 115, 49, 224, 63, 126, 210, 96, 64, 92, 78, 96, 65, 94, 180, 96, 66, 60, 48, 96, 67, 62, 150, 96, 68, 28, 18, 96, 69, 30, 120, 96, 69, 251, 244, 96, 70, 254, 90, 96, 71, 247, 133, 224, 72, 222, 60, 96, 73, 215, 103, 224, 74, 190, 30, 96, 75, 183, 73, 224, 76, 158, 0, 96, 77, 151, 43, 224, 78, 125, 226, 96, 79, 119, 13, 224, 80, 102, 254, 224, 81, 96, 42, 96, 82, 70, 224, 224, 83, 64, 12, 96, 84, 38, 194, 224, 85, 31, 238, 96, 86, 6, 164, 224, 86, 255, 208, 96, 87, 230, 134, 224, 88, 223, 178, 96, 89, 198, 104, 224, 90, 191, 148, 96, 91, 175, 133, 96, 92, 168, 176, 224, 93, 143, 103, 96, 94, 136, 146, 224, 95, 111, 73, 96, 96, 104, 116, 224, 97, 79, 43, 96, 98, 72, 86, 224, 99, 47, 13, 96, 100, 40, 56, 224, 101, 14, 239, 96, 102, 17, 85, 96, 102, 248, 11, 224, 103, 241, 55, 96, 104, 215, 237, 224, 105, 209, 25, 96, 106, 183, 207, 224, 107, 176, 251, 96, 108, 151, 177, 224, 109, 144, 221, 96, 110, 119, 147, 224, 111, 112, 191, 96, 112, 96, 176, 96, 113, 89, 219, 224, 114, 64, 146, 96, 115, 57, 189, 224, 116, 32, 116, 96, 117, 25, 159, 224, 118, 0, 86, 96, 118, 249, 129, 224, 119, 224, 56, 96, 120, 217, 99, 224, 121, 192, 26, 96, 122, 185, 69, 224, 123, 169, 54, 224, 124, 162, 98, 96, 125, 137, 24, 224, 126, 130, 68, 96, 127, 104, 250, 224, 2, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 6, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 0, 0, 163, 216, 0, 0, 0, 0, 175, 200, 1, 4, 0, 0, 161, 184, 0, 9, 0, 0, 168, 192, 1, 4, 0, 0, 182, 208, 1, 14, 0, 0, 168, 192, 0, 4, 0, 0, 168, 192, 0, 4, 76, 77, 84, 0, 78, 90, 83, 84, 0, 78, 90, 77, 84, 0, 78, 90, 68, 84, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 10, 78, 90, 83, 84, 45, 49, 50, 78, 90, 68, 84, 44, 77, 57, 46, 53, 46, 48, 44, 77, 52, 46, 49, 46, 48, 47, 51, 10}, - - "zoneinfo/Antarctica/Palmer": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 84, 0, 0, 0, 8, 0, 0, 0, 16, 128, 0, 0, 0, 246, 152, 173, 0, 246, 230, 159, 176, 248, 19, 67, 192, 248, 199, 211, 48, 249, 244, 119, 64, 250, 211, 54, 176, 251, 195, 53, 192, 252, 188, 83, 48, 253, 172, 82, 64, 254, 156, 53, 48, 255, 140, 52, 64, 7, 163, 74, 176, 8, 36, 111, 160, 23, 48, 188, 176, 24, 6, 93, 192, 24, 209, 86, 176, 25, 230, 63, 192, 26, 177, 56, 176, 27, 207, 92, 64, 28, 145, 26, 176, 29, 175, 62, 64, 30, 112, 252, 176, 31, 143, 32, 64, 32, 127, 3, 48, 33, 111, 2, 64, 34, 57, 251, 48, 35, 78, 228, 64, 36, 25, 221, 48, 37, 56, 0, 192, 37, 249, 191, 48, 38, 242, 248, 192, 39, 217, 161, 48, 40, 247, 196, 192, 41, 194, 189, 176, 42, 215, 166, 192, 43, 162, 159, 176, 44, 183, 136, 192, 45, 130, 129, 176, 46, 151, 106, 192, 47, 98, 99, 176, 48, 128, 135, 64, 49, 66, 69, 176, 50, 96, 105, 64, 51, 61, 215, 48, 52, 64, 75, 64, 53, 11, 68, 48, 54, 13, 184, 64, 55, 6, 213, 176, 56, 0, 15, 64, 56, 203, 8, 48, 57, 233, 43, 192, 58, 170, 234, 48, 59, 201, 13, 192, 60, 138, 204, 48, 61, 168, 239, 192, 62, 106, 174, 48, 63, 136, 209, 192, 64, 83, 202, 176, 65, 104, 179, 192, 66, 51, 172, 176, 67, 72, 149, 192, 68, 19, 142, 176, 69, 49, 178, 64, 69, 243, 112, 176, 71, 17, 148, 64, 71, 239, 2, 48, 72, 241, 118, 64, 73, 188, 111, 48, 74, 209, 88, 64, 75, 184, 0, 176, 76, 177, 58, 64, 77, 198, 7, 48, 78, 80, 130, 192, 79, 156, 174, 176, 80, 66, 217, 192, 81, 124, 144, 176, 82, 43, 246, 64, 83, 92, 114, 176, 84, 11, 216, 64, 87, 55, 230, 48, 87, 175, 236, 192, 88, 67, 134, 176, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 4, 3, 4, 1, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 4, 4, 0, 0, 0, 0, 0, 0, 255, 255, 199, 192, 0, 4, 255, 255, 213, 208, 1, 8, 255, 255, 227, 224, 1, 12, 255, 255, 213, 208, 0, 8, 255, 255, 213, 208, 1, 8, 255, 255, 199, 192, 0, 4, 255, 255, 213, 208, 0, 8, 45, 48, 48, 0, 45, 48, 52, 0, 45, 48, 51, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/Antarctica/Rothera": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 13, 2, 45, 0, 127, 255, 255, 255, 0, 1, 1, 0, 0, 0, 0, 0, 0, 255, 255, 213, 208, 0, 4, 45, 48, 48, 0, 45, 48, 51, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/Antarctica/South_Pole": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, 0, 7, 0, 0, 0, 19, 128, 0, 0, 0, 176, 180, 178, 232, 177, 81, 135, 88, 178, 120, 229, 104, 179, 67, 229, 96, 180, 88, 199, 104, 181, 35, 199, 96, 182, 56, 169, 104, 183, 3, 169, 96, 184, 24, 139, 104, 184, 236, 197, 224, 185, 248, 109, 104, 186, 204, 167, 224, 187, 216, 79, 104, 188, 227, 232, 224, 189, 174, 246, 232, 190, 195, 202, 224, 191, 142, 216, 232, 192, 163, 172, 224, 193, 110, 186, 232, 194, 131, 142, 224, 195, 78, 156, 232, 196, 99, 112, 224, 197, 46, 126, 232, 198, 76, 141, 96, 199, 14, 96, 232, 200, 44, 111, 96, 200, 247, 125, 104, 210, 218, 154, 64, 9, 24, 253, 224, 9, 172, 165, 224, 10, 239, 165, 96, 11, 158, 252, 224, 12, 216, 193, 224, 13, 126, 222, 224, 14, 184, 163, 224, 15, 94, 192, 224, 16, 152, 133, 224, 17, 62, 162, 224, 18, 120, 103, 224, 19, 30, 132, 224, 20, 88, 73, 224, 20, 254, 102, 224, 22, 56, 43, 224, 22, 231, 131, 96, 24, 33, 72, 96, 24, 199, 101, 96, 26, 1, 42, 96, 26, 167, 71, 96, 27, 225, 12, 96, 28, 135, 41, 96, 29, 192, 238, 96, 30, 103, 11, 96, 31, 160, 208, 96, 32, 70, 237, 96, 33, 128, 178, 96, 34, 48, 9, 224, 35, 105, 206, 224, 36, 15, 235, 224, 37, 46, 1, 96, 38, 2, 66, 224, 39, 13, 227, 96, 39, 226, 36, 224, 40, 237, 197, 96, 41, 194, 6, 224, 42, 205, 167, 96, 43, 171, 35, 96, 44, 173, 137, 96, 45, 139, 5, 96, 46, 141, 107, 96, 47, 106, 231, 96, 48, 109, 77, 96, 49, 74, 201, 96, 50, 86, 105, 224, 51, 42, 171, 96, 52, 54, 75, 224, 53, 10, 141, 96, 54, 22, 45, 224, 54, 243, 169, 224, 55, 246, 15, 224, 56, 211, 139, 224, 57, 213, 241, 224, 58, 179, 109, 224, 59, 191, 14, 96, 60, 147, 79, 224, 61, 158, 240, 96, 62, 115, 49, 224, 63, 126, 210, 96, 64, 92, 78, 96, 65, 94, 180, 96, 66, 60, 48, 96, 67, 62, 150, 96, 68, 28, 18, 96, 69, 30, 120, 96, 69, 251, 244, 96, 70, 254, 90, 96, 71, 247, 133, 224, 72, 222, 60, 96, 73, 215, 103, 224, 74, 190, 30, 96, 75, 183, 73, 224, 76, 158, 0, 96, 77, 151, 43, 224, 78, 125, 226, 96, 79, 119, 13, 224, 80, 102, 254, 224, 81, 96, 42, 96, 82, 70, 224, 224, 83, 64, 12, 96, 84, 38, 194, 224, 85, 31, 238, 96, 86, 6, 164, 224, 86, 255, 208, 96, 87, 230, 134, 224, 88, 223, 178, 96, 89, 198, 104, 224, 90, 191, 148, 96, 91, 175, 133, 96, 92, 168, 176, 224, 93, 143, 103, 96, 94, 136, 146, 224, 95, 111, 73, 96, 96, 104, 116, 224, 97, 79, 43, 96, 98, 72, 86, 224, 99, 47, 13, 96, 100, 40, 56, 224, 101, 14, 239, 96, 102, 17, 85, 96, 102, 248, 11, 224, 103, 241, 55, 96, 104, 215, 237, 224, 105, 209, 25, 96, 106, 183, 207, 224, 107, 176, 251, 96, 108, 151, 177, 224, 109, 144, 221, 96, 110, 119, 147, 224, 111, 112, 191, 96, 112, 96, 176, 96, 113, 89, 219, 224, 114, 64, 146, 96, 115, 57, 189, 224, 116, 32, 116, 96, 117, 25, 159, 224, 118, 0, 86, 96, 118, 249, 129, 224, 119, 224, 56, 96, 120, 217, 99, 224, 121, 192, 26, 96, 122, 185, 69, 224, 123, 169, 54, 224, 124, 162, 98, 96, 125, 137, 24, 224, 126, 130, 68, 96, 127, 104, 250, 224, 2, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 6, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 0, 0, 163, 216, 0, 0, 0, 0, 175, 200, 1, 4, 0, 0, 161, 184, 0, 9, 0, 0, 168, 192, 1, 4, 0, 0, 182, 208, 1, 14, 0, 0, 168, 192, 0, 4, 0, 0, 168, 192, 0, 4, 76, 77, 84, 0, 78, 90, 83, 84, 0, 78, 90, 77, 84, 0, 78, 90, 68, 84, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 10, 78, 90, 83, 84, 45, 49, 50, 78, 90, 68, 84, 44, 77, 57, 46, 53, 46, 48, 44, 77, 52, 46, 49, 46, 48, 47, 51, 10}, - - "zoneinfo/Antarctica/Syowa": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 231, 177, 88, 0, 127, 255, 255, 255, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 42, 48, 0, 4, 45, 48, 48, 0, 43, 48, 51, 0, 0, 0, 0, 0, 10, 60, 43, 48, 51, 62, 45, 51, 10}, - - "zoneinfo/Antarctica/Troll": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 69, 0, 0, 0, 4, 0, 0, 0, 12, 128, 0, 0, 0, 66, 13, 71, 0, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 127, 255, 255, 255, 0, 3, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 8, 45, 48, 48, 0, 43, 48, 50, 0, 43, 48, 48, 0, 0, 1, 1, 0, 0, 1, 1, 0, 10, 60, 43, 48, 48, 62, 48, 60, 43, 48, 50, 62, 45, 50, 44, 77, 51, 46, 53, 46, 48, 47, 49, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Antarctica/Vostok": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 233, 88, 137, 128, 127, 255, 255, 255, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 84, 96, 0, 4, 45, 48, 48, 0, 43, 48, 54, 0, 0, 0, 0, 0, 10, 60, 43, 48, 54, 62, 45, 54, 10}, - - "zoneinfo/Arctic/Longyearbyen": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 155, 39, 227, 0, 155, 212, 123, 96, 200, 183, 77, 96, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 209, 114, 22, 16, 210, 98, 7, 16, 235, 175, 32, 144, 236, 168, 76, 16, 237, 152, 61, 16, 238, 136, 46, 16, 239, 120, 31, 16, 240, 104, 16, 16, 241, 88, 1, 16, 242, 71, 242, 16, 243, 55, 227, 16, 244, 39, 212, 16, 245, 23, 197, 16, 246, 16, 240, 144, 247, 47, 6, 16, 247, 240, 210, 144, 18, 206, 151, 240, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 10, 20, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 76, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Asia/Aden": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 213, 27, 54, 180, 127, 255, 255, 255, 0, 1, 1, 0, 0, 43, 204, 0, 0, 0, 0, 42, 48, 0, 4, 76, 77, 84, 0, 43, 48, 51, 0, 0, 0, 0, 0, 10, 60, 43, 48, 51, 62, 45, 51, 10}, - - "zoneinfo/Asia/Almaty": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 53, 0, 0, 0, 10, 0, 0, 0, 16, 128, 0, 0, 0, 170, 25, 123, 220, 181, 163, 239, 48, 21, 39, 125, 160, 22, 24, 178, 16, 23, 8, 177, 32, 23, 249, 229, 144, 24, 233, 228, 160, 25, 219, 25, 16, 26, 204, 105, 160, 27, 188, 118, 192, 28, 172, 103, 192, 29, 156, 88, 192, 30, 140, 73, 192, 31, 124, 58, 192, 32, 108, 43, 192, 33, 92, 28, 192, 34, 76, 13, 192, 35, 59, 254, 192, 36, 43, 239, 192, 37, 27, 224, 192, 38, 11, 209, 192, 39, 4, 253, 64, 39, 244, 238, 64, 40, 228, 237, 80, 41, 120, 149, 80, 41, 212, 208, 64, 42, 196, 193, 64, 43, 180, 178, 64, 44, 164, 163, 64, 45, 148, 148, 64, 46, 132, 133, 64, 47, 116, 118, 64, 48, 100, 103, 64, 49, 93, 146, 192, 50, 114, 109, 192, 51, 61, 116, 192, 52, 82, 79, 192, 53, 29, 86, 192, 54, 50, 49, 192, 54, 253, 56, 192, 56, 27, 78, 64, 56, 221, 26, 192, 57, 251, 48, 64, 58, 188, 252, 192, 59, 219, 18, 64, 60, 166, 25, 64, 61, 186, 244, 64, 62, 133, 251, 64, 63, 154, 214, 64, 64, 101, 221, 64, 65, 131, 242, 192, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 4, 0, 0, 72, 36, 0, 0, 0, 0, 70, 80, 0, 4, 0, 0, 98, 112, 1, 8, 0, 0, 84, 96, 0, 12, 0, 0, 84, 96, 0, 12, 0, 0, 98, 112, 1, 8, 0, 0, 84, 96, 1, 12, 0, 0, 70, 80, 0, 4, 0, 0, 98, 112, 1, 8, 0, 0, 84, 96, 0, 12, 76, 77, 84, 0, 43, 48, 53, 0, 43, 48, 55, 0, 43, 48, 54, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 54, 62, 45, 54, 10}, - - "zoneinfo/Asia/Amman": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 118, 0, 0, 0, 5, 0, 0, 0, 13, 128, 0, 0, 0, 182, 163, 214, 208, 6, 114, 121, 224, 7, 12, 171, 80, 8, 36, 55, 96, 8, 237, 222, 208, 10, 5, 106, 224, 10, 207, 18, 80, 11, 231, 239, 224, 12, 218, 117, 208, 13, 201, 35, 96, 14, 146, 202, 208, 15, 169, 5, 96, 16, 114, 172, 208, 28, 173, 213, 96, 29, 159, 9, 208, 30, 146, 253, 96, 31, 130, 224, 80, 32, 114, 223, 96, 33, 98, 194, 80, 34, 82, 193, 96, 35, 75, 222, 208, 36, 100, 188, 96, 37, 43, 192, 208, 38, 55, 111, 96, 39, 11, 162, 208, 40, 11, 115, 224, 40, 226, 74, 80, 41, 228, 190, 96, 42, 203, 102, 208, 43, 187, 101, 224, 44, 171, 72, 208, 45, 155, 71, 224, 46, 120, 181, 208, 47, 132, 100, 96, 48, 88, 165, 224, 49, 100, 70, 96, 50, 65, 194, 96, 51, 68, 40, 96, 52, 33, 164, 96, 53, 36, 10, 96, 54, 1, 134, 96, 55, 122, 147, 96, 55, 234, 162, 224, 56, 226, 124, 224, 57, 211, 191, 96, 58, 194, 94, 224, 59, 179, 161, 96, 60, 163, 146, 96, 61, 147, 131, 96, 62, 131, 116, 96, 63, 152, 79, 96, 64, 99, 86, 96, 65, 110, 246, 224, 66, 76, 114, 224, 67, 60, 99, 224, 68, 44, 84, 224, 69, 65, 47, 224, 70, 12, 54, 224, 71, 33, 17, 224, 71, 236, 24, 224, 73, 10, 46, 96, 73, 203, 250, 224, 74, 234, 16, 96, 75, 171, 220, 224, 76, 201, 242, 96, 77, 148, 249, 96, 78, 169, 212, 96, 79, 116, 219, 96, 82, 179, 94, 80, 83, 52, 159, 96, 84, 82, 180, 224, 85, 20, 129, 96, 86, 50, 150, 224, 86, 253, 157, 224, 88, 18, 120, 224, 88, 221, 127, 224, 89, 242, 90, 224, 90, 189, 97, 224, 91, 210, 60, 224, 92, 157, 67, 224, 93, 178, 30, 224, 94, 125, 37, 224, 95, 155, 59, 96, 96, 93, 7, 224, 97, 123, 29, 96, 98, 70, 36, 96, 99, 90, 255, 96, 100, 38, 6, 96, 101, 58, 225, 96, 102, 5, 232, 96, 103, 26, 195, 96, 103, 229, 202, 96, 105, 3, 223, 224, 105, 197, 172, 96, 106, 227, 193, 224, 107, 165, 142, 96, 108, 195, 163, 224, 109, 142, 170, 224, 110, 163, 133, 224, 111, 110, 140, 224, 112, 131, 103, 224, 113, 78, 110, 224, 114, 99, 73, 224, 115, 46, 80, 224, 116, 76, 102, 96, 117, 14, 50, 224, 118, 44, 72, 96, 118, 247, 79, 96, 120, 12, 42, 96, 120, 215, 49, 96, 121, 236, 12, 96, 122, 183, 19, 96, 123, 203, 238, 96, 124, 150, 245, 96, 125, 181, 10, 224, 126, 118, 215, 96, 127, 148, 236, 224, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 4, 3, 4, 3, 4, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 0, 0, 33, 176, 0, 0, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 9, 0, 0, 28, 32, 0, 9, 0, 0, 42, 48, 1, 4, 76, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 52, 47, 50, 52, 44, 77, 49, 48, 46, 53, 46, 53, 47, 49, 10}, - - "zoneinfo/Asia/Anadyr": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 66, 0, 0, 0, 10, 0, 0, 0, 20, 128, 0, 0, 0, 170, 25, 29, 156, 181, 163, 140, 192, 21, 39, 27, 48, 22, 24, 79, 160, 23, 8, 78, 176, 23, 249, 145, 48, 24, 233, 144, 64, 25, 218, 196, 176, 26, 204, 21, 64, 27, 188, 34, 96, 28, 172, 19, 96, 29, 156, 4, 96, 30, 139, 245, 96, 31, 123, 230, 96, 32, 107, 215, 96, 33, 91, 200, 96, 34, 75, 185, 96, 35, 59, 170, 96, 36, 43, 155, 96, 37, 27, 140, 96, 38, 11, 125, 96, 39, 4, 168, 224, 39, 244, 153, 224, 40, 228, 152, 240, 41, 120, 64, 240, 41, 212, 123, 224, 42, 196, 108, 224, 43, 180, 93, 224, 44, 164, 78, 224, 45, 148, 63, 224, 46, 132, 48, 224, 47, 116, 33, 224, 48, 100, 18, 224, 49, 93, 62, 96, 50, 114, 25, 96, 51, 61, 32, 96, 52, 81, 251, 96, 53, 29, 2, 96, 54, 49, 221, 96, 54, 252, 228, 96, 56, 26, 249, 224, 56, 220, 198, 96, 57, 250, 219, 224, 58, 188, 168, 96, 59, 218, 189, 224, 60, 165, 196, 224, 61, 186, 159, 224, 62, 133, 166, 224, 63, 154, 129, 224, 64, 101, 136, 224, 65, 131, 158, 96, 66, 69, 106, 224, 67, 99, 128, 96, 68, 37, 76, 224, 69, 67, 98, 96, 70, 5, 46, 224, 71, 35, 68, 96, 71, 238, 75, 96, 73, 3, 38, 96, 73, 206, 45, 96, 74, 227, 8, 96, 75, 174, 15, 96, 76, 204, 50, 240, 77, 141, 255, 112, 127, 255, 255, 255, 0, 1, 3, 2, 3, 4, 1, 4, 1, 4, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 7, 8, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 7, 8, 5, 5, 0, 0, 166, 100, 0, 0, 0, 0, 168, 192, 0, 4, 0, 0, 196, 224, 1, 8, 0, 0, 182, 208, 0, 12, 0, 0, 182, 208, 1, 12, 0, 0, 168, 192, 0, 4, 0, 0, 182, 208, 1, 12, 0, 0, 168, 192, 1, 4, 0, 0, 154, 176, 0, 16, 0, 0, 168, 192, 0, 4, 76, 77, 84, 0, 43, 49, 50, 0, 43, 49, 52, 0, 43, 49, 51, 0, 43, 49, 49, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 50, 62, 45, 49, 50, 10}, - - "zoneinfo/Asia/Aqtau": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 52, 0, 0, 0, 10, 0, 0, 0, 16, 128, 0, 0, 0, 170, 25, 148, 224, 181, 163, 253, 64, 22, 24, 206, 48, 23, 8, 177, 32, 23, 249, 243, 160, 24, 233, 242, 176, 25, 219, 39, 32, 26, 204, 119, 176, 27, 188, 132, 208, 28, 172, 117, 208, 29, 156, 102, 208, 30, 140, 87, 208, 31, 124, 72, 208, 32, 108, 57, 208, 33, 92, 42, 208, 34, 76, 27, 208, 35, 60, 12, 208, 36, 43, 253, 208, 37, 27, 238, 208, 38, 11, 223, 208, 39, 5, 11, 80, 39, 244, 252, 80, 40, 228, 251, 96, 41, 120, 163, 96, 41, 212, 222, 80, 42, 196, 207, 80, 43, 180, 192, 80, 44, 164, 177, 80, 45, 148, 162, 80, 46, 132, 147, 80, 47, 116, 146, 96, 48, 100, 131, 96, 49, 93, 174, 224, 50, 114, 137, 224, 51, 61, 144, 224, 52, 82, 107, 224, 53, 29, 114, 224, 54, 50, 77, 224, 54, 253, 84, 224, 56, 27, 106, 96, 56, 221, 54, 224, 57, 251, 76, 96, 58, 189, 24, 224, 59, 219, 46, 96, 60, 166, 53, 96, 61, 187, 16, 96, 62, 134, 23, 96, 63, 154, 242, 96, 64, 101, 249, 96, 65, 132, 14, 224, 127, 255, 255, 255, 0, 1, 2, 3, 4, 2, 4, 2, 4, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 7, 8, 5, 6, 5, 6, 5, 6, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 5, 5, 0, 0, 47, 32, 0, 0, 0, 0, 56, 64, 0, 4, 0, 0, 70, 80, 0, 8, 0, 0, 84, 96, 0, 12, 0, 0, 84, 96, 1, 12, 0, 0, 70, 80, 0, 8, 0, 0, 84, 96, 1, 12, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 0, 4, 0, 0, 70, 80, 0, 8, 76, 77, 84, 0, 43, 48, 52, 0, 43, 48, 53, 0, 43, 48, 54, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 53, 62, 45, 53, 10}, - - "zoneinfo/Asia/Aqtobe": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 53, 0, 0, 0, 11, 0, 0, 0, 16, 128, 0, 0, 0, 170, 25, 142, 104, 181, 163, 253, 64, 21, 39, 139, 176, 22, 24, 192, 32, 23, 8, 177, 32, 23, 249, 243, 160, 24, 233, 242, 176, 25, 219, 39, 32, 26, 204, 119, 176, 27, 188, 132, 208, 28, 172, 117, 208, 29, 156, 102, 208, 30, 140, 87, 208, 31, 124, 72, 208, 32, 108, 57, 208, 33, 92, 42, 208, 34, 76, 27, 208, 35, 60, 12, 208, 36, 43, 253, 208, 37, 27, 238, 208, 38, 11, 223, 208, 39, 5, 11, 80, 39, 244, 252, 80, 40, 228, 251, 96, 41, 120, 163, 96, 41, 212, 222, 80, 42, 196, 207, 80, 43, 180, 192, 80, 44, 164, 177, 80, 45, 148, 162, 80, 46, 132, 147, 80, 47, 116, 132, 80, 48, 100, 117, 80, 49, 93, 160, 208, 50, 114, 123, 208, 51, 61, 130, 208, 52, 82, 93, 208, 53, 29, 100, 208, 54, 50, 63, 208, 54, 253, 70, 208, 56, 27, 92, 80, 56, 221, 40, 208, 57, 251, 62, 80, 58, 189, 10, 208, 59, 219, 32, 80, 60, 166, 39, 80, 61, 187, 2, 80, 62, 134, 9, 80, 63, 154, 228, 80, 64, 101, 235, 80, 65, 132, 0, 208, 127, 255, 255, 255, 0, 1, 2, 3, 4, 3, 2, 3, 2, 3, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 7, 8, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 5, 0, 0, 53, 152, 0, 0, 0, 0, 56, 64, 0, 4, 0, 0, 70, 80, 0, 8, 0, 0, 84, 96, 1, 12, 0, 0, 84, 96, 0, 12, 0, 0, 70, 80, 0, 8, 0, 0, 84, 96, 1, 12, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 0, 4, 0, 0, 84, 96, 1, 12, 0, 0, 70, 80, 0, 8, 76, 77, 84, 0, 43, 48, 52, 0, 43, 48, 53, 0, 43, 48, 54, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 53, 62, 45, 53, 10}, - - "zoneinfo/Asia/Ashgabat": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 27, 0, 0, 0, 9, 0, 0, 0, 16, 128, 0, 0, 0, 170, 25, 141, 68, 181, 163, 253, 64, 21, 39, 139, 176, 22, 24, 192, 32, 23, 8, 191, 48, 23, 249, 243, 160, 24, 233, 242, 176, 25, 219, 39, 32, 26, 204, 119, 176, 27, 188, 132, 208, 28, 172, 117, 208, 29, 156, 102, 208, 30, 140, 87, 208, 31, 124, 72, 208, 32, 108, 57, 208, 33, 92, 42, 208, 34, 76, 27, 208, 35, 60, 12, 208, 36, 43, 253, 208, 37, 27, 238, 208, 38, 11, 223, 208, 39, 5, 11, 80, 39, 244, 252, 80, 40, 228, 251, 96, 41, 120, 163, 96, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 3, 3, 0, 0, 54, 188, 0, 0, 0, 0, 56, 64, 0, 4, 0, 0, 84, 96, 1, 8, 0, 0, 70, 80, 0, 12, 0, 0, 70, 80, 0, 12, 0, 0, 84, 96, 1, 8, 0, 0, 70, 80, 1, 12, 0, 0, 56, 64, 0, 4, 0, 0, 70, 80, 0, 12, 76, 77, 84, 0, 43, 48, 52, 0, 43, 48, 54, 0, 43, 48, 53, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 53, 62, 45, 53, 10}, - - "zoneinfo/Asia/Ashkhabad": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 27, 0, 0, 0, 9, 0, 0, 0, 16, 128, 0, 0, 0, 170, 25, 141, 68, 181, 163, 253, 64, 21, 39, 139, 176, 22, 24, 192, 32, 23, 8, 191, 48, 23, 249, 243, 160, 24, 233, 242, 176, 25, 219, 39, 32, 26, 204, 119, 176, 27, 188, 132, 208, 28, 172, 117, 208, 29, 156, 102, 208, 30, 140, 87, 208, 31, 124, 72, 208, 32, 108, 57, 208, 33, 92, 42, 208, 34, 76, 27, 208, 35, 60, 12, 208, 36, 43, 253, 208, 37, 27, 238, 208, 38, 11, 223, 208, 39, 5, 11, 80, 39, 244, 252, 80, 40, 228, 251, 96, 41, 120, 163, 96, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 3, 3, 0, 0, 54, 188, 0, 0, 0, 0, 56, 64, 0, 4, 0, 0, 84, 96, 1, 8, 0, 0, 70, 80, 0, 12, 0, 0, 70, 80, 0, 12, 0, 0, 84, 96, 1, 8, 0, 0, 70, 80, 1, 12, 0, 0, 56, 64, 0, 4, 0, 0, 70, 80, 0, 12, 76, 77, 84, 0, 43, 48, 52, 0, 43, 48, 54, 0, 43, 48, 53, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 53, 62, 45, 53, 10}, - - "zoneinfo/Asia/Atyrau": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 52, 0, 0, 0, 10, 0, 0, 0, 20, 128, 0, 0, 0, 170, 25, 147, 80, 181, 164, 11, 80, 22, 24, 206, 48, 23, 8, 177, 32, 23, 249, 243, 160, 24, 233, 242, 176, 25, 219, 39, 32, 26, 204, 119, 176, 27, 188, 132, 208, 28, 172, 117, 208, 29, 156, 102, 208, 30, 140, 87, 208, 31, 124, 72, 208, 32, 108, 57, 208, 33, 92, 42, 208, 34, 76, 27, 208, 35, 60, 12, 208, 36, 43, 253, 208, 37, 27, 238, 208, 38, 11, 223, 208, 39, 5, 11, 80, 39, 244, 252, 80, 40, 228, 251, 96, 41, 120, 163, 96, 41, 212, 222, 80, 42, 196, 207, 80, 43, 180, 192, 80, 44, 164, 177, 80, 45, 148, 162, 80, 46, 132, 147, 80, 47, 116, 132, 80, 48, 100, 117, 80, 49, 93, 160, 208, 50, 114, 123, 208, 51, 61, 130, 208, 52, 82, 93, 208, 53, 29, 100, 208, 54, 50, 63, 208, 54, 253, 70, 208, 56, 27, 106, 96, 56, 221, 54, 224, 57, 251, 76, 96, 58, 189, 24, 224, 59, 219, 46, 96, 60, 166, 53, 96, 61, 187, 16, 96, 62, 134, 23, 96, 63, 154, 242, 96, 64, 101, 249, 96, 65, 132, 14, 224, 127, 255, 255, 255, 0, 1, 2, 3, 4, 2, 4, 2, 4, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 7, 8, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 5, 5, 0, 0, 48, 176, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 70, 80, 0, 8, 0, 0, 84, 96, 0, 12, 0, 0, 84, 96, 1, 12, 0, 0, 70, 80, 0, 8, 0, 0, 84, 96, 1, 12, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 0, 16, 0, 0, 70, 80, 0, 8, 76, 77, 84, 0, 43, 48, 51, 0, 43, 48, 53, 0, 43, 48, 54, 0, 43, 48, 52, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 53, 62, 45, 53, 10}, - - "zoneinfo/Asia/Baghdad": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 55, 0, 0, 0, 6, 0, 0, 0, 16, 128, 0, 0, 0, 158, 48, 60, 224, 23, 48, 104, 80, 23, 250, 15, 192, 24, 232, 189, 80, 25, 219, 67, 64, 26, 204, 147, 208, 27, 189, 200, 64, 28, 173, 199, 80, 29, 156, 116, 224, 30, 140, 101, 224, 31, 124, 86, 224, 32, 108, 71, 224, 33, 92, 56, 224, 34, 76, 41, 224, 35, 60, 26, 224, 36, 44, 11, 224, 37, 27, 252, 224, 38, 11, 237, 224, 39, 5, 25, 96, 39, 246, 120, 0, 40, 231, 186, 128, 41, 216, 253, 0, 42, 202, 63, 128, 43, 186, 48, 128, 44, 171, 115, 0, 45, 155, 100, 0, 46, 140, 166, 128, 47, 124, 151, 128, 48, 109, 218, 0, 49, 95, 28, 128, 50, 80, 95, 0, 51, 64, 80, 0, 52, 49, 146, 128, 53, 33, 131, 128, 54, 18, 198, 0, 55, 2, 183, 0, 55, 243, 249, 128, 56, 229, 60, 0, 57, 214, 126, 128, 58, 198, 111, 128, 59, 183, 178, 0, 60, 167, 163, 0, 61, 152, 229, 128, 62, 136, 214, 128, 63, 122, 25, 0, 64, 107, 91, 128, 65, 92, 158, 0, 66, 76, 143, 0, 67, 61, 209, 128, 68, 45, 194, 128, 69, 31, 5, 0, 70, 14, 246, 0, 71, 0, 56, 128, 127, 255, 255, 255, 1, 2, 3, 2, 3, 2, 3, 2, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 4, 0, 0, 41, 164, 0, 0, 0, 0, 41, 160, 0, 4, 0, 0, 42, 48, 0, 8, 0, 0, 56, 64, 1, 12, 0, 0, 42, 48, 0, 8, 0, 0, 56, 64, 1, 12, 76, 77, 84, 0, 66, 77, 84, 0, 43, 48, 51, 0, 43, 48, 52, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 51, 62, 45, 51, 10}, - - "zoneinfo/Asia/Bahrain": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 161, 242, 157, 48, 4, 138, 146, 192, 127, 255, 255, 255, 0, 1, 2, 2, 0, 0, 48, 80, 0, 0, 0, 0, 56, 64, 0, 4, 0, 0, 42, 48, 0, 8, 76, 77, 84, 0, 43, 48, 52, 0, 43, 48, 51, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 51, 62, 45, 51, 10}, - - "zoneinfo/Asia/Baku": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 70, 0, 0, 0, 10, 0, 0, 0, 16, 128, 0, 0, 0, 170, 25, 149, 68, 231, 218, 12, 80, 21, 39, 153, 192, 22, 24, 206, 48, 23, 8, 205, 64, 23, 250, 1, 176, 24, 234, 0, 192, 25, 219, 53, 48, 26, 204, 133, 192, 27, 188, 146, 224, 28, 172, 131, 224, 29, 156, 116, 224, 30, 140, 101, 224, 31, 124, 86, 224, 32, 108, 71, 224, 33, 92, 56, 224, 34, 76, 41, 224, 35, 60, 26, 224, 36, 44, 11, 224, 37, 27, 252, 224, 38, 11, 237, 224, 39, 5, 25, 96, 39, 245, 10, 96, 40, 229, 9, 112, 41, 212, 250, 112, 42, 196, 235, 112, 48, 230, 235, 192, 49, 93, 217, 16, 50, 114, 180, 16, 50, 201, 112, 192, 51, 61, 173, 0, 52, 82, 136, 0, 53, 29, 143, 0, 54, 50, 106, 0, 54, 253, 113, 0, 56, 27, 134, 128, 56, 221, 83, 0, 57, 251, 104, 128, 58, 189, 53, 0, 59, 219, 74, 128, 60, 166, 81, 128, 61, 187, 44, 128, 62, 134, 51, 128, 63, 155, 14, 128, 64, 102, 21, 128, 65, 132, 43, 0, 66, 69, 247, 128, 67, 100, 13, 0, 68, 37, 217, 128, 69, 67, 239, 0, 70, 5, 187, 128, 71, 35, 209, 0, 71, 238, 216, 0, 73, 3, 179, 0, 73, 206, 186, 0, 74, 227, 149, 0, 75, 174, 156, 0, 76, 204, 177, 128, 77, 142, 126, 0, 78, 172, 147, 128, 79, 110, 96, 0, 80, 140, 117, 128, 81, 87, 124, 128, 82, 108, 87, 128, 83, 55, 94, 128, 84, 76, 57, 128, 85, 23, 64, 128, 86, 44, 27, 128, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 6, 4, 3, 8, 9, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 3, 0, 0, 46, 188, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 0, 12, 0, 0, 56, 64, 0, 12, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 1, 12, 0, 0, 42, 48, 0, 4, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 0, 12, 76, 77, 84, 0, 43, 48, 51, 0, 43, 48, 53, 0, 43, 48, 52, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 60, 43, 48, 52, 62, 45, 52, 10}, - - "zoneinfo/Asia/Bangkok": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 162, 106, 103, 196, 127, 255, 255, 255, 1, 2, 2, 0, 0, 94, 60, 0, 0, 0, 0, 94, 60, 0, 4, 0, 0, 98, 112, 0, 8, 76, 77, 84, 0, 66, 77, 84, 0, 43, 48, 55, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 55, 62, 45, 55, 10}, - - "zoneinfo/Asia/Barnaul": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 69, 0, 0, 0, 10, 0, 0, 0, 16, 128, 0, 0, 0, 161, 213, 125, 252, 181, 163, 225, 32, 21, 39, 111, 144, 22, 24, 164, 0, 23, 8, 163, 16, 23, 249, 215, 128, 24, 233, 214, 144, 25, 219, 11, 0, 26, 204, 91, 144, 27, 188, 104, 176, 28, 172, 89, 176, 29, 156, 74, 176, 30, 140, 59, 176, 31, 124, 44, 176, 32, 108, 29, 176, 33, 92, 14, 176, 34, 75, 255, 176, 35, 59, 240, 176, 36, 43, 225, 176, 37, 27, 210, 176, 38, 11, 195, 176, 39, 4, 239, 48, 39, 244, 224, 48, 40, 228, 223, 64, 41, 120, 135, 64, 41, 212, 194, 48, 42, 196, 179, 48, 43, 180, 164, 48, 44, 164, 149, 48, 45, 148, 134, 48, 46, 132, 119, 48, 47, 116, 104, 48, 47, 199, 76, 128, 48, 100, 103, 64, 49, 93, 146, 192, 50, 114, 109, 192, 51, 61, 116, 192, 52, 82, 79, 192, 53, 29, 86, 192, 54, 50, 49, 192, 54, 253, 56, 192, 56, 27, 78, 64, 56, 221, 26, 192, 57, 251, 48, 64, 58, 188, 252, 192, 59, 219, 18, 64, 60, 166, 25, 64, 61, 186, 244, 64, 62, 133, 251, 64, 63, 154, 214, 64, 64, 101, 221, 64, 65, 131, 242, 192, 66, 69, 191, 64, 67, 99, 212, 192, 68, 37, 161, 64, 69, 67, 182, 192, 70, 5, 131, 64, 71, 35, 152, 192, 71, 238, 159, 192, 73, 3, 122, 192, 73, 206, 129, 192, 74, 227, 92, 192, 75, 174, 99, 192, 76, 204, 121, 64, 77, 142, 69, 192, 84, 75, 243, 48, 86, 246, 234, 64, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 5, 4, 5, 4, 5, 4, 5, 8, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 4, 7, 4, 4, 0, 0, 78, 132, 0, 0, 0, 0, 84, 96, 0, 4, 0, 0, 112, 128, 1, 8, 0, 0, 98, 112, 0, 12, 0, 0, 98, 112, 0, 12, 0, 0, 112, 128, 1, 8, 0, 0, 98, 112, 1, 12, 0, 0, 84, 96, 0, 4, 0, 0, 98, 112, 1, 12, 0, 0, 98, 112, 0, 12, 76, 77, 84, 0, 43, 48, 54, 0, 43, 48, 56, 0, 43, 48, 55, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 55, 62, 45, 55, 10}, - - "zoneinfo/Asia/Beirut": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 141, 0, 0, 0, 3, 0, 0, 0, 13, 128, 0, 0, 0, 162, 101, 99, 224, 163, 123, 130, 80, 164, 78, 128, 96, 165, 63, 180, 208, 166, 37, 39, 224, 167, 39, 127, 208, 168, 41, 243, 224, 168, 235, 178, 80, 232, 42, 133, 224, 232, 244, 45, 80, 234, 11, 185, 96, 234, 213, 96, 208, 235, 236, 236, 224, 236, 182, 148, 80, 237, 207, 113, 224, 238, 153, 25, 80, 239, 176, 165, 96, 240, 122, 76, 208, 4, 166, 94, 96, 5, 43, 119, 208, 6, 67, 3, 224, 7, 12, 171, 80, 8, 36, 55, 96, 8, 237, 222, 208, 10, 5, 106, 224, 10, 207, 18, 80, 11, 231, 239, 224, 12, 177, 151, 80, 13, 201, 35, 96, 14, 146, 202, 208, 15, 169, 5, 96, 16, 114, 172, 208, 26, 244, 46, 224, 27, 209, 156, 208, 28, 213, 98, 96, 29, 178, 208, 80, 30, 182, 149, 224, 31, 148, 3, 208, 32, 151, 201, 96, 33, 117, 55, 80, 34, 163, 44, 224, 35, 87, 188, 80, 36, 103, 95, 96, 37, 56, 239, 208, 38, 60, 181, 96, 39, 26, 35, 80, 40, 29, 232, 224, 40, 251, 86, 208, 42, 0, 109, 224, 42, 206, 9, 208, 43, 180, 206, 96, 44, 164, 177, 80, 45, 148, 176, 96, 46, 132, 147, 80, 47, 116, 146, 96, 48, 100, 117, 80, 49, 93, 174, 224, 50, 77, 145, 208, 51, 61, 144, 224, 52, 45, 115, 208, 53, 29, 114, 224, 54, 13, 85, 208, 54, 253, 84, 224, 56, 27, 92, 80, 56, 221, 54, 224, 57, 251, 62, 80, 58, 189, 24, 224, 59, 219, 32, 80, 60, 166, 53, 96, 61, 187, 2, 80, 62, 134, 23, 96, 63, 154, 228, 80, 64, 101, 249, 96, 65, 132, 0, 208, 66, 69, 219, 96, 67, 99, 226, 208, 68, 37, 189, 96, 69, 67, 196, 208, 70, 5, 159, 96, 71, 35, 166, 208, 71, 238, 187, 224, 73, 3, 136, 208, 73, 206, 157, 224, 74, 227, 106, 208, 75, 174, 127, 224, 76, 204, 135, 80, 77, 142, 97, 224, 78, 172, 105, 80, 79, 110, 67, 224, 80, 140, 75, 80, 81, 87, 96, 96, 82, 108, 45, 80, 83, 55, 66, 96, 84, 76, 15, 80, 85, 23, 36, 96, 86, 43, 241, 80, 86, 247, 6, 96, 88, 21, 13, 208, 88, 214, 232, 96, 89, 244, 239, 208, 90, 182, 202, 96, 91, 212, 209, 208, 92, 159, 230, 224, 93, 180, 179, 208, 94, 127, 200, 224, 95, 148, 149, 208, 96, 95, 170, 224, 97, 125, 178, 80, 98, 63, 140, 224, 99, 93, 148, 80, 100, 31, 110, 224, 101, 61, 118, 80, 102, 8, 139, 96, 103, 29, 88, 80, 103, 232, 109, 96, 104, 253, 58, 80, 105, 200, 79, 96, 106, 221, 28, 80, 107, 168, 49, 96, 108, 198, 56, 208, 109, 136, 19, 96, 110, 166, 26, 208, 111, 103, 245, 96, 112, 133, 252, 208, 113, 81, 17, 224, 114, 101, 222, 208, 115, 48, 243, 224, 116, 69, 192, 208, 117, 16, 213, 224, 118, 46, 221, 80, 118, 240, 183, 224, 120, 14, 191, 80, 120, 208, 153, 224, 121, 238, 161, 80, 122, 176, 123, 224, 123, 206, 131, 80, 124, 153, 152, 96, 125, 174, 101, 80, 126, 121, 122, 96, 127, 142, 71, 80, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 33, 72, 0, 0, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 9, 76, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 0, 0, 0, 0, 0, 0, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 48, 10}, - - "zoneinfo/Asia/Bishkek": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 0, 10, 0, 0, 0, 16, 128, 0, 0, 0, 170, 25, 126, 16, 181, 163, 239, 48, 21, 39, 125, 160, 22, 24, 178, 16, 23, 8, 177, 32, 23, 249, 229, 144, 24, 233, 228, 160, 25, 219, 25, 16, 26, 204, 105, 160, 27, 188, 118, 192, 28, 172, 103, 192, 29, 156, 88, 192, 30, 140, 73, 192, 31, 124, 58, 192, 32, 108, 43, 192, 33, 92, 28, 192, 34, 76, 13, 192, 35, 59, 254, 192, 36, 43, 239, 192, 37, 27, 224, 192, 38, 11, 209, 192, 39, 4, 253, 64, 39, 244, 238, 64, 40, 190, 163, 192, 41, 231, 55, 48, 42, 196, 165, 32, 43, 199, 25, 48, 44, 164, 135, 32, 45, 166, 251, 48, 46, 132, 105, 32, 47, 134, 221, 48, 48, 100, 75, 32, 49, 102, 191, 48, 50, 77, 103, 160, 51, 61, 137, 216, 52, 82, 86, 200, 53, 29, 107, 216, 54, 50, 56, 200, 54, 253, 77, 216, 56, 27, 85, 72, 56, 221, 47, 216, 57, 251, 55, 72, 58, 189, 17, 216, 59, 219, 25, 72, 60, 166, 46, 88, 61, 186, 251, 72, 62, 134, 16, 88, 63, 154, 221, 72, 64, 101, 242, 88, 65, 131, 249, 200, 66, 69, 212, 88, 66, 251, 146, 32, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 6, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 1, 8, 3, 3, 0, 0, 69, 240, 0, 0, 0, 0, 70, 80, 0, 4, 0, 0, 98, 112, 1, 8, 0, 0, 84, 96, 0, 12, 0, 0, 84, 96, 0, 12, 0, 0, 98, 112, 1, 8, 0, 0, 84, 96, 1, 12, 0, 0, 70, 80, 0, 4, 0, 0, 84, 96, 1, 12, 0, 0, 84, 96, 0, 12, 76, 77, 84, 0, 43, 48, 53, 0, 43, 48, 55, 0, 43, 48, 54, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 54, 62, 45, 54, 10}, - - "zoneinfo/Asia/Brunei": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 3, 0, 0, 0, 14, 128, 0, 0, 0, 173, 138, 2, 68, 186, 103, 71, 136, 127, 255, 255, 255, 0, 1, 2, 2, 0, 0, 107, 188, 0, 0, 0, 0, 105, 120, 0, 4, 0, 0, 112, 128, 0, 10, 76, 77, 84, 0, 43, 48, 55, 51, 48, 0, 43, 48, 56, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 56, 62, 45, 56, 10}, - - "zoneinfo/Asia/Calcutta": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 18, 128, 0, 0, 0, 135, 157, 188, 186, 202, 219, 140, 40, 204, 5, 113, 24, 204, 149, 50, 168, 210, 116, 18, 152, 1, 2, 3, 2, 3, 2, 0, 0, 82, 208, 0, 0, 0, 0, 75, 70, 0, 4, 0, 0, 77, 88, 0, 8, 0, 0, 91, 104, 1, 12, 72, 77, 84, 0, 77, 77, 84, 0, 73, 83, 84, 0, 43, 48, 54, 51, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 73, 83, 84, 45, 53, 58, 51, 48, 10}, - - "zoneinfo/Asia/Chita": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 11, 0, 0, 0, 16, 128, 0, 0, 0, 161, 219, 249, 160, 181, 163, 197, 0, 21, 39, 83, 112, 22, 24, 135, 224, 23, 8, 134, 240, 23, 249, 187, 96, 24, 233, 186, 112, 25, 218, 238, 224, 26, 204, 63, 112, 27, 188, 76, 144, 28, 172, 61, 144, 29, 156, 46, 144, 30, 140, 31, 144, 31, 124, 16, 144, 32, 108, 1, 144, 33, 91, 242, 144, 34, 75, 227, 144, 35, 59, 212, 144, 36, 43, 197, 144, 37, 27, 182, 144, 38, 11, 167, 144, 39, 4, 211, 16, 39, 244, 196, 16, 40, 228, 195, 32, 41, 120, 107, 32, 41, 212, 166, 16, 42, 196, 151, 16, 43, 180, 136, 16, 44, 164, 121, 16, 45, 148, 106, 16, 46, 132, 91, 16, 47, 116, 76, 16, 48, 100, 61, 16, 49, 93, 104, 144, 50, 114, 67, 144, 51, 61, 74, 144, 52, 82, 37, 144, 53, 29, 44, 144, 54, 50, 7, 144, 54, 253, 14, 144, 56, 27, 36, 16, 56, 220, 240, 144, 57, 251, 6, 16, 58, 188, 210, 144, 59, 218, 232, 16, 60, 165, 239, 16, 61, 186, 202, 16, 62, 133, 209, 16, 63, 154, 172, 16, 64, 101, 179, 16, 65, 131, 200, 144, 66, 69, 149, 16, 67, 99, 170, 144, 68, 37, 119, 16, 69, 67, 140, 144, 70, 5, 89, 16, 71, 35, 110, 144, 71, 238, 117, 144, 73, 3, 80, 144, 73, 206, 87, 144, 74, 227, 50, 144, 75, 174, 57, 144, 76, 204, 79, 16, 77, 142, 27, 144, 84, 75, 201, 0, 86, 246, 206, 32, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 8, 7, 3, 3, 0, 0, 106, 96, 0, 0, 0, 0, 112, 128, 0, 4, 0, 0, 140, 160, 1, 8, 0, 0, 126, 144, 0, 12, 0, 0, 126, 144, 0, 12, 0, 0, 140, 160, 1, 8, 0, 0, 126, 144, 1, 12, 0, 0, 112, 128, 0, 4, 0, 0, 140, 160, 0, 8, 0, 0, 140, 160, 1, 8, 0, 0, 126, 144, 0, 12, 76, 77, 84, 0, 43, 48, 56, 0, 43, 49, 48, 0, 43, 48, 57, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 57, 62, 45, 57, 10}, - - "zoneinfo/Asia/Choibalsan": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 53, 0, 0, 0, 7, 0, 0, 0, 20, 128, 0, 0, 0, 134, 211, 231, 40, 15, 11, 220, 144, 24, 233, 200, 128, 25, 218, 238, 224, 26, 204, 63, 112, 27, 188, 34, 96, 28, 172, 33, 112, 29, 156, 4, 96, 30, 140, 3, 112, 31, 123, 230, 96, 32, 107, 229, 112, 33, 91, 200, 96, 34, 75, 199, 112, 35, 59, 170, 96, 36, 43, 169, 112, 37, 27, 140, 96, 38, 11, 139, 112, 39, 4, 168, 224, 39, 244, 167, 240, 40, 228, 138, 224, 41, 212, 137, 240, 42, 196, 108, 224, 43, 180, 107, 240, 44, 164, 78, 224, 45, 148, 77, 240, 46, 132, 48, 224, 47, 116, 47, 240, 48, 100, 18, 224, 49, 93, 76, 112, 50, 77, 47, 96, 51, 61, 46, 112, 52, 45, 17, 96, 53, 29, 16, 112, 54, 12, 243, 96, 58, 233, 165, 144, 59, 180, 158, 128, 60, 164, 157, 144, 61, 148, 128, 128, 62, 132, 127, 144, 63, 116, 98, 128, 64, 100, 97, 144, 65, 84, 68, 128, 66, 68, 67, 144, 67, 52, 38, 128, 68, 36, 37, 144, 69, 29, 67, 0, 71, 239, 170, 240, 85, 21, 154, 160, 86, 5, 97, 112, 86, 245, 124, 160, 87, 229, 67, 112, 127, 255, 255, 255, 0, 1, 2, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 2, 5, 2, 5, 2, 2, 0, 0, 107, 88, 0, 0, 0, 0, 98, 112, 0, 4, 0, 0, 112, 128, 0, 8, 0, 0, 126, 144, 0, 12, 0, 0, 140, 160, 1, 16, 0, 0, 126, 144, 1, 12, 0, 0, 112, 128, 0, 8, 76, 77, 84, 0, 43, 48, 55, 0, 43, 48, 56, 0, 43, 48, 57, 0, 43, 49, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 56, 62, 45, 56, 10}, - - "zoneinfo/Asia/Chongqing": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 200, 92, 1, 128, 200, 250, 39, 112, 201, 213, 14, 128, 202, 219, 90, 240, 30, 186, 54, 0, 31, 105, 127, 112, 32, 126, 104, 128, 33, 73, 97, 112, 34, 94, 74, 128, 35, 41, 67, 112, 36, 71, 103, 0, 37, 18, 95, 240, 38, 39, 73, 0, 38, 242, 65, 240, 40, 7, 43, 0, 40, 210, 35, 240, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 113, 215, 0, 0, 0, 0, 126, 144, 1, 4, 0, 0, 112, 128, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 45, 56, 10}, - - "zoneinfo/Asia/Chungking": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 200, 92, 1, 128, 200, 250, 39, 112, 201, 213, 14, 128, 202, 219, 90, 240, 30, 186, 54, 0, 31, 105, 127, 112, 32, 126, 104, 128, 33, 73, 97, 112, 34, 94, 74, 128, 35, 41, 67, 112, 36, 71, 103, 0, 37, 18, 95, 240, 38, 39, 73, 0, 38, 242, 65, 240, 40, 7, 43, 0, 40, 210, 35, 240, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 113, 215, 0, 0, 0, 0, 126, 144, 1, 4, 0, 0, 112, 128, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 45, 56, 10}, - - "zoneinfo/Asia/Colombo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 8, 0, 0, 0, 24, 128, 0, 0, 0, 135, 157, 189, 28, 203, 90, 28, 40, 204, 149, 43, 160, 210, 117, 128, 56, 49, 166, 0, 40, 50, 113, 0, 32, 68, 63, 234, 40, 127, 255, 255, 255, 1, 2, 3, 4, 2, 5, 6, 2, 2, 0, 0, 74, 220, 0, 0, 0, 0, 74, 228, 0, 4, 0, 0, 77, 88, 0, 8, 0, 0, 84, 96, 1, 14, 0, 0, 91, 104, 1, 18, 0, 0, 91, 104, 0, 18, 0, 0, 84, 96, 0, 14, 0, 0, 77, 88, 0, 8, 76, 77, 84, 0, 77, 77, 84, 0, 43, 48, 53, 51, 48, 0, 43, 48, 54, 0, 43, 48, 54, 51, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 53, 51, 48, 62, 45, 53, 58, 51, 48, 10}, - - "zoneinfo/Asia/Dacca": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 6, 0, 0, 0, 28, 128, 0, 0, 0, 202, 219, 134, 176, 204, 5, 113, 24, 204, 149, 50, 168, 221, 168, 210, 152, 74, 59, 196, 16, 75, 60, 216, 144, 127, 255, 255, 255, 1, 2, 3, 2, 4, 5, 4, 4, 0, 0, 84, 196, 0, 0, 0, 0, 82, 208, 0, 4, 0, 0, 91, 104, 0, 8, 0, 0, 77, 88, 0, 14, 0, 0, 84, 96, 0, 20, 0, 0, 98, 112, 1, 24, 76, 77, 84, 0, 72, 77, 84, 0, 43, 48, 54, 51, 48, 0, 43, 48, 53, 51, 48, 0, 43, 48, 54, 0, 43, 48, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 54, 62, 45, 54, 10}, - - "zoneinfo/Asia/Damascus": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 152, 0, 0, 0, 3, 0, 0, 0, 13, 128, 0, 0, 0, 161, 242, 171, 120, 162, 129, 47, 128, 163, 94, 157, 112, 164, 97, 17, 128, 165, 62, 127, 112, 166, 64, 243, 128, 167, 30, 97, 112, 168, 32, 213, 128, 169, 7, 125, 240, 241, 143, 82, 0, 242, 91, 156, 112, 243, 115, 40, 128, 244, 59, 126, 112, 245, 85, 173, 128, 246, 31, 84, 240, 247, 54, 225, 0, 247, 255, 54, 240, 249, 14, 218, 0, 249, 225, 187, 240, 250, 249, 72, 0, 251, 194, 239, 112, 252, 219, 205, 0, 253, 165, 116, 112, 254, 189, 0, 128, 255, 134, 167, 240, 0, 158, 52, 0, 1, 103, 219, 112, 2, 127, 103, 128, 3, 73, 14, 240, 4, 97, 236, 128, 5, 43, 147, 240, 6, 67, 32, 0, 7, 12, 199, 112, 8, 36, 83, 128, 8, 237, 250, 240, 10, 5, 135, 0, 10, 207, 46, 112, 11, 232, 12, 0, 12, 177, 179, 112, 13, 201, 63, 128, 14, 107, 89, 240, 15, 170, 115, 0, 16, 76, 141, 112, 24, 244, 197, 0, 25, 219, 109, 112, 26, 215, 74, 0, 27, 189, 242, 112, 30, 85, 35, 0, 31, 138, 229, 112, 32, 71, 122, 0, 33, 137, 25, 240, 34, 60, 116, 0, 35, 107, 158, 240, 36, 50, 191, 128, 37, 37, 69, 112, 38, 21, 68, 128, 39, 5, 39, 112, 39, 246, 91, 224, 40, 231, 144, 80, 41, 226, 27, 96, 42, 202, 21, 80, 43, 178, 43, 96, 44, 163, 95, 208, 45, 155, 71, 224, 46, 140, 124, 80, 47, 124, 123, 96, 48, 109, 175, 208, 49, 95, 0, 96, 50, 80, 52, 208, 51, 62, 226, 96, 52, 49, 104, 80, 53, 30, 196, 96, 54, 18, 155, 208, 55, 2, 154, 224, 55, 243, 207, 80, 56, 229, 31, 224, 57, 214, 84, 80, 58, 198, 83, 96, 59, 183, 135, 208, 60, 167, 134, 224, 61, 152, 187, 80, 62, 136, 186, 96, 63, 121, 238, 208, 64, 107, 63, 96, 65, 92, 115, 208, 66, 76, 114, 224, 67, 61, 167, 80, 68, 45, 166, 96, 69, 18, 253, 80, 70, 12, 54, 224, 71, 42, 62, 80, 71, 245, 83, 96, 73, 11, 113, 208, 73, 203, 250, 224, 74, 234, 2, 80, 75, 181, 23, 96, 76, 201, 228, 80, 77, 148, 249, 96, 78, 169, 198, 80, 79, 116, 219, 96, 80, 137, 168, 80, 81, 84, 189, 96, 82, 105, 138, 80, 83, 52, 159, 96, 84, 82, 166, 208, 85, 20, 129, 96, 86, 50, 136, 208, 86, 244, 99, 96, 88, 18, 106, 208, 88, 221, 127, 224, 89, 242, 76, 208, 90, 189, 97, 224, 91, 210, 46, 208, 92, 157, 67, 224, 93, 178, 16, 208, 94, 125, 37, 224, 95, 155, 45, 80, 96, 93, 7, 224, 97, 123, 15, 80, 98, 60, 233, 224, 99, 90, 241, 80, 100, 38, 6, 96, 101, 58, 211, 80, 102, 5, 232, 96, 103, 26, 181, 80, 103, 229, 202, 96, 105, 3, 209, 208, 105, 197, 172, 96, 106, 227, 179, 208, 107, 165, 142, 96, 108, 195, 149, 208, 109, 142, 170, 224, 110, 163, 119, 208, 111, 110, 140, 224, 112, 131, 89, 208, 113, 78, 110, 224, 114, 99, 59, 208, 115, 46, 80, 224, 116, 76, 88, 80, 117, 14, 50, 224, 118, 44, 58, 80, 118, 238, 20, 224, 120, 12, 28, 80, 120, 215, 49, 96, 121, 235, 254, 80, 122, 183, 19, 96, 123, 203, 224, 80, 124, 150, 245, 96, 125, 180, 252, 208, 126, 118, 215, 96, 127, 148, 222, 208, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 34, 8, 0, 0, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 9, 76, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 0, 0, 0, 0, 0, 0, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 53, 47, 48, 44, 77, 49, 48, 46, 53, 46, 53, 47, 48, 10}, - - "zoneinfo/Asia/Dhaka": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 6, 0, 0, 0, 28, 128, 0, 0, 0, 202, 219, 134, 176, 204, 5, 113, 24, 204, 149, 50, 168, 221, 168, 210, 152, 74, 59, 196, 16, 75, 60, 216, 144, 127, 255, 255, 255, 1, 2, 3, 2, 4, 5, 4, 4, 0, 0, 84, 196, 0, 0, 0, 0, 82, 208, 0, 4, 0, 0, 91, 104, 0, 8, 0, 0, 77, 88, 0, 14, 0, 0, 84, 96, 0, 20, 0, 0, 98, 112, 1, 24, 76, 77, 84, 0, 72, 77, 84, 0, 43, 48, 54, 51, 48, 0, 43, 48, 53, 51, 48, 0, 43, 48, 54, 0, 43, 48, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 54, 62, 45, 54, 10}, - - "zoneinfo/Asia/Dili": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 146, 230, 24, 196, 203, 153, 50, 240, 11, 234, 48, 112, 57, 195, 153, 0, 127, 255, 255, 255, 0, 1, 2, 1, 2, 2, 0, 0, 117, 188, 0, 0, 0, 0, 112, 128, 0, 4, 0, 0, 126, 144, 0, 8, 76, 77, 84, 0, 43, 48, 56, 0, 43, 48, 57, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 57, 62, 45, 57, 10}, - - "zoneinfo/Asia/Dubai": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 161, 242, 153, 168, 127, 255, 255, 255, 0, 1, 1, 0, 0, 51, 216, 0, 0, 0, 0, 56, 64, 0, 4, 76, 77, 84, 0, 43, 48, 52, 0, 0, 0, 0, 0, 10, 60, 43, 48, 52, 62, 45, 52, 10}, - - "zoneinfo/Asia/Dushanbe": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 26, 0, 0, 0, 8, 0, 0, 0, 16, 128, 0, 0, 0, 170, 25, 131, 128, 181, 163, 239, 48, 21, 39, 125, 160, 22, 24, 178, 16, 23, 8, 177, 32, 23, 249, 229, 144, 24, 233, 228, 160, 25, 219, 25, 16, 26, 204, 105, 160, 27, 188, 118, 192, 28, 172, 103, 192, 29, 156, 88, 192, 30, 140, 73, 192, 31, 124, 58, 192, 32, 108, 43, 192, 33, 92, 28, 192, 34, 76, 13, 192, 35, 59, 254, 192, 36, 43, 239, 192, 37, 27, 224, 192, 38, 11, 209, 192, 39, 4, 253, 64, 39, 244, 238, 64, 40, 202, 143, 80, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 7, 0, 0, 64, 128, 0, 0, 0, 0, 70, 80, 0, 4, 0, 0, 98, 112, 1, 8, 0, 0, 84, 96, 0, 12, 0, 0, 84, 96, 0, 12, 0, 0, 98, 112, 1, 8, 0, 0, 84, 96, 1, 12, 0, 0, 70, 80, 0, 4, 76, 77, 84, 0, 43, 48, 53, 0, 43, 48, 55, 0, 43, 48, 54, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 53, 62, 45, 53, 10}, - - "zoneinfo/Asia/Famagusta": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 127, 0, 0, 0, 7, 0, 0, 0, 17, 128, 0, 0, 0, 165, 119, 30, 44, 9, 237, 175, 224, 10, 221, 146, 208, 11, 250, 100, 224, 12, 190, 198, 80, 13, 164, 57, 96, 14, 138, 225, 208, 15, 132, 27, 96, 16, 117, 79, 208, 17, 99, 253, 96, 18, 83, 224, 80, 19, 77, 25, 224, 20, 51, 194, 80, 21, 35, 193, 96, 22, 19, 164, 80, 23, 3, 163, 96, 23, 243, 134, 80, 24, 227, 133, 96, 25, 211, 104, 80, 26, 195, 103, 96, 27, 188, 132, 208, 28, 172, 131, 224, 29, 156, 102, 208, 30, 140, 101, 224, 31, 124, 72, 208, 32, 108, 71, 224, 33, 92, 42, 208, 34, 76, 41, 224, 35, 60, 12, 208, 36, 44, 11, 224, 37, 27, 238, 208, 38, 11, 237, 224, 39, 5, 11, 80, 39, 245, 10, 96, 40, 228, 237, 80, 41, 212, 236, 96, 42, 196, 207, 80, 43, 180, 206, 96, 44, 164, 177, 80, 45, 148, 176, 96, 46, 132, 147, 80, 47, 116, 146, 96, 48, 100, 117, 80, 49, 93, 174, 224, 50, 77, 145, 208, 51, 61, 144, 224, 52, 45, 115, 208, 53, 29, 114, 224, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 87, 208, 127, 208, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 5, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 31, 212, 0, 0, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 9, 0, 0, 28, 32, 0, 9, 0, 0, 42, 48, 1, 4, 0, 0, 42, 48, 0, 13, 0, 0, 28, 32, 0, 9, 76, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 43, 48, 51, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 51, 44, 77, 49, 48, 46, 53, 46, 48, 47, 52, 10}, - - "zoneinfo/Asia/Gaza": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 145, 0, 0, 0, 6, 0, 0, 0, 21, 128, 0, 0, 0, 200, 89, 178, 224, 204, 229, 193, 80, 205, 172, 254, 0, 206, 198, 244, 208, 207, 143, 102, 224, 208, 169, 121, 208, 209, 132, 96, 224, 210, 138, 201, 112, 211, 101, 176, 128, 212, 107, 224, 208, 232, 54, 99, 96, 232, 244, 45, 80, 234, 11, 185, 96, 234, 213, 96, 208, 235, 236, 250, 240, 236, 181, 109, 0, 237, 207, 127, 240, 238, 151, 242, 0, 239, 176, 179, 112, 240, 121, 37, 128, 241, 145, 230, 240, 242, 90, 89, 0, 243, 115, 26, 112, 244, 59, 140, 128, 245, 85, 159, 112, 246, 30, 17, 128, 247, 54, 210, 240, 247, 255, 69, 0, 249, 24, 6, 112, 249, 225, 202, 0, 250, 249, 57, 240, 251, 39, 66, 80, 8, 124, 139, 224, 8, 253, 176, 208, 9, 246, 234, 96, 10, 166, 51, 208, 28, 190, 248, 224, 29, 137, 241, 208, 30, 204, 255, 96, 31, 96, 153, 80, 32, 130, 177, 96, 33, 73, 181, 208, 34, 94, 158, 224, 35, 32, 93, 80, 36, 90, 48, 96, 37, 0, 63, 80, 38, 11, 237, 224, 38, 214, 230, 208, 39, 235, 207, 224, 40, 192, 3, 80, 41, 212, 236, 96, 42, 169, 31, 208, 43, 187, 101, 224, 44, 137, 1, 208, 45, 155, 71, 224, 46, 95, 169, 80, 47, 123, 41, 224, 48, 72, 197, 208, 48, 231, 7, 224, 49, 100, 70, 96, 50, 65, 194, 96, 51, 68, 40, 96, 52, 33, 164, 96, 53, 36, 10, 96, 54, 1, 134, 96, 54, 139, 243, 224, 55, 22, 97, 96, 56, 6, 68, 80, 56, 255, 125, 224, 57, 239, 96, 208, 58, 223, 95, 224, 59, 207, 66, 208, 60, 191, 65, 224, 61, 175, 36, 208, 62, 159, 35, 224, 63, 143, 6, 208, 64, 127, 5, 224, 65, 92, 129, 224, 66, 94, 231, 224, 67, 65, 183, 240, 68, 45, 166, 96, 69, 18, 253, 80, 70, 14, 217, 224, 70, 232, 111, 112, 71, 236, 24, 224, 72, 183, 17, 208, 73, 203, 250, 224, 74, 160, 60, 96, 75, 173, 46, 156, 76, 97, 189, 208, 77, 148, 249, 156, 78, 53, 194, 80, 79, 116, 219, 96, 80, 91, 145, 224, 81, 84, 189, 96, 82, 68, 160, 80, 83, 52, 159, 96, 84, 73, 108, 80, 85, 21, 210, 224, 86, 41, 78, 80, 86, 245, 194, 240, 88, 19, 202, 96, 88, 213, 164, 240, 89, 243, 172, 96, 90, 190, 193, 112, 91, 211, 142, 96, 92, 158, 163, 112, 93, 179, 112, 96, 94, 126, 133, 112, 95, 156, 140, 224, 96, 94, 103, 112, 97, 124, 110, 224, 98, 62, 73, 112, 99, 92, 80, 224, 100, 30, 43, 112, 101, 60, 50, 224, 102, 7, 71, 240, 103, 28, 20, 224, 103, 231, 41, 240, 104, 251, 246, 224, 105, 199, 11, 240, 106, 229, 19, 96, 107, 166, 237, 240, 108, 196, 245, 96, 109, 134, 207, 240, 110, 164, 215, 96, 111, 111, 236, 112, 112, 132, 185, 96, 113, 79, 206, 112, 114, 100, 155, 96, 115, 47, 176, 112, 116, 68, 125, 96, 117, 15, 146, 112, 118, 45, 153, 224, 118, 239, 116, 112, 120, 13, 123, 224, 120, 207, 86, 112, 121, 237, 93, 224, 122, 184, 114, 240, 123, 205, 63, 224, 124, 152, 84, 240, 125, 173, 33, 224, 126, 120, 54, 240, 127, 150, 62, 96, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 2, 1, 5, 1, 5, 1, 5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 32, 80, 0, 0, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 9, 0, 0, 42, 48, 1, 13, 0, 0, 28, 32, 0, 17, 0, 0, 28, 32, 0, 9, 76, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 73, 68, 84, 0, 73, 83, 84, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 54, 47, 49, 44, 77, 49, 48, 46, 53, 46, 54, 47, 49, 10}, - - "zoneinfo/Asia/Harbin": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 200, 92, 1, 128, 200, 250, 39, 112, 201, 213, 14, 128, 202, 219, 90, 240, 30, 186, 54, 0, 31, 105, 127, 112, 32, 126, 104, 128, 33, 73, 97, 112, 34, 94, 74, 128, 35, 41, 67, 112, 36, 71, 103, 0, 37, 18, 95, 240, 38, 39, 73, 0, 38, 242, 65, 240, 40, 7, 43, 0, 40, 210, 35, 240, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 113, 215, 0, 0, 0, 0, 126, 144, 1, 4, 0, 0, 112, 128, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 45, 56, 10}, - - "zoneinfo/Asia/Hebron": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 147, 0, 0, 0, 6, 0, 0, 0, 21, 128, 0, 0, 0, 200, 89, 178, 224, 204, 229, 193, 80, 205, 172, 254, 0, 206, 198, 244, 208, 207, 143, 102, 224, 208, 169, 121, 208, 209, 132, 96, 224, 210, 138, 201, 112, 211, 101, 176, 128, 212, 107, 224, 208, 232, 54, 99, 96, 232, 244, 45, 80, 234, 11, 185, 96, 234, 213, 96, 208, 235, 236, 250, 240, 236, 181, 109, 0, 237, 207, 127, 240, 238, 151, 242, 0, 239, 176, 179, 112, 240, 121, 37, 128, 241, 145, 230, 240, 242, 90, 89, 0, 243, 115, 26, 112, 244, 59, 140, 128, 245, 85, 159, 112, 246, 30, 17, 128, 247, 54, 210, 240, 247, 255, 69, 0, 249, 24, 6, 112, 249, 225, 202, 0, 250, 249, 57, 240, 251, 39, 66, 80, 8, 124, 139, 224, 8, 253, 176, 208, 9, 246, 234, 96, 10, 166, 51, 208, 28, 190, 248, 224, 29, 137, 241, 208, 30, 204, 255, 96, 31, 96, 153, 80, 32, 130, 177, 96, 33, 73, 181, 208, 34, 94, 158, 224, 35, 32, 93, 80, 36, 90, 48, 96, 37, 0, 63, 80, 38, 11, 237, 224, 38, 214, 230, 208, 39, 235, 207, 224, 40, 192, 3, 80, 41, 212, 236, 96, 42, 169, 31, 208, 43, 187, 101, 224, 44, 137, 1, 208, 45, 155, 71, 224, 46, 95, 169, 80, 47, 123, 41, 224, 48, 72, 197, 208, 48, 231, 7, 224, 49, 100, 70, 96, 50, 65, 194, 96, 51, 68, 40, 96, 52, 33, 164, 96, 53, 36, 10, 96, 54, 1, 134, 96, 54, 139, 243, 224, 55, 22, 97, 96, 56, 6, 68, 80, 56, 255, 125, 224, 57, 239, 96, 208, 58, 223, 95, 224, 59, 207, 66, 208, 60, 191, 65, 224, 61, 175, 36, 208, 62, 159, 35, 224, 63, 143, 6, 208, 64, 127, 5, 224, 65, 92, 129, 224, 66, 94, 231, 224, 67, 65, 183, 240, 68, 45, 166, 96, 69, 18, 253, 80, 70, 14, 217, 224, 70, 232, 111, 112, 71, 236, 24, 224, 72, 187, 6, 80, 73, 203, 250, 224, 74, 160, 60, 96, 75, 171, 220, 224, 76, 97, 189, 208, 77, 148, 249, 156, 78, 53, 194, 80, 78, 92, 11, 224, 78, 132, 220, 80, 79, 116, 219, 96, 80, 91, 145, 224, 81, 84, 189, 96, 82, 68, 160, 80, 83, 52, 159, 96, 84, 73, 108, 80, 85, 21, 210, 224, 86, 41, 78, 80, 86, 245, 194, 240, 88, 19, 202, 96, 88, 213, 164, 240, 89, 243, 172, 96, 90, 190, 193, 112, 91, 211, 142, 96, 92, 158, 163, 112, 93, 179, 112, 96, 94, 126, 133, 112, 95, 156, 140, 224, 96, 94, 103, 112, 97, 124, 110, 224, 98, 62, 73, 112, 99, 92, 80, 224, 100, 30, 43, 112, 101, 60, 50, 224, 102, 7, 71, 240, 103, 28, 20, 224, 103, 231, 41, 240, 104, 251, 246, 224, 105, 199, 11, 240, 106, 229, 19, 96, 107, 166, 237, 240, 108, 196, 245, 96, 109, 134, 207, 240, 110, 164, 215, 96, 111, 111, 236, 112, 112, 132, 185, 96, 113, 79, 206, 112, 114, 100, 155, 96, 115, 47, 176, 112, 116, 68, 125, 96, 117, 15, 146, 112, 118, 45, 153, 224, 118, 239, 116, 112, 120, 13, 123, 224, 120, 207, 86, 112, 121, 237, 93, 224, 122, 184, 114, 240, 123, 205, 63, 224, 124, 152, 84, 240, 125, 173, 33, 224, 126, 120, 54, 240, 127, 150, 62, 96, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 2, 1, 5, 1, 5, 1, 5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 32, 231, 0, 0, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 9, 0, 0, 42, 48, 1, 13, 0, 0, 28, 32, 0, 17, 0, 0, 28, 32, 0, 9, 76, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 73, 68, 84, 0, 73, 83, 84, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 54, 47, 49, 44, 77, 49, 48, 46, 53, 46, 54, 47, 49, 10}, - - "zoneinfo/Asia/Ho_Chi_Minh": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 6, 0, 0, 0, 21, 128, 0, 0, 0, 136, 140, 67, 128, 145, 163, 43, 10, 205, 53, 230, 128, 209, 89, 206, 112, 210, 59, 62, 240, 213, 50, 187, 16, 228, 182, 228, 128, 237, 47, 152, 0, 10, 61, 199, 0, 127, 255, 255, 255, 0, 1, 2, 3, 4, 2, 3, 2, 3, 2, 2, 0, 0, 100, 0, 0, 0, 0, 0, 99, 246, 0, 4, 0, 0, 98, 112, 0, 9, 0, 0, 112, 128, 0, 13, 0, 0, 126, 144, 0, 17, 0, 0, 98, 112, 0, 9, 76, 77, 84, 0, 80, 76, 77, 84, 0, 43, 48, 55, 0, 43, 48, 56, 0, 43, 48, 57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 55, 62, 45, 55, 10}, - - "zoneinfo/Asia/Hong_Kong": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 70, 0, 0, 0, 5, 0, 0, 0, 17, 128, 0, 0, 0, 133, 105, 90, 246, 201, 234, 87, 184, 202, 218, 58, 168, 203, 75, 120, 128, 210, 76, 98, 112, 211, 106, 183, 56, 212, 147, 74, 168, 213, 66, 176, 56, 214, 154, 185, 168, 215, 62, 65, 184, 216, 46, 36, 168, 216, 249, 57, 184, 218, 14, 6, 168, 218, 217, 27, 184, 219, 237, 232, 168, 220, 184, 253, 184, 221, 205, 202, 168, 222, 162, 26, 56, 223, 172, 91, 40, 224, 129, 252, 56, 225, 150, 201, 40, 226, 79, 105, 56, 227, 118, 171, 40, 228, 47, 75, 56, 229, 95, 199, 168, 230, 15, 45, 56, 231, 63, 169, 168, 231, 248, 73, 184, 233, 31, 139, 168, 233, 216, 43, 184, 234, 255, 109, 168, 235, 184, 13, 184, 236, 223, 79, 168, 237, 151, 239, 184, 238, 200, 108, 40, 239, 119, 209, 184, 240, 168, 78, 40, 241, 87, 179, 184, 242, 136, 48, 40, 243, 64, 208, 56, 244, 104, 18, 40, 245, 32, 178, 56, 246, 71, 244, 40, 247, 37, 126, 56, 248, 21, 97, 40, 249, 5, 96, 56, 249, 245, 67, 40, 250, 229, 66, 56, 251, 222, 95, 168, 252, 206, 94, 184, 253, 190, 65, 168, 254, 174, 64, 184, 255, 158, 35, 168, 0, 142, 34, 184, 1, 126, 5, 168, 2, 110, 4, 184, 3, 93, 231, 168, 4, 77, 230, 184, 5, 71, 4, 40, 6, 55, 3, 56, 7, 38, 230, 40, 7, 131, 61, 56, 9, 6, 200, 40, 9, 246, 199, 56, 10, 230, 170, 40, 11, 214, 169, 56, 12, 198, 140, 40, 17, 155, 57, 56, 18, 111, 108, 168, 0, 2, 1, 2, 3, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 107, 10, 0, 0, 0, 0, 126, 144, 1, 4, 0, 0, 112, 128, 0, 9, 0, 0, 126, 144, 0, 13, 0, 0, 112, 128, 0, 9, 76, 77, 84, 0, 72, 75, 83, 84, 0, 72, 75, 84, 0, 74, 83, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 72, 75, 84, 45, 56, 10}, - - "zoneinfo/Asia/Hovd": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 52, 0, 0, 0, 4, 0, 0, 0, 16, 128, 0, 0, 0, 134, 211, 252, 148, 15, 11, 234, 160, 24, 233, 214, 144, 25, 219, 11, 0, 26, 204, 91, 144, 27, 188, 62, 128, 28, 172, 61, 144, 29, 156, 32, 128, 30, 140, 31, 144, 31, 124, 2, 128, 32, 108, 1, 144, 33, 91, 228, 128, 34, 75, 227, 144, 35, 59, 198, 128, 36, 43, 197, 144, 37, 27, 168, 128, 38, 11, 167, 144, 39, 4, 197, 0, 39, 244, 196, 16, 40, 228, 167, 0, 41, 212, 166, 16, 42, 196, 137, 0, 43, 180, 136, 16, 44, 164, 107, 0, 45, 148, 106, 16, 46, 132, 77, 0, 47, 116, 76, 16, 48, 100, 47, 0, 49, 93, 104, 144, 50, 77, 75, 128, 51, 61, 74, 144, 52, 45, 45, 128, 53, 29, 44, 144, 54, 13, 15, 128, 58, 233, 193, 176, 59, 180, 186, 160, 60, 164, 185, 176, 61, 148, 156, 160, 62, 132, 155, 176, 63, 116, 126, 160, 64, 100, 125, 176, 65, 84, 96, 160, 66, 68, 95, 176, 67, 52, 66, 160, 68, 36, 65, 176, 69, 29, 95, 32, 85, 21, 168, 176, 86, 5, 111, 128, 86, 245, 138, 176, 87, 229, 81, 128, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 3, 0, 0, 85, 236, 0, 0, 0, 0, 84, 96, 0, 4, 0, 0, 112, 128, 1, 8, 0, 0, 98, 112, 0, 12, 76, 77, 84, 0, 43, 48, 54, 0, 43, 48, 56, 0, 43, 48, 55, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 55, 62, 45, 55, 10}, - - "zoneinfo/Asia/Irkutsk": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 12, 0, 0, 0, 20, 128, 0, 0, 0, 162, 18, 15, 191, 181, 163, 211, 16, 21, 39, 97, 128, 22, 24, 149, 240, 23, 8, 149, 0, 23, 249, 201, 112, 24, 233, 200, 128, 25, 218, 252, 240, 26, 204, 77, 128, 27, 188, 90, 160, 28, 172, 75, 160, 29, 156, 60, 160, 30, 140, 45, 160, 31, 124, 30, 160, 32, 108, 15, 160, 33, 92, 0, 160, 34, 75, 241, 160, 35, 59, 226, 160, 36, 43, 211, 160, 37, 27, 196, 160, 38, 11, 181, 160, 39, 4, 225, 32, 39, 244, 210, 32, 40, 228, 209, 48, 41, 120, 121, 48, 41, 212, 180, 32, 42, 196, 165, 32, 43, 180, 150, 32, 44, 164, 135, 32, 45, 148, 120, 32, 46, 132, 105, 32, 47, 116, 90, 32, 48, 100, 75, 32, 49, 93, 118, 160, 50, 114, 81, 160, 51, 61, 88, 160, 52, 82, 51, 160, 53, 29, 58, 160, 54, 50, 21, 160, 54, 253, 28, 160, 56, 27, 50, 32, 56, 220, 254, 160, 57, 251, 20, 32, 58, 188, 224, 160, 59, 218, 246, 32, 60, 165, 253, 32, 61, 186, 216, 32, 62, 133, 223, 32, 63, 154, 186, 32, 64, 101, 193, 32, 65, 131, 214, 160, 66, 69, 163, 32, 67, 99, 184, 160, 68, 37, 133, 32, 69, 67, 154, 160, 70, 5, 103, 32, 71, 35, 124, 160, 71, 238, 131, 160, 73, 3, 94, 160, 73, 206, 101, 160, 74, 227, 64, 160, 75, 174, 71, 160, 76, 204, 93, 32, 77, 142, 41, 160, 84, 75, 215, 16, 127, 255, 255, 255, 1, 2, 4, 3, 4, 3, 4, 3, 4, 3, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 7, 8, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 9, 5, 5, 0, 0, 97, 193, 0, 0, 0, 0, 97, 193, 0, 4, 0, 0, 98, 112, 0, 8, 0, 0, 126, 144, 1, 12, 0, 0, 112, 128, 0, 16, 0, 0, 112, 128, 0, 16, 0, 0, 126, 144, 1, 12, 0, 0, 112, 128, 1, 16, 0, 0, 98, 112, 0, 8, 0, 0, 126, 144, 0, 12, 0, 0, 126, 144, 1, 12, 0, 0, 112, 128, 0, 16, 76, 77, 84, 0, 73, 77, 84, 0, 43, 48, 55, 0, 43, 48, 57, 0, 43, 48, 56, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 56, 62, 45, 56, 10}, - - "zoneinfo/Asia/Istanbul": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 131, 0, 0, 0, 11, 0, 0, 0, 25, 128, 0, 0, 0, 144, 139, 245, 152, 155, 12, 23, 96, 155, 213, 190, 208, 162, 101, 99, 224, 163, 123, 130, 80, 164, 78, 128, 96, 165, 63, 180, 208, 166, 37, 39, 224, 167, 39, 127, 208, 170, 40, 40, 96, 170, 225, 253, 208, 171, 249, 137, 224, 172, 195, 49, 80, 200, 127, 238, 96, 200, 255, 193, 208, 201, 74, 245, 96, 202, 206, 128, 80, 203, 203, 174, 96, 204, 229, 193, 80, 209, 113, 235, 224, 210, 107, 9, 80, 211, 162, 57, 96, 212, 67, 2, 80, 213, 76, 13, 224, 214, 41, 123, 208, 215, 43, 239, 224, 216, 9, 93, 208, 217, 2, 151, 96, 217, 233, 63, 208, 218, 239, 168, 96, 219, 210, 92, 80, 220, 212, 208, 96, 221, 179, 143, 208, 241, 244, 185, 96, 242, 100, 186, 208, 245, 104, 6, 96, 246, 31, 56, 208, 0, 160, 186, 224, 1, 107, 179, 208, 2, 128, 156, 224, 3, 75, 149, 208, 4, 105, 185, 96, 5, 52, 178, 80, 6, 110, 147, 112, 7, 57, 168, 128, 7, 251, 117, 0, 9, 25, 166, 160, 9, 219, 58, 224, 10, 240, 7, 208, 12, 16, 206, 96, 12, 217, 36, 80, 13, 164, 57, 96, 14, 166, 145, 80, 15, 132, 27, 96, 16, 134, 115, 80, 18, 103, 152, 192, 19, 77, 54, 0, 20, 71, 122, 192, 21, 35, 221, 128, 22, 39, 92, 192, 23, 3, 191, 128, 24, 7, 62, 192, 25, 137, 148, 80, 25, 220, 148, 192, 28, 198, 211, 208, 29, 155, 21, 80, 30, 140, 115, 240, 31, 124, 100, 240, 32, 108, 85, 240, 33, 92, 70, 240, 34, 76, 55, 240, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 10, 240, 38, 11, 251, 240, 39, 5, 39, 112, 39, 245, 24, 112, 40, 229, 9, 112, 41, 212, 250, 112, 42, 196, 235, 112, 43, 180, 220, 112, 44, 164, 205, 112, 45, 139, 131, 240, 46, 132, 175, 112, 47, 116, 160, 112, 48, 100, 145, 112, 49, 93, 188, 240, 50, 114, 151, 240, 51, 61, 158, 240, 52, 82, 121, 240, 53, 29, 128, 240, 54, 50, 91, 240, 54, 253, 98, 240, 56, 27, 120, 112, 56, 221, 68, 240, 57, 251, 90, 112, 58, 189, 38, 240, 59, 219, 60, 112, 60, 166, 67, 112, 61, 187, 30, 112, 62, 134, 37, 112, 63, 155, 0, 112, 64, 102, 7, 112, 65, 132, 28, 240, 66, 69, 233, 112, 67, 99, 254, 240, 68, 37, 203, 112, 69, 67, 224, 240, 69, 152, 50, 224, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 143, 221, 144, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 56, 190, 16, 84, 76, 71, 144, 85, 23, 78, 144, 86, 62, 158, 144, 86, 247, 48, 144, 87, 207, 46, 80, 127, 255, 255, 255, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 2, 3, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 3, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 5, 5, 0, 0, 27, 40, 0, 0, 0, 0, 27, 104, 0, 4, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 0, 0, 56, 64, 1, 17, 0, 0, 42, 48, 0, 21, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 0, 0, 42, 48, 0, 21, 76, 77, 84, 0, 73, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 43, 48, 52, 0, 43, 48, 51, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 10, 60, 43, 48, 51, 62, 45, 51, 10}, - - "zoneinfo/Asia/Jakarta": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 7, 0, 0, 0, 32, 128, 0, 0, 0, 169, 120, 133, 224, 186, 22, 222, 96, 203, 191, 131, 136, 210, 86, 238, 112, 215, 60, 198, 8, 218, 255, 38, 0, 244, 181, 190, 136, 1, 2, 3, 4, 3, 5, 3, 6, 0, 0, 100, 32, 0, 0, 0, 0, 100, 32, 0, 4, 0, 0, 103, 32, 0, 8, 0, 0, 105, 120, 0, 14, 0, 0, 126, 144, 0, 20, 0, 0, 112, 128, 0, 24, 0, 0, 98, 112, 0, 28, 76, 77, 84, 0, 66, 77, 84, 0, 43, 48, 55, 50, 48, 0, 43, 48, 55, 51, 48, 0, 43, 48, 57, 0, 43, 48, 56, 0, 87, 73, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 87, 73, 66, 45, 55, 10}, - - "zoneinfo/Asia/Jayapura": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 18, 128, 0, 0, 0, 186, 22, 193, 152, 208, 88, 185, 240, 244, 181, 162, 104, 0, 1, 2, 3, 0, 0, 131, 232, 0, 0, 0, 0, 126, 144, 0, 4, 0, 0, 133, 152, 0, 8, 0, 0, 126, 144, 0, 14, 76, 77, 84, 0, 43, 48, 57, 0, 43, 48, 57, 51, 48, 0, 87, 73, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 87, 73, 84, 45, 57, 10}, - - "zoneinfo/Asia/Jerusalem": []byte{84, 90, 105, 102, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 143, 0, 0, 0, 6, 0, 0, 0, 21, 128, 0, 0, 0, 158, 48, 69, 136, 200, 89, 178, 224, 204, 229, 193, 80, 205, 172, 254, 0, 206, 198, 244, 208, 207, 143, 102, 224, 208, 169, 121, 208, 209, 132, 96, 224, 210, 138, 201, 112, 211, 101, 176, 128, 212, 107, 224, 208, 215, 90, 20, 96, 215, 223, 31, 192, 216, 47, 181, 112, 217, 30, 70, 224, 218, 16, 232, 240, 218, 235, 179, 224, 219, 180, 52, 0, 220, 185, 32, 224, 221, 224, 141, 0, 222, 180, 206, 128, 223, 164, 191, 128, 224, 139, 118, 0, 225, 86, 125, 0, 226, 190, 74, 96, 227, 54, 52, 208, 228, 156, 247, 0, 229, 22, 22, 208, 230, 116, 211, 224, 231, 17, 210, 128, 232, 39, 255, 0, 232, 232, 79, 208, 8, 124, 139, 224, 8, 253, 176, 208, 9, 246, 234, 96, 10, 166, 51, 208, 28, 190, 248, 224, 29, 137, 241, 208, 30, 204, 255, 96, 31, 96, 153, 80, 32, 130, 177, 96, 33, 73, 181, 208, 34, 94, 158, 224, 35, 32, 93, 80, 36, 90, 48, 96, 37, 0, 63, 80, 38, 11, 237, 224, 38, 214, 230, 208, 39, 235, 207, 224, 40, 192, 3, 80, 41, 212, 236, 96, 42, 169, 31, 208, 43, 187, 101, 224, 44, 137, 1, 208, 45, 155, 71, 224, 46, 95, 169, 80, 47, 123, 41, 224, 48, 72, 197, 208, 49, 72, 150, 224, 50, 60, 110, 80, 51, 49, 179, 96, 52, 26, 254, 208, 53, 17, 149, 96, 53, 241, 166, 80, 55, 4, 8, 128, 55, 207, 1, 112, 56, 246, 95, 128, 57, 220, 249, 224, 58, 208, 237, 112, 59, 174, 91, 96, 60, 163, 160, 112, 61, 160, 178, 96, 62, 131, 130, 112, 63, 124, 159, 224, 64, 115, 54, 112, 65, 80, 164, 96, 66, 76, 143, 0, 67, 72, 79, 112, 68, 44, 113, 0, 69, 30, 246, 240, 70, 12, 83, 0, 70, 236, 99, 240, 71, 236, 53, 0, 72, 231, 245, 112, 73, 204, 23, 0, 74, 190, 156, 240, 75, 171, 249, 0, 76, 140, 9, 240, 77, 149, 21, 128, 78, 135, 155, 112, 79, 116, 247, 128, 80, 94, 66, 240, 81, 84, 217, 128, 82, 108, 73, 112, 83, 52, 187, 128, 84, 76, 43, 112, 85, 20, 157, 128, 86, 44, 13, 112, 86, 244, 127, 128, 88, 21, 41, 240, 88, 212, 97, 128, 89, 245, 11, 240, 90, 180, 67, 128, 91, 212, 237, 240, 92, 157, 96, 0, 93, 180, 207, 240, 94, 125, 66, 0, 95, 148, 177, 240, 96, 93, 36, 0, 97, 125, 206, 112, 98, 61, 6, 0, 99, 93, 176, 112, 100, 28, 232, 0, 101, 61, 146, 112, 102, 6, 4, 128, 103, 29, 116, 112, 103, 229, 230, 128, 104, 253, 86, 112, 105, 197, 200, 128, 106, 221, 56, 112, 107, 165, 170, 128, 108, 198, 84, 240, 109, 133, 140, 128, 110, 166, 54, 240, 111, 101, 110, 128, 112, 134, 24, 240, 113, 78, 139, 0, 114, 101, 250, 240, 115, 46, 109, 0, 116, 69, 220, 240, 117, 14, 79, 0, 118, 46, 249, 112, 118, 238, 49, 0, 120, 14, 219, 112, 120, 206, 19, 0, 121, 238, 189, 112, 122, 173, 245, 0, 123, 206, 159, 112, 124, 151, 17, 128, 125, 174, 129, 112, 126, 118, 243, 128, 127, 142, 99, 112, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 4, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 0, 0, 33, 6, 0, 0, 0, 0, 32, 248, 0, 4, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 12, 0, 0, 56, 64, 1, 16, 0, 0, 42, 48, 1, 8, 76, 77, 84, 0, 74, 77, 84, 0, 73, 68, 84, 0, 73, 83, 84, 0, 73, 68, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 73, 83, 84, 45, 50, 73, 68, 84, 44, 77, 51, 46, 52, 46, 52, 47, 50, 54, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/Asia/Kabul": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 14, 128, 0, 0, 0, 208, 249, 215, 64, 127, 255, 255, 255, 1, 2, 2, 0, 0, 64, 224, 0, 0, 0, 0, 56, 64, 0, 4, 0, 0, 63, 72, 0, 8, 76, 77, 84, 0, 43, 48, 52, 0, 43, 48, 52, 51, 48, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 52, 51, 48, 62, 45, 52, 58, 51, 48, 10}, - - "zoneinfo/Asia/Kamchatka": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 66, 0, 0, 0, 9, 0, 0, 0, 16, 128, 0, 0, 0, 167, 82, 150, 196, 181, 163, 154, 208, 21, 39, 41, 64, 22, 24, 93, 176, 23, 8, 92, 192, 23, 249, 145, 48, 24, 233, 144, 64, 25, 218, 196, 176, 26, 204, 21, 64, 27, 188, 34, 96, 28, 172, 19, 96, 29, 156, 4, 96, 30, 139, 245, 96, 31, 123, 230, 96, 32, 107, 215, 96, 33, 91, 200, 96, 34, 75, 185, 96, 35, 59, 170, 96, 36, 43, 155, 96, 37, 27, 140, 96, 38, 11, 125, 96, 39, 4, 168, 224, 39, 244, 153, 224, 40, 228, 152, 240, 41, 120, 64, 240, 41, 212, 123, 224, 42, 196, 108, 224, 43, 180, 93, 224, 44, 164, 78, 224, 45, 148, 63, 224, 46, 132, 48, 224, 47, 116, 33, 224, 48, 100, 18, 224, 49, 93, 62, 96, 50, 114, 25, 96, 51, 61, 32, 96, 52, 81, 251, 96, 53, 29, 2, 96, 54, 49, 221, 96, 54, 252, 228, 96, 56, 26, 249, 224, 56, 220, 198, 96, 57, 250, 219, 224, 58, 188, 168, 96, 59, 218, 189, 224, 60, 165, 196, 224, 61, 186, 159, 224, 62, 133, 166, 224, 63, 154, 129, 224, 64, 101, 136, 224, 65, 131, 158, 96, 66, 69, 106, 224, 67, 99, 128, 96, 68, 37, 76, 224, 69, 67, 98, 96, 70, 5, 46, 224, 71, 35, 68, 96, 71, 238, 75, 96, 73, 3, 38, 96, 73, 206, 45, 96, 74, 227, 8, 96, 75, 174, 15, 96, 76, 204, 50, 240, 77, 141, 255, 112, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 4, 0, 0, 148, 188, 0, 0, 0, 0, 154, 176, 0, 4, 0, 0, 182, 208, 1, 8, 0, 0, 168, 192, 0, 12, 0, 0, 168, 192, 0, 12, 0, 0, 182, 208, 1, 8, 0, 0, 168, 192, 1, 12, 0, 0, 154, 176, 0, 4, 0, 0, 168, 192, 0, 12, 76, 77, 84, 0, 43, 49, 49, 0, 43, 49, 51, 0, 43, 49, 50, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 50, 62, 45, 49, 50, 10}, - - "zoneinfo/Asia/Karachi": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 6, 0, 0, 0, 29, 128, 0, 0, 0, 137, 126, 252, 164, 204, 149, 50, 168, 210, 116, 18, 152, 221, 168, 224, 168, 2, 79, 171, 48, 60, 175, 69, 176, 61, 159, 40, 160, 72, 65, 160, 48, 73, 11, 71, 160, 73, 228, 221, 48, 74, 236, 123, 32, 0, 1, 2, 1, 3, 5, 4, 5, 4, 5, 4, 5, 0, 0, 62, 220, 0, 0, 0, 0, 77, 88, 0, 4, 0, 0, 91, 104, 1, 10, 0, 0, 70, 80, 0, 16, 0, 0, 84, 96, 1, 20, 0, 0, 70, 80, 0, 25, 76, 77, 84, 0, 43, 48, 53, 51, 48, 0, 43, 48, 54, 51, 48, 0, 43, 48, 53, 0, 80, 75, 83, 84, 0, 80, 75, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 80, 75, 84, 45, 53, 10}, - - "zoneinfo/Asia/Kashgar": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 176, 254, 186, 100, 127, 255, 255, 255, 0, 1, 1, 0, 0, 82, 28, 0, 0, 0, 0, 84, 96, 0, 4, 76, 77, 84, 0, 43, 48, 54, 0, 0, 0, 0, 0, 10, 60, 43, 48, 54, 62, 45, 54, 10}, - - "zoneinfo/Asia/Kathmandu": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 3, 0, 0, 0, 16, 128, 0, 0, 0, 161, 242, 125, 132, 30, 24, 48, 168, 127, 255, 255, 255, 0, 1, 2, 2, 0, 0, 79, 252, 0, 0, 0, 0, 77, 88, 0, 4, 0, 0, 80, 220, 0, 10, 76, 77, 84, 0, 43, 48, 53, 51, 48, 0, 43, 48, 53, 52, 53, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 53, 52, 53, 62, 45, 53, 58, 52, 53, 10}, - - "zoneinfo/Asia/Katmandu": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 3, 0, 0, 0, 16, 128, 0, 0, 0, 161, 242, 125, 132, 30, 24, 48, 168, 127, 255, 255, 255, 0, 1, 2, 2, 0, 0, 79, 252, 0, 0, 0, 0, 77, 88, 0, 4, 0, 0, 80, 220, 0, 10, 76, 77, 84, 0, 43, 48, 53, 51, 48, 0, 43, 48, 53, 52, 53, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 53, 52, 53, 62, 45, 53, 58, 52, 53, 10}, - - "zoneinfo/Asia/Khandyga": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 69, 0, 0, 0, 13, 0, 0, 0, 20, 128, 0, 0, 0, 161, 219, 228, 235, 181, 163, 197, 0, 21, 39, 83, 112, 22, 24, 135, 224, 23, 8, 134, 240, 23, 249, 187, 96, 24, 233, 186, 112, 25, 218, 238, 224, 26, 204, 63, 112, 27, 188, 76, 144, 28, 172, 61, 144, 29, 156, 46, 144, 30, 140, 31, 144, 31, 124, 16, 144, 32, 108, 1, 144, 33, 91, 242, 144, 34, 75, 227, 144, 35, 59, 212, 144, 36, 43, 197, 144, 37, 27, 182, 144, 38, 11, 167, 144, 39, 4, 211, 16, 39, 244, 196, 16, 40, 228, 195, 32, 41, 120, 107, 32, 41, 212, 166, 16, 42, 196, 151, 16, 43, 180, 136, 16, 44, 164, 121, 16, 45, 148, 106, 16, 46, 132, 91, 16, 47, 116, 76, 16, 48, 100, 61, 16, 49, 93, 104, 144, 50, 114, 67, 144, 51, 61, 74, 144, 52, 82, 37, 144, 53, 29, 44, 144, 54, 50, 7, 144, 54, 253, 14, 144, 56, 27, 36, 16, 56, 220, 240, 144, 57, 251, 6, 16, 58, 188, 210, 144, 59, 218, 232, 16, 60, 165, 239, 16, 61, 186, 202, 16, 62, 133, 209, 16, 63, 154, 172, 16, 63, 242, 228, 112, 64, 101, 165, 0, 65, 131, 186, 128, 66, 69, 135, 0, 67, 99, 156, 128, 68, 37, 105, 0, 69, 67, 126, 128, 70, 5, 75, 0, 71, 35, 96, 128, 71, 238, 103, 128, 73, 3, 66, 128, 73, 206, 73, 128, 74, 227, 36, 128, 75, 174, 43, 128, 76, 204, 65, 0, 77, 142, 13, 128, 78, 110, 2, 80, 84, 75, 201, 0, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 10, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 11, 9, 4, 4, 0, 0, 127, 21, 0, 0, 0, 0, 112, 128, 0, 4, 0, 0, 140, 160, 1, 8, 0, 0, 126, 144, 0, 12, 0, 0, 126, 144, 0, 12, 0, 0, 140, 160, 1, 8, 0, 0, 126, 144, 1, 12, 0, 0, 112, 128, 0, 4, 0, 0, 154, 176, 1, 16, 0, 0, 140, 160, 0, 8, 0, 0, 140, 160, 0, 8, 0, 0, 154, 176, 0, 16, 0, 0, 126, 144, 0, 12, 76, 77, 84, 0, 43, 48, 56, 0, 43, 49, 48, 0, 43, 48, 57, 0, 43, 49, 49, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 57, 62, 45, 57, 10}, - - "zoneinfo/Asia/Kolkata": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 18, 128, 0, 0, 0, 135, 157, 188, 186, 202, 219, 140, 40, 204, 5, 113, 24, 204, 149, 50, 168, 210, 116, 18, 152, 1, 2, 3, 2, 3, 2, 0, 0, 82, 208, 0, 0, 0, 0, 75, 70, 0, 4, 0, 0, 77, 88, 0, 8, 0, 0, 91, 104, 1, 12, 72, 77, 84, 0, 77, 77, 84, 0, 73, 83, 84, 0, 43, 48, 54, 51, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 73, 83, 84, 45, 53, 58, 51, 48, 10}, - - "zoneinfo/Asia/Krasnoyarsk": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 11, 0, 0, 0, 16, 128, 0, 0, 0, 161, 249, 13, 242, 181, 163, 225, 32, 21, 39, 111, 144, 22, 24, 164, 0, 23, 8, 163, 16, 23, 249, 215, 128, 24, 233, 214, 144, 25, 219, 11, 0, 26, 204, 91, 144, 27, 188, 104, 176, 28, 172, 89, 176, 29, 156, 74, 176, 30, 140, 59, 176, 31, 124, 44, 176, 32, 108, 29, 176, 33, 92, 14, 176, 34, 75, 255, 176, 35, 59, 240, 176, 36, 43, 225, 176, 37, 27, 210, 176, 38, 11, 195, 176, 39, 4, 239, 48, 39, 244, 224, 48, 40, 228, 223, 64, 41, 120, 135, 64, 41, 212, 194, 48, 42, 196, 179, 48, 43, 180, 164, 48, 44, 164, 149, 48, 45, 148, 134, 48, 46, 132, 119, 48, 47, 116, 104, 48, 48, 100, 89, 48, 49, 93, 132, 176, 50, 114, 95, 176, 51, 61, 102, 176, 52, 82, 65, 176, 53, 29, 72, 176, 54, 50, 35, 176, 54, 253, 42, 176, 56, 27, 64, 48, 56, 221, 12, 176, 57, 251, 34, 48, 58, 188, 238, 176, 59, 219, 4, 48, 60, 166, 11, 48, 61, 186, 230, 48, 62, 133, 237, 48, 63, 154, 200, 48, 64, 101, 207, 48, 65, 131, 228, 176, 66, 69, 177, 48, 67, 99, 198, 176, 68, 37, 147, 48, 69, 67, 168, 176, 70, 5, 117, 48, 71, 35, 138, 176, 71, 238, 145, 176, 73, 3, 108, 176, 73, 206, 115, 176, 74, 227, 78, 176, 75, 174, 85, 176, 76, 204, 107, 48, 77, 142, 55, 176, 84, 75, 229, 32, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 8, 4, 4, 0, 0, 87, 14, 0, 0, 0, 0, 84, 96, 0, 4, 0, 0, 112, 128, 1, 8, 0, 0, 98, 112, 0, 12, 0, 0, 98, 112, 0, 12, 0, 0, 112, 128, 1, 8, 0, 0, 98, 112, 1, 12, 0, 0, 84, 96, 0, 4, 0, 0, 112, 128, 0, 8, 0, 0, 112, 128, 1, 8, 0, 0, 98, 112, 0, 12, 76, 77, 84, 0, 43, 48, 54, 0, 43, 48, 56, 0, 43, 48, 55, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 55, 62, 45, 55, 10}, - - "zoneinfo/Asia/Kuala_Lumpur": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 8, 0, 0, 0, 32, 128, 0, 0, 0, 134, 131, 133, 163, 186, 103, 78, 144, 192, 10, 228, 96, 202, 179, 229, 96, 203, 145, 95, 8, 210, 72, 109, 240, 22, 145, 245, 8, 127, 255, 255, 255, 1, 2, 3, 4, 5, 6, 5, 7, 7, 0, 0, 95, 86, 0, 0, 0, 0, 97, 93, 0, 4, 0, 0, 98, 112, 0, 8, 0, 0, 103, 32, 1, 12, 0, 0, 103, 32, 0, 12, 0, 0, 105, 120, 0, 18, 0, 0, 126, 144, 0, 24, 0, 0, 112, 128, 0, 28, 76, 77, 84, 0, 83, 77, 84, 0, 43, 48, 55, 0, 43, 48, 55, 50, 48, 0, 43, 48, 55, 51, 48, 0, 43, 48, 57, 0, 43, 48, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 56, 62, 45, 56, 10}, - - "zoneinfo/Asia/Kuching": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 6, 0, 0, 0, 24, 128, 0, 0, 0, 173, 138, 6, 144, 186, 103, 71, 136, 191, 123, 39, 128, 191, 243, 27, 80, 193, 93, 172, 128, 193, 213, 160, 80, 195, 62, 224, 0, 195, 182, 211, 208, 197, 32, 19, 128, 197, 152, 7, 80, 199, 1, 71, 0, 199, 121, 58, 208, 200, 227, 204, 0, 201, 91, 191, 208, 202, 196, 255, 128, 203, 60, 243, 80, 203, 145, 88, 0, 210, 72, 109, 240, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 4, 3, 3, 0, 0, 103, 112, 0, 0, 0, 0, 105, 120, 0, 4, 0, 0, 117, 48, 1, 10, 0, 0, 112, 128, 0, 16, 0, 0, 126, 144, 0, 20, 0, 0, 112, 128, 0, 16, 76, 77, 84, 0, 43, 48, 55, 51, 48, 0, 43, 48, 56, 50, 48, 0, 43, 48, 56, 0, 43, 48, 57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 56, 62, 45, 56, 10}, - - "zoneinfo/Asia/Kuwait": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 213, 27, 54, 180, 127, 255, 255, 255, 0, 1, 1, 0, 0, 43, 204, 0, 0, 0, 0, 42, 48, 0, 4, 76, 77, 84, 0, 43, 48, 51, 0, 0, 0, 0, 0, 10, 60, 43, 48, 51, 62, 45, 51, 10}, - - "zoneinfo/Asia/Macao": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 42, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 146, 230, 36, 4, 239, 119, 209, 184, 240, 168, 78, 40, 241, 87, 179, 184, 242, 136, 48, 40, 243, 55, 100, 128, 244, 104, 18, 40, 245, 32, 178, 56, 246, 71, 244, 40, 247, 0, 99, 0, 248, 39, 164, 240, 249, 5, 96, 56, 249, 245, 67, 40, 250, 229, 66, 56, 251, 222, 95, 168, 252, 206, 94, 184, 253, 190, 65, 168, 254, 174, 64, 184, 255, 158, 35, 168, 0, 142, 34, 184, 1, 126, 5, 168, 2, 110, 4, 184, 3, 93, 231, 168, 4, 77, 181, 128, 5, 61, 152, 112, 6, 45, 151, 128, 7, 38, 180, 240, 8, 22, 180, 0, 9, 6, 200, 40, 9, 246, 199, 56, 10, 230, 170, 40, 11, 214, 169, 56, 12, 198, 140, 40, 13, 182, 139, 56, 14, 166, 110, 40, 15, 150, 60, 0, 16, 134, 30, 240, 17, 118, 30, 0, 18, 111, 59, 112, 19, 95, 58, 128, 20, 79, 29, 112, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 106, 124, 0, 0, 0, 0, 126, 144, 1, 4, 0, 0, 112, 128, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 45, 56, 10}, - - "zoneinfo/Asia/Macau": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 42, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 146, 230, 36, 4, 239, 119, 209, 184, 240, 168, 78, 40, 241, 87, 179, 184, 242, 136, 48, 40, 243, 55, 100, 128, 244, 104, 18, 40, 245, 32, 178, 56, 246, 71, 244, 40, 247, 0, 99, 0, 248, 39, 164, 240, 249, 5, 96, 56, 249, 245, 67, 40, 250, 229, 66, 56, 251, 222, 95, 168, 252, 206, 94, 184, 253, 190, 65, 168, 254, 174, 64, 184, 255, 158, 35, 168, 0, 142, 34, 184, 1, 126, 5, 168, 2, 110, 4, 184, 3, 93, 231, 168, 4, 77, 181, 128, 5, 61, 152, 112, 6, 45, 151, 128, 7, 38, 180, 240, 8, 22, 180, 0, 9, 6, 200, 40, 9, 246, 199, 56, 10, 230, 170, 40, 11, 214, 169, 56, 12, 198, 140, 40, 13, 182, 139, 56, 14, 166, 110, 40, 15, 150, 60, 0, 16, 134, 30, 240, 17, 118, 30, 0, 18, 111, 59, 112, 19, 95, 58, 128, 20, 79, 29, 112, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 106, 124, 0, 0, 0, 0, 126, 144, 1, 4, 0, 0, 112, 128, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 45, 56, 10}, - - "zoneinfo/Asia/Magadan": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 11, 0, 0, 0, 16, 128, 0, 0, 0, 170, 25, 54, 160, 181, 163, 168, 224, 21, 39, 55, 80, 22, 24, 107, 192, 23, 8, 106, 208, 23, 249, 159, 64, 24, 233, 158, 80, 25, 218, 210, 192, 26, 204, 35, 80, 27, 188, 48, 112, 28, 172, 33, 112, 29, 156, 18, 112, 30, 140, 3, 112, 31, 123, 244, 112, 32, 107, 229, 112, 33, 91, 214, 112, 34, 75, 199, 112, 35, 59, 184, 112, 36, 43, 169, 112, 37, 27, 154, 112, 38, 11, 139, 112, 39, 4, 182, 240, 39, 244, 167, 240, 40, 228, 167, 0, 41, 120, 79, 0, 41, 212, 137, 240, 42, 196, 122, 240, 43, 180, 107, 240, 44, 164, 92, 240, 45, 148, 77, 240, 46, 132, 62, 240, 47, 116, 47, 240, 48, 100, 32, 240, 49, 93, 76, 112, 50, 114, 39, 112, 51, 61, 46, 112, 52, 82, 9, 112, 53, 29, 16, 112, 54, 49, 235, 112, 54, 252, 242, 112, 56, 27, 7, 240, 56, 220, 212, 112, 57, 250, 233, 240, 58, 188, 182, 112, 59, 218, 203, 240, 60, 165, 210, 240, 61, 186, 173, 240, 62, 133, 180, 240, 63, 154, 143, 240, 64, 101, 150, 240, 65, 131, 172, 112, 66, 69, 120, 240, 67, 99, 142, 112, 68, 37, 90, 240, 69, 67, 112, 112, 70, 5, 60, 240, 71, 35, 82, 112, 71, 238, 89, 112, 73, 3, 52, 112, 73, 206, 59, 112, 74, 227, 22, 112, 75, 174, 29, 112, 76, 204, 50, 240, 77, 141, 255, 112, 84, 75, 172, 224, 87, 27, 156, 0, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 8, 7, 4, 4, 0, 0, 141, 96, 0, 0, 0, 0, 140, 160, 0, 4, 0, 0, 168, 192, 1, 8, 0, 0, 154, 176, 0, 12, 0, 0, 154, 176, 0, 12, 0, 0, 168, 192, 1, 8, 0, 0, 154, 176, 1, 12, 0, 0, 140, 160, 0, 4, 0, 0, 168, 192, 0, 8, 0, 0, 168, 192, 1, 8, 0, 0, 154, 176, 0, 12, 76, 77, 84, 0, 43, 49, 48, 0, 43, 49, 50, 0, 43, 49, 49, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 49, 62, 45, 49, 49, 10}, - - "zoneinfo/Asia/Makassar": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 21, 128, 0, 0, 0, 161, 242, 93, 144, 186, 22, 213, 144, 203, 136, 29, 128, 210, 86, 238, 112, 0, 1, 2, 3, 4, 0, 0, 111, 240, 0, 0, 0, 0, 111, 240, 0, 4, 0, 0, 112, 128, 0, 8, 0, 0, 126, 144, 0, 12, 0, 0, 112, 128, 0, 16, 76, 77, 84, 0, 77, 77, 84, 0, 43, 48, 56, 0, 43, 48, 57, 0, 87, 73, 84, 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 87, 73, 84, 65, 45, 56, 10}, - - "zoneinfo/Asia/Manila": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 5, 0, 0, 0, 12, 128, 0, 0, 0, 193, 156, 244, 128, 194, 22, 48, 112, 203, 242, 231, 0, 208, 169, 37, 112, 226, 108, 57, 0, 226, 213, 162, 240, 15, 117, 70, 128, 16, 102, 122, 240, 127, 255, 255, 255, 2, 1, 2, 3, 2, 1, 2, 1, 2, 2, 0, 0, 113, 112, 0, 0, 0, 0, 126, 144, 1, 4, 0, 0, 112, 128, 0, 8, 0, 0, 126, 144, 0, 4, 0, 0, 112, 128, 0, 8, 76, 77, 84, 0, 43, 48, 57, 0, 43, 48, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 56, 62, 45, 56, 10}, - - "zoneinfo/Asia/Muscat": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 161, 242, 153, 168, 127, 255, 255, 255, 0, 1, 1, 0, 0, 51, 216, 0, 0, 0, 0, 56, 64, 0, 4, 76, 77, 84, 0, 43, 48, 52, 0, 0, 0, 0, 0, 10, 60, 43, 48, 52, 62, 45, 52, 10}, - - "zoneinfo/Asia/Nicosia": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 5, 0, 0, 0, 13, 128, 0, 0, 0, 165, 119, 30, 184, 9, 237, 175, 224, 10, 221, 146, 208, 11, 250, 100, 224, 12, 190, 198, 80, 13, 164, 57, 96, 14, 138, 225, 208, 15, 132, 27, 96, 16, 117, 79, 208, 17, 99, 253, 96, 18, 83, 224, 80, 19, 77, 25, 224, 20, 51, 194, 80, 21, 35, 193, 96, 22, 19, 164, 80, 23, 3, 163, 96, 23, 243, 134, 80, 24, 227, 133, 96, 25, 211, 104, 80, 26, 195, 103, 96, 27, 188, 132, 208, 28, 172, 131, 224, 29, 156, 102, 208, 30, 140, 101, 224, 31, 124, 72, 208, 32, 108, 71, 224, 33, 92, 42, 208, 34, 76, 41, 224, 35, 60, 12, 208, 36, 44, 11, 224, 37, 27, 238, 208, 38, 11, 237, 224, 39, 5, 11, 80, 39, 245, 10, 96, 40, 228, 237, 80, 41, 212, 236, 96, 42, 196, 207, 80, 43, 180, 206, 96, 44, 164, 177, 80, 45, 148, 176, 96, 46, 132, 147, 80, 47, 116, 146, 96, 48, 100, 117, 80, 49, 93, 174, 224, 50, 77, 145, 208, 51, 61, 144, 224, 52, 45, 115, 208, 53, 29, 114, 224, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 31, 72, 0, 0, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 9, 0, 0, 28, 32, 0, 9, 0, 0, 42, 48, 1, 4, 76, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 51, 44, 77, 49, 48, 46, 53, 46, 48, 47, 52, 10}, - - "zoneinfo/Asia/Novokuznetsk": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 66, 0, 0, 0, 9, 0, 0, 0, 16, 128, 0, 0, 0, 170, 24, 32, 192, 181, 163, 225, 32, 21, 39, 111, 144, 22, 24, 164, 0, 23, 8, 163, 16, 23, 249, 215, 128, 24, 233, 214, 144, 25, 219, 11, 0, 26, 204, 91, 144, 27, 188, 104, 176, 28, 172, 89, 176, 29, 156, 74, 176, 30, 140, 59, 176, 31, 124, 44, 176, 32, 108, 29, 176, 33, 92, 14, 176, 34, 75, 255, 176, 35, 59, 240, 176, 36, 43, 225, 176, 37, 27, 210, 176, 38, 11, 195, 176, 39, 4, 239, 48, 39, 244, 224, 48, 40, 228, 223, 64, 41, 120, 135, 64, 41, 212, 194, 48, 42, 196, 179, 48, 43, 180, 164, 48, 44, 164, 149, 48, 45, 148, 134, 48, 46, 132, 119, 48, 47, 116, 104, 48, 48, 100, 89, 48, 49, 93, 132, 176, 50, 114, 95, 176, 51, 61, 102, 176, 52, 82, 65, 176, 53, 29, 72, 176, 54, 50, 35, 176, 54, 253, 42, 176, 56, 27, 64, 48, 56, 221, 12, 176, 57, 251, 34, 48, 58, 188, 238, 176, 59, 219, 4, 48, 60, 166, 11, 48, 61, 186, 230, 48, 62, 133, 237, 48, 63, 154, 200, 48, 64, 101, 207, 48, 65, 131, 228, 176, 66, 69, 177, 48, 67, 99, 198, 176, 68, 37, 147, 48, 69, 67, 168, 176, 70, 5, 117, 48, 71, 35, 138, 176, 71, 238, 145, 176, 73, 3, 108, 176, 73, 206, 115, 176, 74, 227, 78, 176, 75, 174, 85, 176, 76, 204, 121, 64, 77, 142, 69, 192, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 4, 0, 0, 81, 192, 0, 0, 0, 0, 84, 96, 0, 4, 0, 0, 112, 128, 1, 8, 0, 0, 98, 112, 0, 12, 0, 0, 98, 112, 0, 12, 0, 0, 112, 128, 1, 8, 0, 0, 98, 112, 1, 12, 0, 0, 84, 96, 0, 4, 0, 0, 98, 112, 0, 12, 76, 77, 84, 0, 43, 48, 54, 0, 43, 48, 56, 0, 43, 48, 55, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 55, 62, 45, 55, 10}, - - "zoneinfo/Asia/Novosibirsk": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 69, 0, 0, 0, 10, 0, 0, 0, 16, 128, 0, 0, 0, 161, 219, 25, 36, 181, 163, 225, 32, 21, 39, 111, 144, 22, 24, 164, 0, 23, 8, 163, 16, 23, 249, 215, 128, 24, 233, 214, 144, 25, 219, 11, 0, 26, 204, 91, 144, 27, 188, 104, 176, 28, 172, 89, 176, 29, 156, 74, 176, 30, 140, 59, 176, 31, 124, 44, 176, 32, 108, 29, 176, 33, 92, 14, 176, 34, 75, 255, 176, 35, 59, 240, 176, 36, 43, 225, 176, 37, 27, 210, 176, 38, 11, 195, 176, 39, 4, 239, 48, 39, 244, 224, 48, 40, 228, 223, 64, 41, 120, 135, 64, 41, 212, 194, 48, 42, 196, 179, 48, 43, 180, 164, 48, 43, 254, 78, 0, 44, 164, 163, 64, 45, 148, 148, 64, 46, 132, 133, 64, 47, 116, 118, 64, 48, 100, 103, 64, 49, 93, 146, 192, 50, 114, 109, 192, 51, 61, 116, 192, 52, 82, 79, 192, 53, 29, 86, 192, 54, 50, 49, 192, 54, 253, 56, 192, 56, 27, 78, 64, 56, 221, 26, 192, 57, 251, 48, 64, 58, 188, 252, 192, 59, 219, 18, 64, 60, 166, 25, 64, 61, 186, 244, 64, 62, 133, 251, 64, 63, 154, 214, 64, 64, 101, 221, 64, 65, 131, 242, 192, 66, 69, 191, 64, 67, 99, 212, 192, 68, 37, 161, 64, 69, 67, 182, 192, 70, 5, 131, 64, 71, 35, 152, 192, 71, 238, 159, 192, 73, 3, 122, 192, 73, 206, 129, 192, 74, 227, 92, 192, 75, 174, 99, 192, 76, 204, 121, 64, 77, 142, 69, 192, 84, 75, 243, 48, 87, 147, 204, 192, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 5, 4, 5, 8, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 4, 7, 4, 4, 0, 0, 77, 188, 0, 0, 0, 0, 84, 96, 0, 4, 0, 0, 112, 128, 1, 8, 0, 0, 98, 112, 0, 12, 0, 0, 98, 112, 0, 12, 0, 0, 112, 128, 1, 8, 0, 0, 98, 112, 1, 12, 0, 0, 84, 96, 0, 4, 0, 0, 98, 112, 1, 12, 0, 0, 98, 112, 0, 12, 76, 77, 84, 0, 43, 48, 54, 0, 43, 48, 56, 0, 43, 48, 55, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 55, 62, 45, 55, 10}, - - "zoneinfo/Asia/Omsk": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 11, 0, 0, 0, 16, 128, 0, 0, 0, 161, 179, 64, 182, 181, 163, 239, 48, 21, 39, 125, 160, 22, 24, 178, 16, 23, 8, 177, 32, 23, 249, 229, 144, 24, 233, 228, 160, 25, 219, 25, 16, 26, 204, 105, 160, 27, 188, 118, 192, 28, 172, 103, 192, 29, 156, 88, 192, 30, 140, 73, 192, 31, 124, 58, 192, 32, 108, 43, 192, 33, 92, 28, 192, 34, 76, 13, 192, 35, 59, 254, 192, 36, 43, 239, 192, 37, 27, 224, 192, 38, 11, 209, 192, 39, 4, 253, 64, 39, 244, 238, 64, 40, 228, 237, 80, 41, 120, 149, 80, 41, 212, 208, 64, 42, 196, 193, 64, 43, 180, 178, 64, 44, 164, 163, 64, 45, 148, 148, 64, 46, 132, 133, 64, 47, 116, 118, 64, 48, 100, 103, 64, 49, 93, 146, 192, 50, 114, 109, 192, 51, 61, 116, 192, 52, 82, 79, 192, 53, 29, 86, 192, 54, 50, 49, 192, 54, 253, 56, 192, 56, 27, 78, 64, 56, 221, 26, 192, 57, 251, 48, 64, 58, 188, 252, 192, 59, 219, 18, 64, 60, 166, 25, 64, 61, 186, 244, 64, 62, 133, 251, 64, 63, 154, 214, 64, 64, 101, 221, 64, 65, 131, 242, 192, 66, 69, 191, 64, 67, 99, 212, 192, 68, 37, 161, 64, 69, 67, 182, 192, 70, 5, 131, 64, 71, 35, 152, 192, 71, 238, 159, 192, 73, 3, 122, 192, 73, 206, 129, 192, 74, 227, 92, 192, 75, 174, 99, 192, 76, 204, 121, 64, 77, 142, 69, 192, 84, 75, 243, 48, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 8, 4, 4, 0, 0, 68, 202, 0, 0, 0, 0, 70, 80, 0, 4, 0, 0, 98, 112, 1, 8, 0, 0, 84, 96, 0, 12, 0, 0, 84, 96, 0, 12, 0, 0, 98, 112, 1, 8, 0, 0, 84, 96, 1, 12, 0, 0, 70, 80, 0, 4, 0, 0, 98, 112, 0, 8, 0, 0, 98, 112, 1, 8, 0, 0, 84, 96, 0, 12, 76, 77, 84, 0, 43, 48, 53, 0, 43, 48, 55, 0, 43, 48, 54, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 54, 62, 45, 54, 10}, - - "zoneinfo/Asia/Oral": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 53, 0, 0, 0, 10, 0, 0, 0, 20, 128, 0, 0, 0, 170, 25, 147, 220, 181, 164, 11, 80, 21, 39, 139, 176, 22, 24, 192, 32, 23, 8, 177, 32, 23, 249, 243, 160, 24, 233, 242, 176, 25, 219, 39, 32, 26, 204, 119, 176, 27, 188, 132, 208, 28, 172, 117, 208, 29, 156, 102, 208, 30, 140, 87, 208, 31, 124, 72, 208, 32, 108, 57, 208, 33, 92, 42, 208, 34, 76, 27, 208, 35, 60, 12, 208, 36, 43, 253, 208, 37, 27, 252, 224, 38, 11, 237, 224, 39, 5, 25, 96, 39, 245, 10, 96, 40, 228, 251, 96, 41, 120, 163, 96, 41, 212, 222, 80, 42, 196, 221, 96, 43, 180, 206, 96, 44, 164, 191, 96, 45, 148, 176, 96, 46, 132, 161, 96, 47, 116, 146, 96, 48, 100, 131, 96, 49, 93, 174, 224, 50, 114, 137, 224, 51, 61, 144, 224, 52, 82, 107, 224, 53, 29, 114, 224, 54, 50, 77, 224, 54, 253, 84, 224, 56, 27, 106, 96, 56, 221, 54, 224, 57, 251, 76, 96, 58, 189, 24, 224, 59, 219, 46, 96, 60, 166, 53, 96, 61, 187, 16, 96, 62, 134, 23, 96, 63, 154, 242, 96, 64, 101, 249, 96, 65, 132, 14, 224, 127, 255, 255, 255, 0, 1, 2, 3, 4, 3, 2, 3, 2, 3, 5, 6, 5, 6, 5, 6, 5, 6, 5, 7, 8, 7, 8, 7, 8, 5, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 5, 5, 0, 0, 48, 36, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 70, 80, 0, 8, 0, 0, 84, 96, 1, 12, 0, 0, 84, 96, 0, 12, 0, 0, 70, 80, 0, 8, 0, 0, 84, 96, 1, 12, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 0, 16, 0, 0, 70, 80, 0, 8, 76, 77, 84, 0, 43, 48, 51, 0, 43, 48, 53, 0, 43, 48, 54, 0, 43, 48, 52, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 53, 62, 45, 53, 10}, - - "zoneinfo/Asia/Phnom_Penh": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 162, 106, 103, 196, 127, 255, 255, 255, 1, 2, 2, 0, 0, 94, 60, 0, 0, 0, 0, 94, 60, 0, 4, 0, 0, 98, 112, 0, 8, 76, 77, 84, 0, 66, 77, 84, 0, 43, 48, 55, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 55, 62, 45, 55, 10}, - - "zoneinfo/Asia/Pontianak": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 7, 0, 0, 0, 31, 128, 0, 0, 0, 139, 255, 142, 0, 186, 22, 223, 0, 203, 121, 164, 8, 210, 86, 238, 112, 215, 60, 198, 8, 218, 255, 38, 0, 244, 181, 190, 136, 33, 218, 116, 128, 0, 1, 2, 3, 2, 4, 2, 5, 6, 0, 0, 102, 128, 0, 0, 0, 0, 102, 128, 0, 4, 0, 0, 105, 120, 0, 8, 0, 0, 126, 144, 0, 14, 0, 0, 112, 128, 0, 18, 0, 0, 112, 128, 0, 22, 0, 0, 98, 112, 0, 27, 76, 77, 84, 0, 80, 77, 84, 0, 43, 48, 55, 51, 48, 0, 43, 48, 57, 0, 43, 48, 56, 0, 87, 73, 84, 65, 0, 87, 73, 66, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 87, 73, 66, 45, 55, 10}, - - "zoneinfo/Asia/Pyongyang": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 12, 128, 0, 0, 0, 139, 215, 241, 156, 146, 230, 22, 248, 210, 47, 97, 112, 85, 206, 2, 112, 0, 1, 2, 3, 1, 0, 0, 117, 228, 0, 0, 0, 0, 119, 136, 0, 4, 0, 0, 126, 144, 0, 8, 0, 0, 126, 144, 0, 4, 0, 0, 119, 136, 0, 4, 76, 77, 84, 0, 75, 83, 84, 0, 74, 83, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 75, 83, 84, 45, 56, 58, 51, 48, 10}, - - "zoneinfo/Asia/Qatar": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 161, 242, 157, 48, 4, 138, 146, 192, 127, 255, 255, 255, 0, 1, 2, 2, 0, 0, 48, 80, 0, 0, 0, 0, 56, 64, 0, 4, 0, 0, 42, 48, 0, 8, 76, 77, 84, 0, 43, 48, 52, 0, 43, 48, 51, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 51, 62, 45, 51, 10}, - - "zoneinfo/Asia/Qyzylorda": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 53, 0, 0, 0, 11, 0, 0, 0, 16, 128, 0, 0, 0, 170, 25, 134, 160, 181, 163, 253, 64, 21, 39, 139, 176, 22, 24, 192, 32, 23, 8, 177, 32, 23, 249, 243, 160, 24, 233, 242, 176, 25, 219, 39, 32, 26, 204, 119, 176, 27, 188, 132, 208, 28, 172, 117, 208, 29, 156, 102, 208, 30, 140, 87, 208, 31, 124, 72, 208, 32, 108, 57, 208, 33, 92, 42, 208, 34, 76, 27, 208, 35, 60, 12, 208, 36, 43, 253, 208, 37, 27, 238, 208, 38, 11, 223, 208, 39, 5, 11, 80, 39, 244, 252, 80, 40, 228, 251, 96, 41, 120, 149, 80, 41, 212, 208, 64, 42, 196, 207, 80, 43, 180, 192, 80, 44, 164, 177, 80, 45, 148, 162, 80, 46, 132, 147, 80, 47, 116, 132, 80, 48, 100, 117, 80, 49, 93, 160, 208, 50, 114, 123, 208, 51, 61, 130, 208, 52, 82, 93, 208, 53, 29, 100, 208, 54, 50, 63, 208, 54, 253, 70, 208, 56, 27, 92, 80, 56, 221, 40, 208, 57, 251, 62, 80, 58, 189, 10, 208, 59, 219, 32, 80, 60, 166, 39, 80, 61, 187, 2, 80, 62, 134, 9, 80, 63, 154, 228, 80, 64, 101, 235, 80, 65, 132, 0, 208, 127, 255, 255, 255, 0, 1, 2, 3, 4, 3, 2, 3, 2, 3, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 7, 5, 9, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 9, 9, 0, 0, 61, 96, 0, 0, 0, 0, 56, 64, 0, 4, 0, 0, 70, 80, 0, 8, 0, 0, 84, 96, 1, 12, 0, 0, 84, 96, 0, 12, 0, 0, 70, 80, 0, 8, 0, 0, 84, 96, 1, 12, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 0, 4, 0, 0, 84, 96, 0, 12, 0, 0, 84, 96, 1, 12, 76, 77, 84, 0, 43, 48, 52, 0, 43, 48, 53, 0, 43, 48, 54, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 54, 62, 45, 54, 10}, - - "zoneinfo/Asia/Rangoon": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 18, 128, 0, 0, 0, 161, 242, 115, 81, 203, 242, 252, 24, 209, 154, 103, 240, 127, 255, 255, 255, 1, 2, 3, 2, 2, 0, 0, 90, 47, 0, 0, 0, 0, 90, 47, 0, 4, 0, 0, 91, 104, 0, 8, 0, 0, 126, 144, 0, 14, 0, 0, 91, 104, 0, 8, 76, 77, 84, 0, 82, 77, 84, 0, 43, 48, 54, 51, 48, 0, 43, 48, 57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 54, 51, 48, 62, 45, 54, 58, 51, 48, 10}, - - "zoneinfo/Asia/Riyadh": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 213, 27, 54, 180, 127, 255, 255, 255, 0, 1, 1, 0, 0, 43, 204, 0, 0, 0, 0, 42, 48, 0, 4, 76, 77, 84, 0, 43, 48, 51, 0, 0, 0, 0, 0, 10, 60, 43, 48, 51, 62, 45, 51, 10}, - - "zoneinfo/Asia/Saigon": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 6, 0, 0, 0, 21, 128, 0, 0, 0, 136, 140, 67, 128, 145, 163, 43, 10, 205, 53, 230, 128, 209, 89, 206, 112, 210, 59, 62, 240, 213, 50, 187, 16, 228, 182, 228, 128, 237, 47, 152, 0, 10, 61, 199, 0, 127, 255, 255, 255, 0, 1, 2, 3, 4, 2, 3, 2, 3, 2, 2, 0, 0, 100, 0, 0, 0, 0, 0, 99, 246, 0, 4, 0, 0, 98, 112, 0, 9, 0, 0, 112, 128, 0, 13, 0, 0, 126, 144, 0, 17, 0, 0, 98, 112, 0, 9, 76, 77, 84, 0, 80, 76, 77, 84, 0, 43, 48, 55, 0, 43, 48, 56, 0, 43, 48, 57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 55, 62, 45, 55, 10}, - - "zoneinfo/Asia/Sakhalin": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 9, 0, 0, 0, 20, 128, 0, 0, 0, 134, 240, 205, 184, 210, 48, 178, 240, 21, 39, 55, 80, 22, 24, 107, 192, 23, 8, 106, 208, 23, 249, 159, 64, 24, 233, 158, 80, 25, 218, 210, 192, 26, 204, 35, 80, 27, 188, 48, 112, 28, 172, 33, 112, 29, 156, 18, 112, 30, 140, 3, 112, 31, 123, 244, 112, 32, 107, 229, 112, 33, 91, 214, 112, 34, 75, 199, 112, 35, 59, 184, 112, 36, 43, 169, 112, 37, 27, 154, 112, 38, 11, 139, 112, 39, 4, 182, 240, 39, 244, 167, 240, 40, 228, 167, 0, 41, 120, 79, 0, 41, 212, 137, 240, 42, 196, 122, 240, 43, 180, 107, 240, 44, 164, 92, 240, 45, 148, 77, 240, 46, 132, 62, 240, 47, 116, 47, 240, 48, 100, 32, 240, 49, 93, 76, 112, 50, 114, 39, 112, 51, 61, 46, 112, 52, 82, 23, 128, 53, 29, 30, 128, 54, 49, 249, 128, 54, 253, 0, 128, 56, 27, 22, 0, 56, 220, 226, 128, 57, 250, 248, 0, 58, 188, 196, 128, 59, 218, 218, 0, 60, 165, 225, 0, 61, 186, 188, 0, 62, 133, 195, 0, 63, 154, 158, 0, 64, 101, 165, 0, 65, 131, 186, 128, 66, 69, 135, 0, 67, 99, 156, 128, 68, 37, 105, 0, 69, 67, 126, 128, 70, 5, 75, 0, 71, 35, 96, 128, 71, 238, 103, 128, 73, 3, 66, 128, 73, 206, 73, 128, 74, 227, 36, 128, 75, 174, 43, 128, 76, 204, 65, 0, 77, 142, 13, 128, 84, 75, 186, 240, 86, 246, 178, 0, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 4, 7, 4, 4, 0, 0, 133, 200, 0, 0, 0, 0, 126, 144, 0, 4, 0, 0, 168, 192, 1, 8, 0, 0, 154, 176, 0, 12, 0, 0, 154, 176, 0, 12, 0, 0, 168, 192, 1, 8, 0, 0, 154, 176, 1, 12, 0, 0, 140, 160, 0, 16, 0, 0, 154, 176, 0, 12, 76, 77, 84, 0, 43, 48, 57, 0, 43, 49, 50, 0, 43, 49, 49, 0, 43, 49, 48, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 49, 62, 45, 49, 49, 10}, - - "zoneinfo/Asia/Samarkand": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 27, 0, 0, 0, 7, 0, 0, 0, 16, 128, 0, 0, 0, 170, 25, 133, 55, 181, 163, 253, 64, 21, 39, 139, 176, 22, 24, 192, 32, 23, 8, 177, 32, 23, 249, 243, 160, 24, 233, 242, 176, 25, 219, 39, 32, 26, 204, 119, 176, 27, 188, 132, 208, 28, 172, 117, 208, 29, 156, 102, 208, 30, 140, 87, 208, 31, 124, 72, 208, 32, 108, 57, 208, 33, 92, 42, 208, 34, 76, 27, 208, 35, 60, 12, 208, 36, 43, 253, 208, 37, 27, 238, 208, 38, 11, 223, 208, 39, 5, 11, 80, 39, 244, 252, 80, 40, 228, 237, 80, 41, 96, 190, 48, 127, 255, 255, 255, 0, 1, 2, 3, 4, 3, 2, 3, 2, 3, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 2, 2, 0, 0, 62, 201, 0, 0, 0, 0, 56, 64, 0, 4, 0, 0, 70, 80, 0, 8, 0, 0, 84, 96, 1, 12, 0, 0, 84, 96, 0, 12, 0, 0, 70, 80, 0, 8, 0, 0, 84, 96, 1, 12, 76, 77, 84, 0, 43, 48, 52, 0, 43, 48, 53, 0, 43, 48, 54, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 53, 62, 45, 53, 10}, - - "zoneinfo/Asia/Seoul": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 6, 0, 0, 0, 16, 128, 0, 0, 0, 139, 215, 240, 120, 146, 230, 22, 248, 210, 67, 39, 240, 226, 79, 41, 240, 228, 107, 183, 248, 229, 19, 24, 104, 230, 98, 3, 120, 231, 17, 76, 232, 232, 47, 112, 120, 232, 231, 244, 104, 234, 15, 82, 120, 234, 199, 214, 104, 235, 239, 52, 120, 236, 167, 184, 104, 237, 207, 22, 120, 238, 135, 154, 104, 240, 53, 113, 120, 32, 163, 96, 144, 33, 110, 103, 144, 34, 131, 66, 144, 35, 78, 73, 144, 0, 1, 2, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 3, 5, 3, 5, 3, 0, 0, 119, 8, 0, 0, 0, 0, 119, 136, 0, 4, 0, 0, 126, 144, 0, 8, 0, 0, 126, 144, 0, 4, 0, 0, 133, 152, 1, 12, 0, 0, 140, 160, 1, 12, 76, 77, 84, 0, 75, 83, 84, 0, 74, 83, 84, 0, 75, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 75, 83, 84, 45, 57, 10}, - - "zoneinfo/Asia/Shanghai": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 200, 92, 1, 128, 200, 250, 39, 112, 201, 213, 14, 128, 202, 219, 90, 240, 30, 186, 54, 0, 31, 105, 127, 112, 32, 126, 104, 128, 33, 73, 97, 112, 34, 94, 74, 128, 35, 41, 67, 112, 36, 71, 103, 0, 37, 18, 95, 240, 38, 39, 73, 0, 38, 242, 65, 240, 40, 7, 43, 0, 40, 210, 35, 240, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 113, 215, 0, 0, 0, 0, 126, 144, 1, 4, 0, 0, 112, 128, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 45, 56, 10}, - - "zoneinfo/Asia/Singapore": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 8, 0, 0, 0, 32, 128, 0, 0, 0, 134, 131, 133, 163, 186, 103, 78, 144, 192, 10, 228, 96, 202, 179, 229, 96, 203, 145, 95, 8, 210, 72, 109, 240, 22, 145, 245, 8, 127, 255, 255, 255, 1, 2, 3, 4, 5, 6, 5, 7, 7, 0, 0, 97, 93, 0, 0, 0, 0, 97, 93, 0, 4, 0, 0, 98, 112, 0, 8, 0, 0, 103, 32, 1, 12, 0, 0, 103, 32, 0, 12, 0, 0, 105, 120, 0, 18, 0, 0, 126, 144, 0, 24, 0, 0, 112, 128, 0, 28, 76, 77, 84, 0, 83, 77, 84, 0, 43, 48, 55, 0, 43, 48, 55, 50, 48, 0, 43, 48, 55, 51, 48, 0, 43, 48, 57, 0, 43, 48, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 56, 62, 45, 56, 10}, - - "zoneinfo/Asia/Srednekolymsk": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 11, 0, 0, 0, 16, 128, 0, 0, 0, 170, 25, 51, 228, 181, 163, 168, 224, 21, 39, 55, 80, 22, 24, 107, 192, 23, 8, 106, 208, 23, 249, 159, 64, 24, 233, 158, 80, 25, 218, 210, 192, 26, 204, 35, 80, 27, 188, 48, 112, 28, 172, 33, 112, 29, 156, 18, 112, 30, 140, 3, 112, 31, 123, 244, 112, 32, 107, 229, 112, 33, 91, 214, 112, 34, 75, 199, 112, 35, 59, 184, 112, 36, 43, 169, 112, 37, 27, 154, 112, 38, 11, 139, 112, 39, 4, 182, 240, 39, 244, 167, 240, 40, 228, 167, 0, 41, 120, 79, 0, 41, 212, 137, 240, 42, 196, 122, 240, 43, 180, 107, 240, 44, 164, 92, 240, 45, 148, 77, 240, 46, 132, 62, 240, 47, 116, 47, 240, 48, 100, 32, 240, 49, 93, 76, 112, 50, 114, 39, 112, 51, 61, 46, 112, 52, 82, 9, 112, 53, 29, 16, 112, 54, 49, 235, 112, 54, 252, 242, 112, 56, 27, 7, 240, 56, 220, 212, 112, 57, 250, 233, 240, 58, 188, 182, 112, 59, 218, 203, 240, 60, 165, 210, 240, 61, 186, 173, 240, 62, 133, 180, 240, 63, 154, 143, 240, 64, 101, 150, 240, 65, 131, 172, 112, 66, 69, 120, 240, 67, 99, 142, 112, 68, 37, 90, 240, 69, 67, 112, 112, 70, 5, 60, 240, 71, 35, 82, 112, 71, 238, 89, 112, 73, 3, 52, 112, 73, 206, 59, 112, 74, 227, 22, 112, 75, 174, 29, 112, 76, 204, 50, 240, 77, 141, 255, 112, 84, 75, 172, 224, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 8, 4, 4, 0, 0, 144, 28, 0, 0, 0, 0, 140, 160, 0, 4, 0, 0, 168, 192, 1, 8, 0, 0, 154, 176, 0, 12, 0, 0, 154, 176, 0, 12, 0, 0, 168, 192, 1, 8, 0, 0, 154, 176, 1, 12, 0, 0, 140, 160, 0, 4, 0, 0, 168, 192, 0, 8, 0, 0, 168, 192, 1, 8, 0, 0, 154, 176, 0, 12, 76, 77, 84, 0, 43, 49, 48, 0, 43, 49, 50, 0, 43, 49, 49, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 49, 62, 45, 49, 49, 10}, - - "zoneinfo/Asia/Taipei": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 5, 0, 0, 0, 16, 128, 0, 0, 0, 195, 85, 73, 128, 210, 84, 89, 128, 211, 139, 123, 128, 212, 66, 173, 240, 213, 69, 34, 0, 214, 76, 191, 240, 215, 60, 191, 0, 216, 6, 102, 112, 217, 29, 242, 128, 217, 231, 153, 240, 218, 255, 38, 0, 219, 200, 205, 112, 220, 224, 89, 128, 221, 170, 0, 240, 222, 114, 115, 0, 223, 181, 100, 112, 224, 124, 133, 0, 225, 150, 151, 240, 226, 93, 184, 128, 227, 119, 203, 112, 228, 62, 236, 0, 229, 48, 32, 112, 230, 33, 113, 0, 231, 18, 165, 112, 232, 2, 164, 128, 232, 243, 216, 240, 233, 227, 216, 0, 234, 213, 12, 112, 235, 197, 11, 128, 236, 182, 63, 240, 237, 247, 252, 0, 238, 152, 196, 240, 239, 217, 47, 128, 240, 121, 248, 112, 7, 252, 86, 0, 8, 237, 138, 112, 9, 221, 137, 128, 10, 206, 189, 240, 17, 219, 161, 128, 18, 84, 221, 112, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 0, 0, 113, 232, 0, 0, 0, 0, 112, 128, 0, 4, 0, 0, 126, 144, 0, 8, 0, 0, 126, 144, 1, 12, 0, 0, 112, 128, 0, 4, 76, 77, 84, 0, 67, 83, 84, 0, 74, 83, 84, 0, 67, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 45, 56, 10}, - - "zoneinfo/Asia/Tashkent": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 27, 0, 0, 0, 8, 0, 0, 0, 16, 128, 0, 0, 0, 170, 25, 131, 9, 181, 163, 239, 48, 21, 39, 125, 160, 22, 24, 178, 16, 23, 8, 177, 32, 23, 249, 229, 144, 24, 233, 228, 160, 25, 219, 25, 16, 26, 204, 105, 160, 27, 188, 118, 192, 28, 172, 103, 192, 29, 156, 88, 192, 30, 140, 73, 192, 31, 124, 58, 192, 32, 108, 43, 192, 33, 92, 28, 192, 34, 76, 13, 192, 35, 59, 254, 192, 36, 43, 239, 192, 37, 27, 224, 192, 38, 11, 209, 192, 39, 4, 253, 64, 39, 244, 238, 64, 40, 228, 237, 80, 41, 96, 190, 48, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 1, 1, 0, 0, 64, 247, 0, 0, 0, 0, 70, 80, 0, 4, 0, 0, 98, 112, 1, 8, 0, 0, 84, 96, 0, 12, 0, 0, 84, 96, 0, 12, 0, 0, 98, 112, 1, 8, 0, 0, 84, 96, 1, 12, 0, 0, 70, 80, 0, 4, 76, 77, 84, 0, 43, 48, 53, 0, 43, 48, 55, 0, 43, 48, 54, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 53, 62, 45, 53, 10}, - - "zoneinfo/Asia/Tbilisi": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 0, 11, 0, 0, 0, 21, 128, 0, 0, 0, 170, 25, 154, 1, 231, 218, 12, 80, 21, 39, 153, 192, 22, 24, 206, 48, 23, 8, 205, 64, 23, 250, 1, 176, 24, 234, 0, 192, 25, 219, 53, 48, 26, 204, 133, 192, 27, 188, 146, 224, 28, 172, 131, 224, 29, 156, 116, 224, 30, 140, 101, 224, 31, 124, 86, 224, 32, 108, 71, 224, 33, 92, 56, 224, 34, 76, 41, 224, 35, 60, 26, 224, 36, 44, 11, 224, 37, 27, 252, 224, 38, 11, 237, 224, 39, 5, 25, 96, 39, 245, 10, 96, 40, 229, 9, 112, 41, 96, 218, 80, 41, 212, 222, 80, 42, 196, 193, 64, 43, 180, 192, 80, 44, 164, 163, 64, 45, 148, 162, 80, 46, 132, 133, 64, 47, 116, 118, 64, 48, 100, 89, 48, 49, 93, 146, 192, 51, 61, 102, 176, 52, 82, 65, 176, 53, 29, 86, 192, 54, 50, 35, 176, 54, 253, 56, 192, 56, 27, 64, 48, 56, 221, 26, 192, 57, 251, 34, 48, 58, 188, 252, 192, 59, 219, 4, 48, 60, 166, 25, 64, 61, 186, 230, 48, 62, 133, 251, 64, 63, 154, 200, 48, 64, 101, 221, 64, 64, 221, 199, 176, 65, 132, 28, 240, 66, 69, 233, 112, 127, 255, 255, 255, 1, 2, 4, 3, 4, 3, 4, 3, 4, 3, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 7, 8, 2, 9, 2, 9, 2, 9, 4, 3, 4, 3, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 9, 8, 4, 4, 0, 0, 41, 255, 0, 0, 0, 0, 41, 255, 0, 4, 0, 0, 42, 48, 0, 9, 0, 0, 70, 80, 1, 13, 0, 0, 56, 64, 0, 17, 0, 0, 56, 64, 0, 17, 0, 0, 70, 80, 1, 13, 0, 0, 56, 64, 1, 17, 0, 0, 42, 48, 0, 9, 0, 0, 56, 64, 1, 17, 0, 0, 56, 64, 0, 17, 76, 77, 84, 0, 84, 66, 77, 84, 0, 43, 48, 51, 0, 43, 48, 53, 0, 43, 48, 52, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 52, 62, 45, 52, 10}, - - "zoneinfo/Asia/Tehran": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 102, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 154, 108, 125, 200, 210, 219, 18, 200, 14, 187, 162, 72, 15, 116, 45, 64, 16, 142, 64, 48, 16, 237, 58, 64, 17, 85, 103, 200, 18, 69, 74, 184, 19, 55, 236, 200, 20, 45, 21, 184, 40, 32, 118, 200, 40, 219, 157, 184, 41, 203, 156, 200, 42, 190, 34, 184, 43, 172, 208, 72, 44, 159, 86, 56, 45, 142, 3, 200, 46, 128, 137, 184, 47, 111, 55, 72, 48, 97, 189, 56, 49, 80, 106, 200, 50, 66, 240, 184, 51, 50, 239, 200, 52, 37, 117, 184, 53, 20, 35, 72, 54, 6, 169, 56, 54, 245, 86, 200, 55, 231, 220, 184, 56, 214, 138, 72, 57, 201, 16, 56, 58, 185, 15, 72, 59, 171, 149, 56, 60, 154, 66, 200, 61, 140, 200, 184, 62, 123, 118, 72, 63, 109, 252, 56, 64, 92, 169, 200, 65, 79, 47, 184, 66, 63, 46, 200, 67, 49, 180, 184, 71, 226, 201, 72, 72, 213, 79, 56, 73, 197, 78, 72, 74, 183, 212, 56, 75, 166, 129, 200, 76, 153, 7, 184, 77, 135, 181, 72, 78, 122, 59, 56, 79, 104, 232, 200, 80, 91, 110, 184, 81, 75, 109, 200, 82, 61, 243, 184, 83, 44, 161, 72, 84, 31, 39, 56, 85, 13, 212, 200, 86, 0, 90, 184, 86, 239, 8, 72, 87, 225, 142, 56, 88, 209, 141, 72, 89, 196, 19, 56, 90, 178, 192, 200, 91, 165, 70, 184, 92, 147, 244, 72, 93, 134, 122, 56, 94, 117, 39, 200, 95, 103, 173, 184, 96, 87, 172, 200, 97, 74, 50, 184, 98, 56, 224, 72, 99, 43, 102, 56, 100, 26, 19, 200, 101, 12, 153, 184, 101, 251, 71, 72, 102, 237, 205, 56, 103, 221, 204, 72, 104, 208, 82, 56, 105, 190, 255, 200, 106, 177, 133, 184, 107, 160, 51, 72, 108, 146, 185, 56, 109, 129, 102, 200, 110, 115, 236, 184, 111, 98, 154, 72, 112, 85, 32, 56, 113, 69, 31, 72, 114, 55, 165, 56, 115, 38, 82, 200, 116, 24, 216, 184, 117, 7, 134, 72, 117, 250, 12, 56, 118, 232, 185, 200, 119, 219, 63, 184, 120, 203, 62, 200, 121, 189, 196, 184, 122, 172, 114, 72, 123, 158, 248, 56, 124, 141, 165, 200, 125, 128, 43, 184, 126, 110, 217, 72, 127, 97, 95, 56, 127, 255, 255, 255, 0, 1, 2, 4, 3, 4, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 2, 0, 0, 48, 56, 0, 0, 0, 0, 48, 56, 0, 4, 0, 0, 49, 56, 0, 8, 0, 0, 70, 80, 1, 14, 0, 0, 56, 64, 0, 18, 0, 0, 63, 72, 1, 22, 0, 0, 49, 56, 0, 8, 76, 77, 84, 0, 84, 77, 84, 0, 43, 48, 51, 51, 48, 0, 43, 48, 53, 0, 43, 48, 52, 0, 43, 48, 52, 51, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 51, 51, 48, 62, 45, 51, 58, 51, 48, 60, 43, 48, 52, 51, 48, 62, 44, 74, 56, 48, 47, 48, 44, 74, 50, 54, 52, 47, 48, 10}, - - "zoneinfo/Asia/Tel_Aviv": []byte{84, 90, 105, 102, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 143, 0, 0, 0, 6, 0, 0, 0, 21, 128, 0, 0, 0, 158, 48, 69, 136, 200, 89, 178, 224, 204, 229, 193, 80, 205, 172, 254, 0, 206, 198, 244, 208, 207, 143, 102, 224, 208, 169, 121, 208, 209, 132, 96, 224, 210, 138, 201, 112, 211, 101, 176, 128, 212, 107, 224, 208, 215, 90, 20, 96, 215, 223, 31, 192, 216, 47, 181, 112, 217, 30, 70, 224, 218, 16, 232, 240, 218, 235, 179, 224, 219, 180, 52, 0, 220, 185, 32, 224, 221, 224, 141, 0, 222, 180, 206, 128, 223, 164, 191, 128, 224, 139, 118, 0, 225, 86, 125, 0, 226, 190, 74, 96, 227, 54, 52, 208, 228, 156, 247, 0, 229, 22, 22, 208, 230, 116, 211, 224, 231, 17, 210, 128, 232, 39, 255, 0, 232, 232, 79, 208, 8, 124, 139, 224, 8, 253, 176, 208, 9, 246, 234, 96, 10, 166, 51, 208, 28, 190, 248, 224, 29, 137, 241, 208, 30, 204, 255, 96, 31, 96, 153, 80, 32, 130, 177, 96, 33, 73, 181, 208, 34, 94, 158, 224, 35, 32, 93, 80, 36, 90, 48, 96, 37, 0, 63, 80, 38, 11, 237, 224, 38, 214, 230, 208, 39, 235, 207, 224, 40, 192, 3, 80, 41, 212, 236, 96, 42, 169, 31, 208, 43, 187, 101, 224, 44, 137, 1, 208, 45, 155, 71, 224, 46, 95, 169, 80, 47, 123, 41, 224, 48, 72, 197, 208, 49, 72, 150, 224, 50, 60, 110, 80, 51, 49, 179, 96, 52, 26, 254, 208, 53, 17, 149, 96, 53, 241, 166, 80, 55, 4, 8, 128, 55, 207, 1, 112, 56, 246, 95, 128, 57, 220, 249, 224, 58, 208, 237, 112, 59, 174, 91, 96, 60, 163, 160, 112, 61, 160, 178, 96, 62, 131, 130, 112, 63, 124, 159, 224, 64, 115, 54, 112, 65, 80, 164, 96, 66, 76, 143, 0, 67, 72, 79, 112, 68, 44, 113, 0, 69, 30, 246, 240, 70, 12, 83, 0, 70, 236, 99, 240, 71, 236, 53, 0, 72, 231, 245, 112, 73, 204, 23, 0, 74, 190, 156, 240, 75, 171, 249, 0, 76, 140, 9, 240, 77, 149, 21, 128, 78, 135, 155, 112, 79, 116, 247, 128, 80, 94, 66, 240, 81, 84, 217, 128, 82, 108, 73, 112, 83, 52, 187, 128, 84, 76, 43, 112, 85, 20, 157, 128, 86, 44, 13, 112, 86, 244, 127, 128, 88, 21, 41, 240, 88, 212, 97, 128, 89, 245, 11, 240, 90, 180, 67, 128, 91, 212, 237, 240, 92, 157, 96, 0, 93, 180, 207, 240, 94, 125, 66, 0, 95, 148, 177, 240, 96, 93, 36, 0, 97, 125, 206, 112, 98, 61, 6, 0, 99, 93, 176, 112, 100, 28, 232, 0, 101, 61, 146, 112, 102, 6, 4, 128, 103, 29, 116, 112, 103, 229, 230, 128, 104, 253, 86, 112, 105, 197, 200, 128, 106, 221, 56, 112, 107, 165, 170, 128, 108, 198, 84, 240, 109, 133, 140, 128, 110, 166, 54, 240, 111, 101, 110, 128, 112, 134, 24, 240, 113, 78, 139, 0, 114, 101, 250, 240, 115, 46, 109, 0, 116, 69, 220, 240, 117, 14, 79, 0, 118, 46, 249, 112, 118, 238, 49, 0, 120, 14, 219, 112, 120, 206, 19, 0, 121, 238, 189, 112, 122, 173, 245, 0, 123, 206, 159, 112, 124, 151, 17, 128, 125, 174, 129, 112, 126, 118, 243, 128, 127, 142, 99, 112, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 4, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 0, 0, 33, 6, 0, 0, 0, 0, 32, 248, 0, 4, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 12, 0, 0, 56, 64, 1, 16, 0, 0, 42, 48, 1, 8, 76, 77, 84, 0, 74, 77, 84, 0, 73, 68, 84, 0, 73, 83, 84, 0, 73, 68, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 73, 83, 84, 45, 50, 73, 68, 84, 44, 77, 51, 46, 52, 46, 52, 47, 50, 54, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/Asia/Thimbu": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 3, 0, 0, 0, 14, 128, 0, 0, 0, 213, 230, 21, 116, 33, 97, 77, 168, 127, 255, 255, 255, 0, 1, 2, 2, 0, 0, 84, 12, 0, 0, 0, 0, 77, 88, 0, 4, 0, 0, 84, 96, 0, 10, 76, 77, 84, 0, 43, 48, 53, 51, 48, 0, 43, 48, 54, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 54, 62, 45, 54, 10}, - - "zoneinfo/Asia/Thimphu": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 3, 0, 0, 0, 14, 128, 0, 0, 0, 213, 230, 21, 116, 33, 97, 77, 168, 127, 255, 255, 255, 0, 1, 2, 2, 0, 0, 84, 12, 0, 0, 0, 0, 77, 88, 0, 4, 0, 0, 84, 96, 0, 10, 76, 77, 84, 0, 43, 48, 53, 51, 48, 0, 43, 48, 54, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 54, 62, 45, 54, 10}, - - "zoneinfo/Asia/Tokyo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 4, 0, 0, 0, 12, 128, 0, 0, 0, 215, 62, 30, 144, 215, 236, 22, 128, 216, 249, 22, 144, 217, 203, 248, 128, 219, 7, 29, 16, 219, 171, 218, 128, 220, 230, 255, 16, 221, 139, 188, 128, 3, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 131, 3, 0, 0, 0, 0, 140, 160, 1, 4, 0, 0, 126, 144, 0, 8, 0, 0, 126, 144, 0, 8, 76, 77, 84, 0, 74, 68, 84, 0, 74, 83, 84, 0, 0, 0, 0, 1, 0, 0, 0, 1, 10, 74, 83, 84, 45, 57, 10}, - - "zoneinfo/Asia/Tomsk": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 69, 0, 0, 0, 10, 0, 0, 0, 16, 128, 0, 0, 0, 161, 229, 78, 217, 181, 163, 225, 32, 21, 39, 111, 144, 22, 24, 164, 0, 23, 8, 163, 16, 23, 249, 215, 128, 24, 233, 214, 144, 25, 219, 11, 0, 26, 204, 91, 144, 27, 188, 104, 176, 28, 172, 89, 176, 29, 156, 74, 176, 30, 140, 59, 176, 31, 124, 44, 176, 32, 108, 29, 176, 33, 92, 14, 176, 34, 75, 255, 176, 35, 59, 240, 176, 36, 43, 225, 176, 37, 27, 210, 176, 38, 11, 195, 176, 39, 4, 239, 48, 39, 244, 224, 48, 40, 228, 223, 64, 41, 120, 135, 64, 41, 212, 194, 48, 42, 196, 179, 48, 43, 180, 164, 48, 44, 164, 149, 48, 45, 148, 134, 48, 46, 132, 119, 48, 47, 116, 104, 48, 48, 100, 89, 48, 49, 93, 132, 176, 50, 114, 95, 176, 51, 61, 102, 176, 52, 82, 65, 176, 53, 29, 72, 176, 54, 50, 35, 176, 54, 253, 42, 176, 56, 27, 64, 48, 56, 221, 12, 176, 57, 251, 34, 48, 58, 188, 238, 176, 59, 219, 4, 48, 60, 166, 11, 48, 60, 206, 233, 176, 61, 186, 244, 64, 62, 133, 251, 64, 63, 154, 214, 64, 64, 101, 221, 64, 65, 131, 242, 192, 66, 69, 191, 64, 67, 99, 212, 192, 68, 37, 161, 64, 69, 67, 182, 192, 70, 5, 131, 64, 71, 35, 152, 192, 71, 238, 159, 192, 73, 3, 122, 192, 73, 206, 129, 192, 74, 227, 92, 192, 75, 174, 99, 192, 76, 204, 121, 64, 77, 142, 69, 192, 84, 75, 243, 48, 87, 73, 248, 192, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 8, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 4, 7, 4, 4, 0, 0, 79, 167, 0, 0, 0, 0, 84, 96, 0, 4, 0, 0, 112, 128, 1, 8, 0, 0, 98, 112, 0, 12, 0, 0, 98, 112, 0, 12, 0, 0, 112, 128, 1, 8, 0, 0, 98, 112, 1, 12, 0, 0, 84, 96, 0, 4, 0, 0, 98, 112, 1, 12, 0, 0, 98, 112, 0, 12, 76, 77, 84, 0, 43, 48, 54, 0, 43, 48, 56, 0, 43, 48, 55, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 55, 62, 45, 55, 10}, - - "zoneinfo/Asia/Ujung_Pandang": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 21, 128, 0, 0, 0, 161, 242, 93, 144, 186, 22, 213, 144, 203, 136, 29, 128, 210, 86, 238, 112, 0, 1, 2, 3, 4, 0, 0, 111, 240, 0, 0, 0, 0, 111, 240, 0, 4, 0, 0, 112, 128, 0, 8, 0, 0, 126, 144, 0, 12, 0, 0, 112, 128, 0, 16, 76, 77, 84, 0, 77, 77, 84, 0, 43, 48, 56, 0, 43, 48, 57, 0, 87, 73, 84, 65, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 87, 73, 84, 65, 45, 56, 10}, - - "zoneinfo/Asia/Ulaanbaatar": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 52, 0, 0, 0, 4, 0, 0, 0, 16, 128, 0, 0, 0, 134, 211, 238, 76, 15, 11, 220, 144, 24, 233, 200, 128, 25, 218, 252, 240, 26, 204, 77, 128, 27, 188, 48, 112, 28, 172, 47, 128, 29, 156, 18, 112, 30, 140, 17, 128, 31, 123, 244, 112, 32, 107, 243, 128, 33, 91, 214, 112, 34, 75, 213, 128, 35, 59, 184, 112, 36, 43, 183, 128, 37, 27, 154, 112, 38, 11, 153, 128, 39, 4, 182, 240, 39, 244, 182, 0, 40, 228, 152, 240, 41, 212, 152, 0, 42, 196, 122, 240, 43, 180, 122, 0, 44, 164, 92, 240, 45, 148, 92, 0, 46, 132, 62, 240, 47, 116, 62, 0, 48, 100, 32, 240, 49, 93, 90, 128, 50, 77, 61, 112, 51, 61, 60, 128, 52, 45, 31, 112, 53, 29, 30, 128, 54, 13, 1, 112, 58, 233, 179, 160, 59, 180, 172, 144, 60, 164, 171, 160, 61, 148, 142, 144, 62, 132, 141, 160, 63, 116, 112, 144, 64, 100, 111, 160, 65, 84, 82, 144, 66, 68, 81, 160, 67, 52, 52, 144, 68, 36, 51, 160, 69, 29, 81, 16, 85, 21, 154, 160, 86, 5, 97, 112, 86, 245, 124, 160, 87, 229, 67, 112, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 3, 0, 0, 100, 52, 0, 0, 0, 0, 98, 112, 0, 4, 0, 0, 126, 144, 1, 8, 0, 0, 112, 128, 0, 12, 76, 77, 84, 0, 43, 48, 55, 0, 43, 48, 57, 0, 43, 48, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 56, 62, 45, 56, 10}, - - "zoneinfo/Asia/Ulan_Bator": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 52, 0, 0, 0, 4, 0, 0, 0, 16, 128, 0, 0, 0, 134, 211, 238, 76, 15, 11, 220, 144, 24, 233, 200, 128, 25, 218, 252, 240, 26, 204, 77, 128, 27, 188, 48, 112, 28, 172, 47, 128, 29, 156, 18, 112, 30, 140, 17, 128, 31, 123, 244, 112, 32, 107, 243, 128, 33, 91, 214, 112, 34, 75, 213, 128, 35, 59, 184, 112, 36, 43, 183, 128, 37, 27, 154, 112, 38, 11, 153, 128, 39, 4, 182, 240, 39, 244, 182, 0, 40, 228, 152, 240, 41, 212, 152, 0, 42, 196, 122, 240, 43, 180, 122, 0, 44, 164, 92, 240, 45, 148, 92, 0, 46, 132, 62, 240, 47, 116, 62, 0, 48, 100, 32, 240, 49, 93, 90, 128, 50, 77, 61, 112, 51, 61, 60, 128, 52, 45, 31, 112, 53, 29, 30, 128, 54, 13, 1, 112, 58, 233, 179, 160, 59, 180, 172, 144, 60, 164, 171, 160, 61, 148, 142, 144, 62, 132, 141, 160, 63, 116, 112, 144, 64, 100, 111, 160, 65, 84, 82, 144, 66, 68, 81, 160, 67, 52, 52, 144, 68, 36, 51, 160, 69, 29, 81, 16, 85, 21, 154, 160, 86, 5, 97, 112, 86, 245, 124, 160, 87, 229, 67, 112, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 3, 0, 0, 100, 52, 0, 0, 0, 0, 98, 112, 0, 4, 0, 0, 126, 144, 1, 8, 0, 0, 112, 128, 0, 12, 76, 77, 84, 0, 43, 48, 55, 0, 43, 48, 57, 0, 43, 48, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 56, 62, 45, 56, 10}, - - "zoneinfo/Asia/Urumqi": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 176, 254, 186, 100, 127, 255, 255, 255, 0, 1, 1, 0, 0, 82, 28, 0, 0, 0, 0, 84, 96, 0, 4, 76, 77, 84, 0, 43, 48, 54, 0, 0, 0, 0, 0, 10, 60, 43, 48, 54, 62, 45, 54, 10}, - - "zoneinfo/Asia/Ust-Nera": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 12, 0, 0, 0, 24, 128, 0, 0, 0, 161, 219, 221, 186, 181, 163, 197, 0, 21, 39, 83, 112, 22, 24, 107, 192, 23, 8, 106, 208, 23, 249, 159, 64, 24, 233, 158, 80, 25, 218, 210, 192, 26, 204, 35, 80, 27, 188, 48, 112, 28, 172, 33, 112, 29, 156, 18, 112, 30, 140, 3, 112, 31, 123, 244, 112, 32, 107, 229, 112, 33, 91, 214, 112, 34, 75, 199, 112, 35, 59, 184, 112, 36, 43, 169, 112, 37, 27, 154, 112, 38, 11, 139, 112, 39, 4, 182, 240, 39, 244, 167, 240, 40, 228, 167, 0, 41, 120, 79, 0, 41, 212, 137, 240, 42, 196, 122, 240, 43, 180, 107, 240, 44, 164, 92, 240, 45, 148, 77, 240, 46, 132, 62, 240, 47, 116, 47, 240, 48, 100, 32, 240, 49, 93, 76, 112, 50, 114, 39, 112, 51, 61, 46, 112, 52, 82, 9, 112, 53, 29, 16, 112, 54, 49, 235, 112, 54, 252, 242, 112, 56, 27, 7, 240, 56, 220, 212, 112, 57, 250, 233, 240, 58, 188, 182, 112, 59, 218, 203, 240, 60, 165, 210, 240, 61, 186, 173, 240, 62, 133, 180, 240, 63, 154, 143, 240, 64, 101, 150, 240, 65, 131, 172, 112, 66, 69, 120, 240, 67, 99, 142, 112, 68, 37, 90, 240, 69, 67, 112, 112, 70, 5, 60, 240, 71, 35, 82, 112, 71, 238, 89, 112, 73, 3, 52, 112, 73, 206, 59, 112, 74, 227, 22, 112, 75, 174, 29, 112, 76, 204, 50, 240, 77, 141, 255, 112, 78, 109, 244, 64, 84, 75, 186, 240, 127, 255, 255, 255, 0, 1, 2, 4, 3, 4, 3, 4, 3, 4, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 7, 8, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 9, 5, 8, 8, 0, 0, 134, 70, 0, 0, 0, 0, 112, 128, 0, 4, 0, 0, 126, 144, 0, 8, 0, 0, 154, 176, 0, 12, 0, 0, 168, 192, 1, 16, 0, 0, 154, 176, 0, 12, 0, 0, 168, 192, 1, 16, 0, 0, 154, 176, 1, 12, 0, 0, 140, 160, 0, 20, 0, 0, 168, 192, 0, 16, 0, 0, 168, 192, 1, 16, 0, 0, 140, 160, 0, 20, 76, 77, 84, 0, 43, 48, 56, 0, 43, 48, 57, 0, 43, 49, 49, 0, 43, 49, 50, 0, 43, 49, 48, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 48, 62, 45, 49, 48, 10}, - - "zoneinfo/Asia/Vientiane": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 162, 106, 103, 196, 127, 255, 255, 255, 1, 2, 2, 0, 0, 94, 60, 0, 0, 0, 0, 94, 60, 0, 4, 0, 0, 98, 112, 0, 8, 76, 77, 84, 0, 66, 77, 84, 0, 43, 48, 55, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 55, 62, 45, 55, 10}, - - "zoneinfo/Asia/Vladivostok": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 11, 0, 0, 0, 16, 128, 0, 0, 0, 167, 89, 71, 93, 181, 163, 182, 240, 21, 39, 69, 96, 22, 24, 121, 208, 23, 8, 120, 224, 23, 249, 173, 80, 24, 233, 172, 96, 25, 218, 224, 208, 26, 204, 49, 96, 27, 188, 62, 128, 28, 172, 47, 128, 29, 156, 32, 128, 30, 140, 17, 128, 31, 124, 2, 128, 32, 107, 243, 128, 33, 91, 228, 128, 34, 75, 213, 128, 35, 59, 198, 128, 36, 43, 183, 128, 37, 27, 168, 128, 38, 11, 153, 128, 39, 4, 197, 0, 39, 244, 182, 0, 40, 228, 181, 16, 41, 120, 93, 16, 41, 212, 152, 0, 42, 196, 137, 0, 43, 180, 122, 0, 44, 164, 107, 0, 45, 148, 92, 0, 46, 132, 77, 0, 47, 116, 62, 0, 48, 100, 47, 0, 49, 93, 90, 128, 50, 114, 53, 128, 51, 61, 60, 128, 52, 82, 23, 128, 53, 29, 30, 128, 54, 49, 249, 128, 54, 253, 0, 128, 56, 27, 22, 0, 56, 220, 226, 128, 57, 250, 248, 0, 58, 188, 196, 128, 59, 218, 218, 0, 60, 165, 225, 0, 61, 186, 188, 0, 62, 133, 195, 0, 63, 154, 158, 0, 64, 101, 165, 0, 65, 131, 186, 128, 66, 69, 135, 0, 67, 99, 156, 128, 68, 37, 105, 0, 69, 67, 126, 128, 70, 5, 75, 0, 71, 35, 96, 128, 71, 238, 103, 128, 73, 3, 66, 128, 73, 206, 73, 128, 74, 227, 36, 128, 75, 174, 43, 128, 76, 204, 65, 0, 77, 142, 13, 128, 84, 75, 186, 240, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 8, 4, 4, 0, 0, 123, 163, 0, 0, 0, 0, 126, 144, 0, 4, 0, 0, 154, 176, 1, 8, 0, 0, 140, 160, 0, 12, 0, 0, 140, 160, 0, 12, 0, 0, 154, 176, 1, 8, 0, 0, 140, 160, 1, 12, 0, 0, 126, 144, 0, 4, 0, 0, 154, 176, 0, 8, 0, 0, 154, 176, 1, 8, 0, 0, 140, 160, 0, 12, 76, 77, 84, 0, 43, 48, 57, 0, 43, 49, 49, 0, 43, 49, 48, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 48, 62, 45, 49, 48, 10}, - - "zoneinfo/Asia/Yakutsk": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 67, 0, 0, 0, 11, 0, 0, 0, 16, 128, 0, 0, 0, 161, 219, 234, 94, 181, 163, 197, 0, 21, 39, 83, 112, 22, 24, 135, 224, 23, 8, 134, 240, 23, 249, 187, 96, 24, 233, 186, 112, 25, 218, 238, 224, 26, 204, 63, 112, 27, 188, 76, 144, 28, 172, 61, 144, 29, 156, 46, 144, 30, 140, 31, 144, 31, 124, 16, 144, 32, 108, 1, 144, 33, 91, 242, 144, 34, 75, 227, 144, 35, 59, 212, 144, 36, 43, 197, 144, 37, 27, 182, 144, 38, 11, 167, 144, 39, 4, 211, 16, 39, 244, 196, 16, 40, 228, 195, 32, 41, 120, 107, 32, 41, 212, 166, 16, 42, 196, 151, 16, 43, 180, 136, 16, 44, 164, 121, 16, 45, 148, 106, 16, 46, 132, 91, 16, 47, 116, 76, 16, 48, 100, 61, 16, 49, 93, 104, 144, 50, 114, 67, 144, 51, 61, 74, 144, 52, 82, 37, 144, 53, 29, 44, 144, 54, 50, 7, 144, 54, 253, 14, 144, 56, 27, 36, 16, 56, 220, 240, 144, 57, 251, 6, 16, 58, 188, 210, 144, 59, 218, 232, 16, 60, 165, 239, 16, 61, 186, 202, 16, 62, 133, 209, 16, 63, 154, 172, 16, 64, 101, 179, 16, 65, 131, 200, 144, 66, 69, 149, 16, 67, 99, 170, 144, 68, 37, 119, 16, 69, 67, 140, 144, 70, 5, 89, 16, 71, 35, 110, 144, 71, 238, 117, 144, 73, 3, 80, 144, 73, 206, 87, 144, 74, 227, 50, 144, 75, 174, 57, 144, 76, 204, 79, 16, 77, 142, 27, 144, 84, 75, 201, 0, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 8, 4, 4, 0, 0, 121, 162, 0, 0, 0, 0, 112, 128, 0, 4, 0, 0, 140, 160, 1, 8, 0, 0, 126, 144, 0, 12, 0, 0, 126, 144, 0, 12, 0, 0, 140, 160, 1, 8, 0, 0, 126, 144, 1, 12, 0, 0, 112, 128, 0, 4, 0, 0, 140, 160, 0, 8, 0, 0, 140, 160, 1, 8, 0, 0, 126, 144, 0, 12, 76, 77, 84, 0, 43, 48, 56, 0, 43, 49, 48, 0, 43, 48, 57, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 57, 62, 45, 57, 10}, - - "zoneinfo/Asia/Yangon": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 18, 128, 0, 0, 0, 161, 242, 115, 81, 203, 242, 252, 24, 209, 154, 103, 240, 127, 255, 255, 255, 1, 2, 3, 2, 2, 0, 0, 90, 47, 0, 0, 0, 0, 90, 47, 0, 4, 0, 0, 91, 104, 0, 8, 0, 0, 126, 144, 0, 14, 0, 0, 91, 104, 0, 8, 76, 77, 84, 0, 82, 77, 84, 0, 43, 48, 54, 51, 48, 0, 43, 48, 57, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 54, 51, 48, 62, 45, 54, 58, 51, 48, 10}, - - "zoneinfo/Asia/Yekaterinburg": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 12, 0, 0, 0, 20, 128, 0, 0, 0, 155, 95, 9, 39, 161, 18, 177, 255, 181, 163, 253, 64, 21, 39, 139, 176, 22, 24, 192, 32, 23, 8, 191, 48, 23, 249, 243, 160, 24, 233, 242, 176, 25, 219, 39, 32, 26, 204, 119, 176, 27, 188, 132, 208, 28, 172, 117, 208, 29, 156, 102, 208, 30, 140, 87, 208, 31, 124, 72, 208, 32, 108, 57, 208, 33, 92, 42, 208, 34, 76, 27, 208, 35, 60, 12, 208, 36, 43, 253, 208, 37, 27, 238, 208, 38, 11, 223, 208, 39, 5, 11, 80, 39, 244, 252, 80, 40, 228, 251, 96, 41, 120, 163, 96, 41, 212, 222, 80, 42, 196, 207, 80, 43, 180, 192, 80, 44, 164, 177, 80, 45, 148, 162, 80, 46, 132, 147, 80, 47, 116, 132, 80, 48, 100, 117, 80, 49, 93, 160, 208, 50, 114, 123, 208, 51, 61, 130, 208, 52, 82, 93, 208, 53, 29, 100, 208, 54, 50, 63, 208, 54, 253, 70, 208, 56, 27, 92, 80, 56, 221, 40, 208, 57, 251, 62, 80, 58, 189, 10, 208, 59, 219, 32, 80, 60, 166, 39, 80, 61, 187, 2, 80, 62, 134, 9, 80, 63, 154, 228, 80, 64, 101, 235, 80, 65, 132, 0, 208, 66, 69, 205, 80, 67, 99, 226, 208, 68, 37, 175, 80, 69, 67, 196, 208, 70, 5, 145, 80, 71, 35, 166, 208, 71, 238, 173, 208, 73, 3, 136, 208, 73, 206, 143, 208, 74, 227, 106, 208, 75, 174, 113, 208, 76, 204, 135, 80, 77, 142, 83, 208, 84, 76, 1, 64, 127, 255, 255, 255, 0, 1, 2, 4, 3, 4, 3, 4, 3, 4, 3, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 7, 8, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 9, 5, 5, 0, 0, 56, 217, 0, 0, 0, 0, 52, 193, 0, 4, 0, 0, 56, 64, 0, 8, 0, 0, 84, 96, 1, 12, 0, 0, 70, 80, 0, 16, 0, 0, 70, 80, 0, 16, 0, 0, 84, 96, 1, 12, 0, 0, 70, 80, 1, 16, 0, 0, 56, 64, 0, 8, 0, 0, 84, 96, 0, 12, 0, 0, 84, 96, 1, 12, 0, 0, 70, 80, 0, 16, 76, 77, 84, 0, 80, 77, 84, 0, 43, 48, 52, 0, 43, 48, 54, 0, 43, 48, 53, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 53, 62, 45, 53, 10}, - - "zoneinfo/Asia/Yerevan": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 66, 0, 0, 0, 10, 0, 0, 0, 16, 128, 0, 0, 0, 170, 25, 154, 72, 231, 218, 12, 80, 21, 39, 153, 192, 22, 24, 206, 48, 23, 8, 205, 64, 23, 250, 1, 176, 24, 234, 0, 192, 25, 219, 53, 48, 26, 204, 133, 192, 27, 188, 146, 224, 28, 172, 131, 224, 29, 156, 116, 224, 30, 140, 101, 224, 31, 124, 86, 224, 32, 108, 71, 224, 33, 92, 56, 224, 34, 76, 41, 224, 35, 60, 26, 224, 36, 44, 11, 224, 37, 27, 252, 224, 38, 11, 237, 224, 39, 5, 25, 96, 39, 245, 10, 96, 40, 229, 9, 112, 41, 212, 250, 112, 42, 196, 235, 112, 43, 180, 220, 112, 44, 164, 205, 112, 45, 148, 190, 112, 46, 132, 175, 112, 47, 116, 160, 112, 48, 100, 145, 112, 50, 201, 112, 192, 51, 61, 144, 224, 52, 82, 107, 224, 53, 29, 114, 224, 54, 50, 77, 224, 54, 253, 84, 224, 56, 27, 106, 96, 56, 221, 54, 224, 57, 251, 76, 96, 58, 189, 24, 224, 59, 219, 46, 96, 60, 166, 53, 96, 61, 187, 16, 96, 62, 134, 23, 96, 63, 154, 242, 96, 64, 101, 249, 96, 65, 132, 14, 224, 66, 69, 219, 96, 67, 99, 240, 224, 68, 37, 189, 96, 69, 67, 210, 224, 70, 5, 159, 96, 71, 35, 180, 224, 71, 238, 187, 224, 73, 3, 150, 224, 73, 206, 157, 224, 74, 227, 120, 224, 75, 174, 127, 224, 76, 204, 149, 96, 77, 30, 54, 64, 77, 142, 97, 224, 78, 172, 119, 96, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 6, 7, 6, 7, 6, 7, 6, 4, 3, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 3, 5, 4, 4, 0, 0, 41, 184, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 0, 12, 0, 0, 56, 64, 0, 12, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 1, 12, 0, 0, 42, 48, 0, 4, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 0, 12, 76, 77, 84, 0, 43, 48, 51, 0, 43, 48, 53, 0, 43, 48, 52, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 52, 62, 45, 52, 10}, - - "zoneinfo/Atlantic/Azores": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 222, 0, 0, 0, 12, 0, 0, 0, 24, 128, 0, 0, 0, 146, 230, 169, 88, 155, 75, 137, 144, 155, 254, 227, 160, 156, 157, 9, 144, 157, 201, 159, 144, 158, 127, 142, 144, 159, 170, 211, 16, 160, 95, 112, 144, 161, 140, 6, 144, 162, 65, 245, 144, 163, 110, 139, 144, 164, 35, 41, 16, 165, 79, 191, 16, 170, 6, 11, 144, 170, 244, 171, 16, 173, 201, 196, 16, 174, 167, 64, 16, 175, 160, 107, 144, 176, 135, 34, 16, 177, 137, 136, 16, 178, 112, 62, 144, 179, 114, 164, 144, 180, 80, 32, 144, 183, 50, 104, 144, 184, 15, 228, 144, 184, 255, 213, 144, 185, 239, 198, 144, 188, 200, 212, 16, 189, 184, 197, 16, 190, 159, 123, 144, 191, 152, 167, 16, 192, 155, 13, 16, 193, 120, 137, 16, 194, 104, 122, 16, 195, 88, 107, 16, 196, 63, 33, 144, 197, 56, 77, 16, 198, 58, 179, 16, 199, 88, 200, 144, 199, 217, 251, 144, 201, 1, 75, 144, 201, 241, 60, 144, 202, 226, 127, 16, 203, 181, 111, 16, 203, 236, 192, 0, 204, 128, 104, 0, 204, 220, 191, 16, 205, 149, 81, 16, 205, 195, 103, 128, 206, 114, 191, 0, 206, 197, 219, 144, 207, 117, 51, 16, 207, 172, 132, 0, 208, 82, 161, 0, 208, 165, 189, 144, 209, 85, 21, 16, 209, 140, 102, 0, 210, 50, 131, 0, 210, 133, 159, 144, 211, 89, 225, 16, 212, 73, 210, 16, 213, 57, 237, 64, 214, 41, 222, 64, 215, 25, 207, 64, 216, 9, 192, 64, 216, 249, 177, 64, 217, 233, 162, 64, 220, 185, 117, 64, 221, 178, 160, 192, 222, 162, 145, 192, 223, 146, 130, 192, 224, 130, 115, 192, 225, 114, 100, 192, 226, 98, 85, 192, 227, 82, 70, 192, 228, 66, 55, 192, 229, 50, 40, 192, 230, 34, 25, 192, 231, 27, 69, 64, 232, 11, 54, 64, 232, 251, 39, 64, 233, 235, 24, 64, 234, 219, 9, 64, 235, 202, 250, 64, 236, 186, 235, 64, 237, 170, 220, 64, 238, 154, 205, 64, 239, 138, 190, 64, 240, 122, 175, 64, 241, 106, 160, 64, 242, 99, 203, 192, 243, 83, 188, 192, 244, 67, 173, 192, 245, 51, 158, 192, 246, 35, 143, 192, 247, 19, 128, 192, 248, 3, 113, 192, 248, 243, 98, 192, 13, 155, 41, 16, 14, 139, 26, 16, 15, 132, 69, 144, 16, 116, 54, 144, 17, 100, 39, 144, 18, 84, 38, 160, 19, 68, 9, 144, 20, 52, 8, 160, 21, 35, 249, 160, 22, 19, 234, 160, 23, 3, 219, 160, 23, 243, 204, 160, 24, 227, 203, 176, 25, 211, 174, 160, 26, 195, 159, 160, 27, 188, 203, 32, 28, 172, 188, 32, 29, 156, 173, 32, 30, 140, 158, 32, 31, 124, 143, 32, 32, 108, 128, 32, 33, 92, 113, 32, 34, 76, 98, 32, 35, 60, 83, 32, 36, 44, 68, 32, 37, 28, 53, 32, 38, 12, 38, 32, 39, 5, 81, 160, 39, 245, 66, 160, 40, 229, 51, 160, 41, 213, 36, 160, 42, 197, 21, 160, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 127, 255, 255, 255, 1, 3, 2, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 4, 5, 4, 6, 4, 5, 4, 6, 4, 5, 4, 6, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 8, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 9, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 11, 255, 255, 231, 240, 0, 0, 255, 255, 229, 40, 0, 4, 255, 255, 241, 240, 1, 8, 255, 255, 227, 224, 0, 12, 255, 255, 241, 240, 1, 8, 255, 255, 227, 224, 0, 12, 0, 0, 0, 0, 1, 16, 255, 255, 241, 240, 0, 8, 255, 255, 241, 240, 0, 8, 0, 0, 0, 0, 0, 20, 0, 0, 0, 0, 1, 16, 255, 255, 241, 240, 0, 8, 76, 77, 84, 0, 72, 77, 84, 0, 45, 48, 49, 0, 45, 48, 50, 0, 43, 48, 48, 0, 87, 69, 84, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 60, 45, 48, 49, 62, 49, 60, 43, 48, 48, 62, 44, 77, 51, 46, 53, 46, 48, 47, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 49, 10}, - - "zoneinfo/Atlantic/Bermuda": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 130, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 180, 195, 29, 230, 8, 32, 179, 96, 9, 16, 150, 80, 10, 0, 149, 96, 10, 240, 120, 80, 11, 224, 119, 96, 12, 217, 148, 208, 13, 192, 89, 96, 14, 185, 118, 208, 15, 169, 117, 224, 16, 153, 88, 208, 17, 137, 87, 224, 18, 121, 58, 208, 19, 105, 57, 224, 20, 89, 28, 208, 21, 73, 27, 224, 22, 56, 254, 208, 23, 40, 253, 224, 24, 34, 27, 80, 25, 8, 223, 224, 26, 1, 253, 80, 26, 241, 252, 96, 27, 225, 223, 80, 28, 209, 222, 96, 29, 193, 193, 80, 30, 177, 192, 96, 31, 161, 163, 80, 32, 117, 242, 224, 33, 129, 133, 80, 34, 85, 212, 224, 35, 106, 161, 208, 36, 53, 182, 224, 37, 74, 131, 208, 38, 21, 152, 224, 39, 42, 101, 208, 39, 254, 181, 96, 41, 10, 71, 208, 41, 222, 151, 96, 42, 234, 41, 208, 43, 190, 121, 96, 44, 211, 70, 80, 45, 158, 91, 96, 46, 179, 40, 80, 47, 126, 61, 96, 48, 147, 10, 80, 49, 103, 89, 224, 50, 114, 236, 80, 51, 71, 59, 224, 52, 82, 206, 80, 53, 39, 29, 224, 54, 50, 176, 80, 55, 6, 255, 224, 56, 27, 204, 208, 56, 230, 225, 224, 57, 251, 174, 208, 58, 198, 195, 224, 59, 219, 144, 208, 60, 175, 224, 96, 61, 187, 114, 208, 62, 143, 194, 96, 63, 155, 84, 208, 64, 111, 164, 96, 65, 132, 113, 80, 66, 79, 134, 96, 67, 100, 83, 80, 68, 47, 104, 96, 69, 68, 53, 80, 69, 243, 154, 224, 71, 45, 81, 208, 71, 211, 124, 224, 73, 13, 51, 208, 73, 179, 94, 224, 74, 237, 21, 208, 75, 156, 123, 96, 76, 214, 50, 80, 77, 124, 93, 96, 78, 182, 20, 80, 79, 92, 63, 96, 80, 149, 246, 80, 81, 60, 33, 96, 82, 117, 216, 80, 83, 28, 3, 96, 84, 85, 186, 80, 84, 251, 229, 96, 86, 53, 156, 80, 86, 229, 1, 224, 88, 30, 184, 208, 88, 196, 227, 224, 89, 254, 154, 208, 90, 164, 197, 224, 91, 222, 124, 208, 92, 132, 167, 224, 93, 190, 94, 208, 94, 100, 137, 224, 95, 158, 64, 208, 96, 77, 166, 96, 97, 135, 93, 80, 98, 45, 136, 96, 99, 103, 63, 80, 100, 13, 106, 96, 101, 71, 33, 80, 101, 237, 76, 96, 103, 39, 3, 80, 103, 205, 46, 96, 105, 6, 229, 80, 105, 173, 16, 96, 106, 230, 199, 80, 107, 150, 44, 224, 108, 207, 227, 208, 109, 118, 14, 224, 110, 175, 197, 208, 111, 85, 240, 224, 112, 143, 167, 208, 113, 53, 210, 224, 114, 111, 137, 208, 115, 21, 180, 224, 116, 79, 107, 208, 116, 254, 209, 96, 118, 56, 136, 80, 118, 222, 179, 96, 120, 24, 106, 80, 120, 190, 149, 96, 121, 248, 76, 80, 122, 158, 119, 96, 123, 216, 46, 80, 124, 126, 89, 96, 125, 184, 16, 80, 126, 94, 59, 96, 127, 151, 242, 80, 0, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 255, 255, 195, 58, 0, 0, 255, 255, 199, 192, 0, 4, 255, 255, 213, 208, 1, 8, 76, 77, 84, 0, 65, 83, 84, 0, 65, 68, 84, 0, 0, 0, 0, 0, 0, 0, 10, 65, 83, 84, 52, 65, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/Atlantic/Canary": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 119, 0, 0, 0, 6, 0, 0, 0, 17, 128, 0, 0, 0, 166, 4, 92, 240, 212, 65, 247, 32, 19, 77, 54, 0, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 0, 1, 2, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 255, 255, 241, 144, 0, 0, 255, 255, 241, 240, 0, 4, 0, 0, 0, 0, 0, 8, 0, 0, 14, 16, 1, 12, 0, 0, 0, 0, 0, 8, 0, 0, 14, 16, 1, 12, 76, 77, 84, 0, 45, 48, 49, 0, 87, 69, 84, 0, 87, 69, 83, 84, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 1, 10, 87, 69, 84, 48, 87, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 49, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/Atlantic/Cape_Verde": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 12, 128, 0, 0, 0, 137, 127, 81, 140, 204, 149, 156, 32, 210, 116, 124, 16, 11, 23, 247, 64, 127, 255, 255, 255, 0, 1, 2, 1, 3, 3, 255, 255, 233, 244, 0, 0, 255, 255, 227, 224, 0, 4, 255, 255, 241, 240, 1, 8, 255, 255, 241, 240, 0, 8, 76, 77, 84, 0, 45, 48, 50, 0, 45, 48, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 49, 62, 49, 10}, - - "zoneinfo/Atlantic/Faeroe": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 116, 0, 0, 0, 4, 0, 0, 0, 13, 128, 0, 0, 0, 139, 109, 164, 88, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 0, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 255, 255, 249, 168, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 14, 16, 1, 8, 0, 0, 0, 0, 0, 4, 76, 77, 84, 0, 87, 69, 84, 0, 87, 69, 83, 84, 0, 0, 0, 1, 1, 0, 0, 1, 1, 10, 87, 69, 84, 48, 87, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 49, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/Atlantic/Faroe": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 116, 0, 0, 0, 4, 0, 0, 0, 13, 128, 0, 0, 0, 139, 109, 164, 88, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 0, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 255, 255, 249, 168, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 14, 16, 1, 8, 0, 0, 0, 0, 0, 4, 76, 77, 84, 0, 87, 69, 84, 0, 87, 69, 83, 84, 0, 0, 0, 1, 1, 0, 0, 1, 1, 10, 87, 69, 84, 48, 87, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 49, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/Atlantic/Jan_Mayen": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 155, 39, 227, 0, 155, 212, 123, 96, 200, 183, 77, 96, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 209, 114, 22, 16, 210, 98, 7, 16, 235, 175, 32, 144, 236, 168, 76, 16, 237, 152, 61, 16, 238, 136, 46, 16, 239, 120, 31, 16, 240, 104, 16, 16, 241, 88, 1, 16, 242, 71, 242, 16, 243, 55, 227, 16, 244, 39, 212, 16, 245, 23, 197, 16, 246, 16, 240, 144, 247, 47, 6, 16, 247, 240, 210, 144, 18, 206, 151, 240, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 10, 20, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 76, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Atlantic/Madeira": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 221, 0, 0, 0, 12, 0, 0, 0, 29, 128, 0, 0, 0, 146, 230, 158, 88, 155, 75, 123, 128, 155, 254, 213, 144, 156, 156, 251, 128, 157, 201, 145, 128, 158, 127, 128, 128, 159, 170, 197, 0, 160, 95, 98, 128, 161, 139, 248, 128, 162, 65, 231, 128, 163, 110, 125, 128, 164, 35, 27, 0, 165, 79, 177, 0, 170, 5, 253, 128, 170, 244, 157, 0, 173, 201, 182, 0, 174, 167, 50, 0, 175, 160, 93, 128, 176, 135, 20, 0, 177, 137, 122, 0, 178, 112, 48, 128, 179, 114, 150, 128, 180, 80, 18, 128, 183, 50, 90, 128, 184, 15, 214, 128, 184, 255, 199, 128, 185, 239, 184, 128, 188, 200, 198, 0, 189, 184, 183, 0, 190, 159, 109, 128, 191, 152, 153, 0, 192, 154, 255, 0, 193, 120, 123, 0, 194, 104, 108, 0, 195, 88, 93, 0, 196, 63, 19, 128, 197, 56, 63, 0, 198, 58, 165, 0, 199, 88, 186, 128, 199, 217, 237, 128, 201, 1, 61, 128, 201, 241, 46, 128, 202, 226, 113, 0, 203, 181, 97, 0, 203, 236, 177, 240, 204, 128, 89, 240, 204, 220, 177, 0, 205, 149, 67, 0, 205, 195, 89, 112, 206, 114, 176, 240, 206, 197, 205, 128, 207, 117, 37, 0, 207, 172, 117, 240, 208, 82, 146, 240, 208, 165, 175, 128, 209, 85, 7, 0, 209, 140, 87, 240, 210, 50, 116, 240, 210, 133, 145, 128, 211, 89, 211, 0, 212, 73, 196, 0, 213, 57, 223, 48, 214, 41, 208, 48, 215, 25, 193, 48, 216, 9, 178, 48, 216, 249, 163, 48, 217, 233, 148, 48, 220, 185, 103, 48, 221, 178, 146, 176, 222, 162, 131, 176, 223, 146, 116, 176, 224, 130, 101, 176, 225, 114, 86, 176, 226, 98, 71, 176, 227, 82, 56, 176, 228, 66, 41, 176, 229, 50, 26, 176, 230, 34, 11, 176, 231, 27, 55, 48, 232, 11, 40, 48, 232, 251, 25, 48, 233, 235, 10, 48, 234, 218, 251, 48, 235, 202, 236, 48, 236, 186, 221, 48, 237, 170, 206, 48, 238, 154, 191, 48, 239, 138, 176, 48, 240, 122, 161, 48, 241, 106, 146, 48, 242, 99, 189, 176, 243, 83, 174, 176, 244, 67, 159, 176, 245, 51, 144, 176, 246, 35, 129, 176, 247, 19, 114, 176, 248, 3, 99, 176, 248, 243, 84, 176, 13, 155, 27, 0, 14, 139, 12, 0, 15, 132, 55, 128, 16, 116, 40, 128, 17, 100, 25, 128, 18, 84, 24, 144, 19, 67, 251, 128, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 189, 160, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 3, 2, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 4, 5, 4, 6, 4, 5, 4, 6, 4, 5, 4, 6, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 9, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 255, 255, 240, 40, 0, 0, 255, 255, 240, 40, 0, 4, 0, 0, 0, 0, 1, 8, 255, 255, 241, 240, 0, 12, 0, 0, 0, 0, 1, 8, 255, 255, 241, 240, 0, 12, 0, 0, 14, 16, 1, 16, 0, 0, 14, 16, 1, 20, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 25, 0, 0, 0, 0, 0, 25, 0, 0, 14, 16, 1, 20, 76, 77, 84, 0, 70, 77, 84, 0, 43, 48, 48, 0, 45, 48, 49, 0, 43, 48, 49, 0, 87, 69, 83, 84, 0, 87, 69, 84, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 87, 69, 84, 48, 87, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 49, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/Atlantic/Reykjavik": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 69, 0, 0, 0, 6, 0, 0, 0, 16, 128, 0, 0, 0, 139, 96, 131, 160, 156, 145, 30, 0, 157, 209, 136, 144, 158, 114, 81, 128, 159, 213, 3, 16, 160, 83, 133, 0, 161, 182, 54, 144, 164, 60, 39, 128, 164, 185, 116, 16, 198, 77, 26, 0, 199, 61, 39, 32, 199, 218, 23, 176, 201, 38, 67, 160, 201, 195, 38, 32, 203, 6, 37, 160, 203, 172, 66, 160, 204, 220, 205, 32, 205, 140, 36, 160, 206, 188, 175, 32, 207, 108, 6, 160, 208, 156, 145, 32, 209, 75, 232, 160, 210, 133, 173, 160, 211, 43, 202, 160, 212, 101, 143, 160, 213, 57, 209, 32, 214, 69, 113, 160, 215, 25, 179, 32, 216, 37, 83, 160, 216, 249, 149, 32, 218, 14, 112, 32, 218, 217, 119, 32, 219, 229, 23, 160, 220, 185, 89, 32, 221, 206, 52, 32, 222, 162, 117, 160, 223, 174, 22, 32, 224, 130, 87, 160, 225, 141, 248, 32, 226, 98, 57, 160, 227, 109, 218, 32, 228, 66, 27, 160, 229, 77, 188, 32, 230, 33, 253, 160, 231, 54, 216, 160, 232, 11, 26, 32, 233, 22, 186, 160, 233, 234, 252, 32, 234, 246, 156, 160, 235, 202, 222, 32, 236, 214, 126, 160, 237, 170, 192, 32, 238, 182, 96, 160, 239, 138, 162, 32, 240, 150, 66, 160, 241, 106, 132, 32, 242, 127, 95, 32, 243, 83, 160, 160, 244, 95, 65, 32, 245, 51, 130, 160, 246, 63, 35, 32, 247, 19, 100, 160, 248, 31, 5, 32, 248, 243, 70, 160, 249, 254, 231, 32, 250, 211, 40, 160, 251, 232, 3, 160, 252, 188, 69, 32, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 5, 255, 255, 235, 96, 0, 0, 0, 0, 0, 0, 1, 4, 255, 255, 241, 240, 0, 8, 255, 255, 241, 240, 0, 8, 0, 0, 0, 0, 1, 4, 0, 0, 0, 0, 0, 12, 76, 77, 84, 0, 43, 48, 48, 0, 45, 48, 49, 0, 71, 77, 84, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Atlantic/South_Georgia": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 127, 255, 255, 255, 1, 1, 255, 255, 221, 192, 0, 0, 255, 255, 227, 224, 0, 4, 76, 77, 84, 0, 45, 48, 50, 0, 0, 0, 0, 0, 10, 60, 45, 48, 50, 62, 50, 10}, - - "zoneinfo/Atlantic/St_Helena": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 146, 230, 146, 72, 0, 1, 255, 255, 252, 56, 0, 0, 0, 0, 0, 0, 0, 4, 76, 77, 84, 0, 71, 77, 84, 0, 0, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Atlantic/Stanley": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 71, 0, 0, 0, 7, 0, 0, 0, 20, 128, 0, 0, 0, 147, 68, 95, 60, 195, 79, 90, 192, 196, 54, 3, 48, 197, 47, 60, 192, 198, 21, 229, 48, 199, 24, 89, 64, 199, 255, 1, 176, 200, 248, 59, 64, 201, 222, 227, 176, 202, 216, 29, 64, 203, 190, 197, 176, 204, 183, 255, 64, 205, 54, 129, 48, 25, 17, 254, 64, 25, 211, 188, 176, 26, 241, 196, 32, 27, 170, 100, 48, 28, 209, 166, 32, 29, 138, 70, 48, 30, 168, 91, 176, 31, 106, 54, 64, 32, 136, 61, 176, 33, 74, 24, 64, 34, 104, 31, 176, 35, 41, 250, 64, 36, 72, 1, 176, 37, 9, 220, 64, 38, 49, 30, 48, 38, 233, 190, 64, 40, 17, 0, 48, 40, 210, 218, 192, 41, 240, 226, 48, 42, 178, 188, 192, 43, 208, 196, 48, 44, 146, 158, 192, 45, 176, 166, 48, 46, 114, 128, 192, 47, 144, 136, 48, 48, 82, 98, 192, 49, 121, 164, 176, 50, 59, 127, 64, 51, 89, 134, 176, 52, 27, 97, 64, 53, 57, 104, 176, 53, 251, 67, 64, 55, 25, 74, 176, 55, 219, 37, 64, 56, 249, 44, 176, 57, 187, 7, 64, 58, 217, 42, 208, 59, 145, 202, 224, 60, 194, 71, 80, 61, 113, 172, 224, 62, 162, 41, 80, 63, 90, 201, 96, 64, 130, 11, 80, 65, 58, 171, 96, 66, 97, 237, 80, 67, 26, 141, 96, 68, 65, 207, 80, 68, 250, 111, 96, 70, 33, 177, 80, 70, 218, 81, 96, 72, 10, 205, 208, 72, 195, 109, 224, 73, 234, 175, 208, 74, 163, 79, 224, 75, 202, 145, 208, 76, 131, 49, 224, 127, 255, 255, 255, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 5, 4, 5, 4, 5, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 5, 5, 255, 255, 201, 196, 0, 0, 255, 255, 201, 196, 0, 4, 255, 255, 213, 208, 1, 8, 255, 255, 199, 192, 0, 12, 255, 255, 227, 224, 1, 16, 255, 255, 213, 208, 0, 8, 255, 255, 213, 208, 1, 8, 76, 77, 84, 0, 83, 77, 84, 0, 45, 48, 51, 0, 45, 48, 52, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/Australia/ACT": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 5, 0, 0, 0, 14, 128, 0, 0, 0, 156, 78, 166, 156, 156, 188, 32, 240, 203, 84, 179, 0, 203, 199, 87, 112, 204, 183, 86, 128, 205, 167, 57, 112, 206, 160, 115, 0, 207, 135, 27, 112, 3, 112, 57, 128, 4, 13, 28, 0, 5, 80, 27, 128, 5, 246, 56, 128, 7, 47, 253, 128, 7, 214, 26, 128, 9, 15, 223, 128, 9, 181, 252, 128, 10, 239, 193, 128, 11, 159, 25, 0, 12, 216, 222, 0, 13, 126, 251, 0, 14, 184, 192, 0, 15, 94, 221, 0, 16, 152, 162, 0, 17, 62, 191, 0, 18, 120, 132, 0, 19, 30, 161, 0, 20, 88, 102, 0, 20, 254, 131, 0, 22, 56, 72, 0, 23, 12, 137, 128, 24, 33, 100, 128, 24, 199, 129, 128, 26, 1, 70, 128, 26, 167, 99, 128, 27, 225, 40, 128, 28, 135, 69, 128, 29, 193, 10, 128, 30, 121, 156, 128, 31, 151, 178, 0, 32, 89, 126, 128, 33, 128, 206, 128, 34, 66, 155, 0, 35, 105, 235, 0, 36, 34, 125, 0, 37, 73, 205, 0, 37, 239, 234, 0, 39, 41, 175, 0, 39, 207, 204, 0, 41, 9, 145, 0, 41, 175, 174, 0, 42, 233, 115, 0, 43, 152, 202, 128, 44, 210, 143, 128, 45, 120, 172, 128, 46, 178, 113, 128, 47, 88, 142, 128, 48, 146, 83, 128, 49, 93, 90, 128, 50, 114, 53, 128, 51, 61, 60, 128, 52, 82, 23, 128, 53, 29, 30, 128, 54, 49, 249, 128, 54, 253, 0, 128, 56, 27, 22, 0, 56, 220, 226, 128, 57, 167, 233, 128, 58, 188, 196, 128, 59, 218, 218, 0, 60, 165, 225, 0, 61, 186, 188, 0, 62, 133, 195, 0, 63, 154, 158, 0, 64, 101, 165, 0, 65, 131, 186, 128, 66, 69, 135, 0, 67, 99, 156, 128, 68, 46, 163, 128, 69, 67, 126, 128, 70, 5, 75, 0, 71, 35, 96, 128, 71, 247, 162, 0, 72, 231, 147, 0, 73, 215, 132, 0, 74, 199, 117, 0, 75, 183, 102, 0, 76, 167, 87, 0, 77, 151, 72, 0, 78, 135, 57, 0, 79, 119, 42, 0, 80, 112, 85, 128, 81, 96, 70, 128, 82, 80, 55, 128, 83, 64, 40, 128, 84, 48, 25, 128, 85, 32, 10, 128, 86, 15, 251, 128, 86, 255, 236, 128, 87, 239, 221, 128, 88, 223, 206, 128, 89, 207, 191, 128, 90, 191, 176, 128, 91, 184, 220, 0, 92, 168, 205, 0, 93, 152, 190, 0, 94, 136, 175, 0, 95, 120, 160, 0, 96, 104, 145, 0, 97, 88, 130, 0, 98, 72, 115, 0, 99, 56, 100, 0, 100, 40, 85, 0, 101, 24, 70, 0, 102, 17, 113, 128, 103, 1, 98, 128, 103, 241, 83, 128, 104, 225, 68, 128, 105, 209, 53, 128, 106, 193, 38, 128, 107, 177, 23, 128, 108, 161, 8, 128, 109, 144, 249, 128, 110, 128, 234, 128, 111, 112, 219, 128, 112, 106, 7, 0, 113, 89, 248, 0, 114, 73, 233, 0, 115, 57, 218, 0, 116, 41, 203, 0, 117, 25, 188, 0, 118, 9, 173, 0, 118, 249, 158, 0, 119, 233, 143, 0, 120, 217, 128, 0, 121, 201, 113, 0, 122, 185, 98, 0, 123, 178, 141, 128, 124, 162, 126, 128, 125, 146, 111, 128, 126, 130, 96, 128, 127, 114, 81, 128, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 141, 196, 0, 0, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 76, 77, 84, 0, 65, 69, 68, 84, 0, 65, 69, 83, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 69, 83, 84, 45, 49, 48, 65, 69, 68, 84, 44, 77, 49, 48, 46, 49, 46, 48, 44, 77, 52, 46, 49, 46, 48, 47, 51, 10}, - - "zoneinfo/Australia/Adelaide": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 5, 0, 0, 0, 10, 128, 0, 0, 0, 156, 78, 173, 164, 156, 188, 39, 248, 203, 84, 186, 8, 203, 199, 94, 120, 204, 183, 93, 136, 205, 167, 64, 120, 206, 160, 122, 8, 207, 135, 34, 120, 3, 112, 64, 136, 4, 13, 35, 8, 5, 80, 34, 136, 5, 246, 63, 136, 7, 48, 4, 136, 7, 214, 33, 136, 9, 15, 230, 136, 9, 182, 3, 136, 10, 239, 200, 136, 11, 159, 32, 8, 12, 216, 229, 8, 13, 127, 2, 8, 14, 184, 199, 8, 15, 94, 228, 8, 16, 152, 169, 8, 17, 62, 198, 8, 18, 120, 139, 8, 19, 30, 168, 8, 20, 88, 109, 8, 20, 254, 138, 8, 22, 56, 79, 8, 22, 231, 166, 136, 24, 33, 107, 136, 24, 199, 136, 136, 26, 1, 77, 136, 26, 167, 106, 136, 27, 225, 47, 136, 28, 135, 76, 136, 29, 193, 17, 136, 30, 121, 163, 136, 31, 151, 185, 8, 32, 89, 133, 136, 33, 128, 213, 136, 34, 66, 162, 8, 35, 105, 242, 8, 36, 34, 132, 8, 37, 73, 212, 8, 38, 2, 102, 8, 39, 41, 182, 8, 39, 207, 211, 8, 41, 9, 152, 8, 41, 203, 100, 136, 42, 233, 122, 8, 43, 152, 209, 136, 44, 210, 150, 136, 45, 139, 40, 136, 46, 178, 120, 136, 47, 116, 69, 8, 48, 146, 90, 136, 49, 93, 97, 136, 50, 114, 60, 136, 51, 61, 67, 136, 52, 82, 30, 136, 53, 29, 37, 136, 54, 50, 0, 136, 54, 253, 7, 136, 56, 27, 29, 8, 56, 220, 233, 136, 57, 250, 255, 8, 58, 188, 203, 136, 59, 218, 225, 8, 60, 165, 232, 8, 61, 186, 195, 8, 62, 133, 202, 8, 63, 154, 165, 8, 64, 101, 172, 8, 65, 131, 193, 136, 66, 69, 142, 8, 67, 99, 163, 136, 68, 46, 170, 136, 69, 67, 133, 136, 70, 5, 82, 8, 71, 35, 103, 136, 71, 247, 169, 8, 72, 231, 154, 8, 73, 215, 139, 8, 74, 199, 124, 8, 75, 183, 109, 8, 76, 167, 94, 8, 77, 151, 79, 8, 78, 135, 64, 8, 79, 119, 49, 8, 80, 112, 92, 136, 81, 96, 77, 136, 82, 80, 62, 136, 83, 64, 47, 136, 84, 48, 32, 136, 85, 32, 17, 136, 86, 16, 2, 136, 86, 255, 243, 136, 87, 239, 228, 136, 88, 223, 213, 136, 89, 207, 198, 136, 90, 191, 183, 136, 91, 184, 227, 8, 92, 168, 212, 8, 93, 152, 197, 8, 94, 136, 182, 8, 95, 120, 167, 8, 96, 104, 152, 8, 97, 88, 137, 8, 98, 72, 122, 8, 99, 56, 107, 8, 100, 40, 92, 8, 101, 24, 77, 8, 102, 17, 120, 136, 103, 1, 105, 136, 103, 241, 90, 136, 104, 225, 75, 136, 105, 209, 60, 136, 106, 193, 45, 136, 107, 177, 30, 136, 108, 161, 15, 136, 109, 145, 0, 136, 110, 128, 241, 136, 111, 112, 226, 136, 112, 106, 14, 8, 113, 89, 255, 8, 114, 73, 240, 8, 115, 57, 225, 8, 116, 41, 210, 8, 117, 25, 195, 8, 118, 9, 180, 8, 118, 249, 165, 8, 119, 233, 150, 8, 120, 217, 135, 8, 121, 201, 120, 8, 122, 185, 105, 8, 123, 178, 148, 136, 124, 162, 133, 136, 125, 146, 118, 136, 126, 130, 103, 136, 127, 114, 88, 136, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 126, 144, 0, 0, 0, 0, 147, 168, 1, 5, 0, 0, 133, 152, 0, 0, 0, 0, 147, 168, 1, 5, 0, 0, 133, 152, 0, 0, 65, 67, 83, 84, 0, 65, 67, 68, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 67, 83, 84, 45, 57, 58, 51, 48, 65, 67, 68, 84, 44, 77, 49, 48, 46, 49, 46, 48, 44, 77, 52, 46, 49, 46, 48, 47, 51, 10}, - - "zoneinfo/Australia/Brisbane": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 5, 0, 0, 0, 14, 128, 0, 0, 0, 156, 78, 166, 156, 156, 188, 32, 240, 203, 84, 179, 0, 203, 199, 87, 112, 204, 183, 86, 128, 205, 167, 57, 112, 206, 160, 115, 0, 207, 135, 27, 112, 3, 112, 57, 128, 4, 13, 28, 0, 37, 73, 205, 0, 37, 239, 234, 0, 39, 41, 175, 0, 39, 207, 204, 0, 41, 9, 145, 0, 41, 175, 174, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 0, 0, 143, 120, 0, 0, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 76, 77, 84, 0, 65, 69, 68, 84, 0, 65, 69, 83, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 69, 83, 84, 45, 49, 48, 10}, - - "zoneinfo/Australia/Broken_Hill": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 143, 0, 0, 0, 5, 0, 0, 0, 10, 128, 0, 0, 0, 156, 78, 173, 164, 156, 188, 39, 248, 203, 84, 186, 8, 203, 199, 94, 120, 204, 183, 93, 136, 205, 167, 64, 120, 206, 160, 122, 8, 207, 135, 34, 120, 3, 112, 64, 136, 4, 13, 35, 8, 5, 80, 34, 136, 5, 246, 63, 136, 7, 48, 4, 136, 7, 214, 33, 136, 9, 15, 230, 136, 9, 182, 3, 136, 10, 239, 200, 136, 11, 159, 32, 8, 12, 216, 229, 8, 13, 127, 2, 8, 14, 184, 199, 8, 15, 94, 228, 8, 16, 152, 169, 8, 17, 62, 198, 8, 18, 120, 139, 8, 19, 30, 168, 8, 20, 88, 109, 8, 20, 254, 138, 8, 22, 56, 79, 8, 23, 12, 144, 136, 24, 33, 107, 136, 24, 199, 136, 136, 26, 1, 77, 136, 26, 167, 106, 136, 27, 225, 47, 136, 28, 135, 76, 136, 29, 193, 17, 136, 30, 121, 163, 136, 31, 151, 185, 8, 32, 89, 133, 136, 33, 128, 213, 136, 34, 66, 162, 8, 35, 105, 242, 8, 36, 34, 132, 8, 37, 73, 212, 8, 37, 239, 241, 8, 39, 41, 182, 8, 39, 207, 211, 8, 41, 9, 152, 8, 41, 175, 181, 8, 42, 233, 122, 8, 43, 152, 209, 136, 44, 210, 150, 136, 45, 120, 179, 136, 46, 178, 120, 136, 47, 88, 149, 136, 48, 146, 90, 136, 49, 93, 97, 136, 50, 114, 60, 136, 51, 61, 67, 136, 52, 82, 30, 136, 53, 29, 37, 136, 54, 50, 0, 136, 54, 253, 7, 136, 56, 27, 29, 8, 56, 108, 175, 216, 56, 220, 233, 136, 57, 250, 255, 8, 58, 188, 203, 136, 59, 218, 225, 8, 60, 165, 232, 8, 61, 186, 195, 8, 62, 133, 202, 8, 63, 154, 165, 8, 64, 101, 172, 8, 65, 131, 193, 136, 66, 69, 142, 8, 67, 99, 163, 136, 68, 46, 170, 136, 69, 67, 133, 136, 70, 5, 82, 8, 71, 35, 103, 136, 71, 247, 169, 8, 72, 231, 154, 8, 73, 215, 139, 8, 74, 199, 124, 8, 75, 183, 109, 8, 76, 167, 94, 8, 77, 151, 79, 8, 78, 135, 64, 8, 79, 119, 49, 8, 80, 112, 92, 136, 81, 96, 77, 136, 82, 80, 62, 136, 83, 64, 47, 136, 84, 48, 32, 136, 85, 32, 17, 136, 86, 16, 2, 136, 86, 255, 243, 136, 87, 239, 228, 136, 88, 223, 213, 136, 89, 207, 198, 136, 90, 191, 183, 136, 91, 184, 227, 8, 92, 168, 212, 8, 93, 152, 197, 8, 94, 136, 182, 8, 95, 120, 167, 8, 96, 104, 152, 8, 97, 88, 137, 8, 98, 72, 122, 8, 99, 56, 107, 8, 100, 40, 92, 8, 101, 24, 77, 8, 102, 17, 120, 136, 103, 1, 105, 136, 103, 241, 90, 136, 104, 225, 75, 136, 105, 209, 60, 136, 106, 193, 45, 136, 107, 177, 30, 136, 108, 161, 15, 136, 109, 145, 0, 136, 110, 128, 241, 136, 111, 112, 226, 136, 112, 106, 14, 8, 113, 89, 255, 8, 114, 73, 240, 8, 115, 57, 225, 8, 116, 41, 210, 8, 117, 25, 195, 8, 118, 9, 180, 8, 118, 249, 165, 8, 119, 233, 150, 8, 120, 217, 135, 8, 121, 201, 120, 8, 122, 185, 105, 8, 123, 178, 148, 136, 124, 162, 133, 136, 125, 146, 118, 136, 126, 130, 103, 136, 127, 114, 88, 136, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 1, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 126, 144, 0, 0, 0, 0, 147, 168, 1, 5, 0, 0, 133, 152, 0, 0, 0, 0, 147, 168, 1, 5, 0, 0, 133, 152, 0, 0, 65, 67, 83, 84, 0, 65, 67, 68, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 67, 83, 84, 45, 57, 58, 51, 48, 65, 67, 68, 84, 44, 77, 49, 48, 46, 49, 46, 48, 44, 77, 52, 46, 49, 46, 48, 47, 51, 10}, - - "zoneinfo/Australia/Canberra": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 5, 0, 0, 0, 14, 128, 0, 0, 0, 156, 78, 166, 156, 156, 188, 32, 240, 203, 84, 179, 0, 203, 199, 87, 112, 204, 183, 86, 128, 205, 167, 57, 112, 206, 160, 115, 0, 207, 135, 27, 112, 3, 112, 57, 128, 4, 13, 28, 0, 5, 80, 27, 128, 5, 246, 56, 128, 7, 47, 253, 128, 7, 214, 26, 128, 9, 15, 223, 128, 9, 181, 252, 128, 10, 239, 193, 128, 11, 159, 25, 0, 12, 216, 222, 0, 13, 126, 251, 0, 14, 184, 192, 0, 15, 94, 221, 0, 16, 152, 162, 0, 17, 62, 191, 0, 18, 120, 132, 0, 19, 30, 161, 0, 20, 88, 102, 0, 20, 254, 131, 0, 22, 56, 72, 0, 23, 12, 137, 128, 24, 33, 100, 128, 24, 199, 129, 128, 26, 1, 70, 128, 26, 167, 99, 128, 27, 225, 40, 128, 28, 135, 69, 128, 29, 193, 10, 128, 30, 121, 156, 128, 31, 151, 178, 0, 32, 89, 126, 128, 33, 128, 206, 128, 34, 66, 155, 0, 35, 105, 235, 0, 36, 34, 125, 0, 37, 73, 205, 0, 37, 239, 234, 0, 39, 41, 175, 0, 39, 207, 204, 0, 41, 9, 145, 0, 41, 175, 174, 0, 42, 233, 115, 0, 43, 152, 202, 128, 44, 210, 143, 128, 45, 120, 172, 128, 46, 178, 113, 128, 47, 88, 142, 128, 48, 146, 83, 128, 49, 93, 90, 128, 50, 114, 53, 128, 51, 61, 60, 128, 52, 82, 23, 128, 53, 29, 30, 128, 54, 49, 249, 128, 54, 253, 0, 128, 56, 27, 22, 0, 56, 220, 226, 128, 57, 167, 233, 128, 58, 188, 196, 128, 59, 218, 218, 0, 60, 165, 225, 0, 61, 186, 188, 0, 62, 133, 195, 0, 63, 154, 158, 0, 64, 101, 165, 0, 65, 131, 186, 128, 66, 69, 135, 0, 67, 99, 156, 128, 68, 46, 163, 128, 69, 67, 126, 128, 70, 5, 75, 0, 71, 35, 96, 128, 71, 247, 162, 0, 72, 231, 147, 0, 73, 215, 132, 0, 74, 199, 117, 0, 75, 183, 102, 0, 76, 167, 87, 0, 77, 151, 72, 0, 78, 135, 57, 0, 79, 119, 42, 0, 80, 112, 85, 128, 81, 96, 70, 128, 82, 80, 55, 128, 83, 64, 40, 128, 84, 48, 25, 128, 85, 32, 10, 128, 86, 15, 251, 128, 86, 255, 236, 128, 87, 239, 221, 128, 88, 223, 206, 128, 89, 207, 191, 128, 90, 191, 176, 128, 91, 184, 220, 0, 92, 168, 205, 0, 93, 152, 190, 0, 94, 136, 175, 0, 95, 120, 160, 0, 96, 104, 145, 0, 97, 88, 130, 0, 98, 72, 115, 0, 99, 56, 100, 0, 100, 40, 85, 0, 101, 24, 70, 0, 102, 17, 113, 128, 103, 1, 98, 128, 103, 241, 83, 128, 104, 225, 68, 128, 105, 209, 53, 128, 106, 193, 38, 128, 107, 177, 23, 128, 108, 161, 8, 128, 109, 144, 249, 128, 110, 128, 234, 128, 111, 112, 219, 128, 112, 106, 7, 0, 113, 89, 248, 0, 114, 73, 233, 0, 115, 57, 218, 0, 116, 41, 203, 0, 117, 25, 188, 0, 118, 9, 173, 0, 118, 249, 158, 0, 119, 233, 143, 0, 120, 217, 128, 0, 121, 201, 113, 0, 122, 185, 98, 0, 123, 178, 141, 128, 124, 162, 126, 128, 125, 146, 111, 128, 126, 130, 96, 128, 127, 114, 81, 128, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 141, 196, 0, 0, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 76, 77, 84, 0, 65, 69, 68, 84, 0, 65, 69, 83, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 69, 83, 84, 45, 49, 48, 65, 69, 68, 84, 44, 77, 49, 48, 46, 49, 46, 48, 44, 77, 52, 46, 49, 46, 48, 47, 51, 10}, - - "zoneinfo/Australia/Currie": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 5, 0, 0, 0, 14, 128, 0, 0, 0, 155, 213, 120, 128, 156, 188, 32, 240, 203, 84, 179, 0, 203, 199, 87, 112, 204, 183, 86, 128, 205, 167, 57, 112, 206, 160, 115, 0, 207, 135, 27, 112, 3, 112, 57, 128, 4, 13, 28, 0, 5, 80, 27, 128, 5, 246, 56, 128, 7, 47, 253, 128, 7, 214, 26, 128, 9, 15, 223, 128, 9, 181, 252, 128, 10, 239, 193, 128, 11, 159, 25, 0, 12, 216, 222, 0, 13, 126, 251, 0, 14, 184, 192, 0, 15, 94, 221, 0, 16, 152, 162, 0, 17, 62, 191, 0, 18, 120, 132, 0, 19, 30, 161, 0, 20, 88, 102, 0, 20, 254, 131, 0, 22, 56, 72, 0, 23, 3, 79, 0, 24, 33, 100, 128, 24, 227, 49, 0, 26, 1, 70, 128, 26, 167, 99, 128, 27, 225, 40, 128, 28, 135, 69, 128, 29, 193, 10, 128, 30, 103, 39, 128, 31, 151, 178, 0, 32, 89, 126, 128, 33, 128, 206, 128, 34, 66, 155, 0, 35, 105, 235, 0, 36, 34, 125, 0, 37, 73, 205, 0, 38, 2, 95, 0, 39, 41, 175, 0, 39, 244, 182, 0, 40, 237, 225, 128, 41, 212, 152, 0, 42, 205, 195, 128, 43, 180, 122, 0, 44, 173, 165, 128, 45, 148, 92, 0, 46, 141, 135, 128, 47, 116, 62, 0, 48, 109, 105, 128, 49, 93, 90, 128, 50, 86, 134, 0, 51, 61, 60, 128, 52, 54, 104, 0, 53, 29, 30, 128, 54, 22, 74, 0, 54, 253, 0, 128, 55, 246, 44, 0, 56, 220, 226, 128, 57, 167, 233, 128, 58, 188, 196, 128, 59, 191, 42, 128, 60, 165, 225, 0, 61, 159, 12, 128, 62, 133, 195, 0, 63, 126, 238, 128, 64, 101, 165, 0, 65, 94, 208, 128, 66, 69, 135, 0, 67, 62, 178, 128, 68, 46, 163, 128, 69, 30, 148, 128, 70, 5, 75, 0, 71, 7, 177, 0, 71, 247, 162, 0, 72, 231, 147, 0, 73, 215, 132, 0, 74, 199, 117, 0, 75, 183, 102, 0, 76, 167, 87, 0, 77, 151, 72, 0, 78, 135, 57, 0, 79, 119, 42, 0, 80, 112, 85, 128, 81, 96, 70, 128, 82, 80, 55, 128, 83, 64, 40, 128, 84, 48, 25, 128, 85, 32, 10, 128, 86, 15, 251, 128, 86, 255, 236, 128, 87, 239, 221, 128, 88, 223, 206, 128, 89, 207, 191, 128, 90, 191, 176, 128, 91, 184, 220, 0, 92, 168, 205, 0, 93, 152, 190, 0, 94, 136, 175, 0, 95, 120, 160, 0, 96, 104, 145, 0, 97, 88, 130, 0, 98, 72, 115, 0, 99, 56, 100, 0, 100, 40, 85, 0, 101, 24, 70, 0, 102, 17, 113, 128, 103, 1, 98, 128, 103, 241, 83, 128, 104, 225, 68, 128, 105, 209, 53, 128, 106, 193, 38, 128, 107, 177, 23, 128, 108, 161, 8, 128, 109, 144, 249, 128, 110, 128, 234, 128, 111, 112, 219, 128, 112, 106, 7, 0, 113, 89, 248, 0, 114, 73, 233, 0, 115, 57, 218, 0, 116, 41, 203, 0, 117, 25, 188, 0, 118, 9, 173, 0, 118, 249, 158, 0, 119, 233, 143, 0, 120, 217, 128, 0, 121, 201, 113, 0, 122, 185, 98, 0, 123, 178, 141, 128, 124, 162, 126, 128, 125, 146, 111, 128, 126, 130, 96, 128, 127, 114, 81, 128, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 134, 224, 0, 0, 0, 0, 140, 160, 0, 4, 0, 0, 154, 176, 1, 9, 0, 0, 154, 176, 1, 9, 0, 0, 140, 160, 0, 4, 76, 77, 84, 0, 65, 69, 83, 84, 0, 65, 69, 68, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 69, 83, 84, 45, 49, 48, 65, 69, 68, 84, 44, 77, 49, 48, 46, 49, 46, 48, 44, 77, 52, 46, 49, 46, 48, 47, 51, 10}, - - "zoneinfo/Australia/Darwin": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 3, 0, 0, 0, 10, 128, 0, 0, 0, 156, 78, 173, 164, 156, 188, 39, 248, 203, 84, 186, 8, 203, 199, 94, 120, 204, 183, 93, 136, 205, 167, 64, 120, 206, 160, 122, 8, 207, 135, 34, 120, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 126, 144, 0, 0, 0, 0, 147, 168, 1, 5, 0, 0, 133, 152, 0, 0, 65, 67, 83, 84, 0, 65, 67, 68, 84, 0, 0, 0, 0, 0, 0, 0, 10, 65, 67, 83, 84, 45, 57, 58, 51, 48, 10}, - - "zoneinfo/Australia/Eucla": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 20, 0, 0, 0, 5, 0, 0, 0, 16, 128, 0, 0, 0, 156, 78, 184, 48, 156, 188, 50, 132, 203, 84, 196, 148, 203, 199, 105, 4, 204, 183, 104, 20, 205, 167, 75, 4, 9, 15, 241, 20, 9, 182, 14, 20, 26, 1, 88, 20, 26, 167, 117, 20, 41, 37, 82, 20, 41, 175, 191, 148, 69, 113, 180, 148, 70, 5, 92, 148, 71, 35, 114, 20, 71, 238, 121, 20, 73, 3, 84, 20, 73, 206, 91, 20, 127, 255, 255, 255, 2, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 4, 0, 0, 120, 208, 0, 0, 0, 0, 137, 28, 1, 4, 0, 0, 123, 12, 0, 10, 0, 0, 137, 28, 1, 4, 0, 0, 123, 12, 0, 10, 76, 77, 84, 0, 43, 48, 57, 52, 53, 0, 43, 48, 56, 52, 53, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 60, 43, 48, 56, 52, 53, 62, 45, 56, 58, 52, 53, 10}, - - "zoneinfo/Australia/Hobart": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 150, 0, 0, 0, 5, 0, 0, 0, 14, 128, 0, 0, 0, 155, 213, 120, 128, 156, 188, 32, 240, 203, 84, 179, 0, 203, 199, 87, 112, 204, 183, 86, 128, 205, 167, 57, 112, 206, 160, 115, 0, 207, 135, 27, 112, 251, 194, 141, 0, 252, 178, 126, 0, 253, 199, 89, 0, 254, 118, 176, 128, 255, 167, 59, 0, 0, 86, 146, 128, 1, 135, 29, 0, 2, 63, 175, 0, 3, 112, 57, 128, 4, 13, 28, 0, 5, 80, 27, 128, 5, 246, 56, 128, 7, 47, 253, 128, 7, 214, 26, 128, 9, 15, 223, 128, 9, 181, 252, 128, 10, 239, 193, 128, 11, 159, 25, 0, 12, 216, 222, 0, 13, 126, 251, 0, 14, 184, 192, 0, 15, 94, 221, 0, 16, 152, 162, 0, 17, 62, 191, 0, 18, 120, 132, 0, 19, 30, 161, 0, 20, 88, 102, 0, 20, 254, 131, 0, 22, 56, 72, 0, 23, 3, 79, 0, 24, 33, 100, 128, 24, 227, 49, 0, 26, 1, 70, 128, 26, 167, 99, 128, 27, 225, 40, 128, 28, 135, 69, 128, 29, 193, 10, 128, 30, 103, 39, 128, 31, 151, 178, 0, 32, 89, 126, 128, 33, 128, 206, 128, 34, 66, 155, 0, 35, 105, 235, 0, 36, 34, 125, 0, 37, 73, 205, 0, 38, 2, 95, 0, 39, 41, 175, 0, 39, 244, 182, 0, 40, 237, 225, 128, 41, 212, 152, 0, 42, 205, 195, 128, 43, 180, 122, 0, 44, 173, 165, 128, 45, 148, 92, 0, 46, 141, 135, 128, 47, 116, 62, 0, 48, 109, 105, 128, 49, 93, 90, 128, 50, 86, 134, 0, 51, 61, 60, 128, 52, 54, 104, 0, 53, 29, 30, 128, 54, 22, 74, 0, 54, 253, 0, 128, 55, 246, 44, 0, 56, 220, 226, 128, 57, 167, 233, 128, 58, 188, 196, 128, 59, 191, 42, 128, 60, 165, 225, 0, 61, 159, 12, 128, 62, 133, 195, 0, 63, 126, 238, 128, 64, 101, 165, 0, 65, 94, 208, 128, 66, 69, 135, 0, 67, 62, 178, 128, 68, 46, 163, 128, 69, 30, 148, 128, 70, 5, 75, 0, 71, 7, 177, 0, 71, 247, 162, 0, 72, 231, 147, 0, 73, 215, 132, 0, 74, 199, 117, 0, 75, 183, 102, 0, 76, 167, 87, 0, 77, 151, 72, 0, 78, 135, 57, 0, 79, 119, 42, 0, 80, 112, 85, 128, 81, 96, 70, 128, 82, 80, 55, 128, 83, 64, 40, 128, 84, 48, 25, 128, 85, 32, 10, 128, 86, 15, 251, 128, 86, 255, 236, 128, 87, 239, 221, 128, 88, 223, 206, 128, 89, 207, 191, 128, 90, 191, 176, 128, 91, 184, 220, 0, 92, 168, 205, 0, 93, 152, 190, 0, 94, 136, 175, 0, 95, 120, 160, 0, 96, 104, 145, 0, 97, 88, 130, 0, 98, 72, 115, 0, 99, 56, 100, 0, 100, 40, 85, 0, 101, 24, 70, 0, 102, 17, 113, 128, 103, 1, 98, 128, 103, 241, 83, 128, 104, 225, 68, 128, 105, 209, 53, 128, 106, 193, 38, 128, 107, 177, 23, 128, 108, 161, 8, 128, 109, 144, 249, 128, 110, 128, 234, 128, 111, 112, 219, 128, 112, 106, 7, 0, 113, 89, 248, 0, 114, 73, 233, 0, 115, 57, 218, 0, 116, 41, 203, 0, 117, 25, 188, 0, 118, 9, 173, 0, 118, 249, 158, 0, 119, 233, 143, 0, 120, 217, 128, 0, 121, 201, 113, 0, 122, 185, 98, 0, 123, 178, 141, 128, 124, 162, 126, 128, 125, 146, 111, 128, 126, 130, 96, 128, 127, 114, 81, 128, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 138, 28, 0, 0, 0, 0, 140, 160, 0, 4, 0, 0, 154, 176, 1, 9, 0, 0, 154, 176, 1, 9, 0, 0, 140, 160, 0, 4, 76, 77, 84, 0, 65, 69, 83, 84, 0, 65, 69, 68, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 69, 83, 84, 45, 49, 48, 65, 69, 68, 84, 44, 77, 49, 48, 46, 49, 46, 48, 44, 77, 52, 46, 49, 46, 48, 47, 51, 10}, - - "zoneinfo/Australia/LHI": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 116, 0, 0, 0, 5, 0, 0, 0, 25, 128, 0, 0, 0, 20, 254, 102, 224, 22, 56, 64, 248, 22, 231, 138, 104, 24, 33, 93, 120, 24, 199, 108, 104, 26, 1, 63, 120, 26, 167, 78, 104, 27, 225, 33, 120, 28, 135, 48, 104, 29, 193, 3, 120, 30, 121, 142, 112, 31, 151, 170, 248, 32, 89, 112, 112, 33, 128, 199, 120, 34, 66, 140, 240, 35, 105, 227, 248, 36, 34, 110, 240, 37, 73, 197, 248, 37, 239, 219, 240, 39, 41, 167, 248, 39, 207, 189, 240, 41, 9, 137, 248, 41, 175, 159, 240, 42, 233, 107, 248, 43, 152, 188, 112, 44, 210, 136, 120, 45, 120, 158, 112, 46, 178, 106, 120, 47, 88, 128, 112, 48, 146, 76, 120, 49, 93, 76, 112, 50, 114, 46, 120, 51, 61, 46, 112, 52, 82, 16, 120, 53, 29, 16, 112, 54, 49, 242, 120, 54, 252, 242, 112, 56, 27, 14, 248, 56, 220, 212, 112, 57, 167, 226, 120, 58, 188, 182, 112, 59, 218, 210, 248, 60, 165, 210, 240, 61, 186, 180, 248, 62, 133, 180, 240, 63, 154, 150, 248, 64, 101, 150, 240, 65, 131, 179, 120, 66, 69, 120, 240, 67, 99, 149, 120, 68, 46, 149, 112, 69, 67, 119, 120, 70, 5, 60, 240, 71, 35, 89, 120, 71, 247, 147, 240, 72, 231, 139, 248, 73, 215, 117, 240, 74, 199, 109, 248, 75, 183, 87, 240, 76, 167, 79, 248, 77, 151, 57, 240, 78, 135, 49, 248, 79, 119, 27, 240, 80, 112, 78, 120, 81, 96, 56, 112, 82, 80, 48, 120, 83, 64, 26, 112, 84, 48, 18, 120, 85, 31, 252, 112, 86, 15, 244, 120, 86, 255, 222, 112, 87, 239, 214, 120, 88, 223, 192, 112, 89, 207, 184, 120, 90, 191, 162, 112, 91, 184, 212, 248, 92, 168, 190, 240, 93, 152, 182, 248, 94, 136, 160, 240, 95, 120, 152, 248, 96, 104, 130, 240, 97, 88, 122, 248, 98, 72, 100, 240, 99, 56, 92, 248, 100, 40, 70, 240, 101, 24, 62, 248, 102, 17, 99, 112, 103, 1, 91, 120, 103, 241, 69, 112, 104, 225, 61, 120, 105, 209, 39, 112, 106, 193, 31, 120, 107, 177, 9, 112, 108, 161, 1, 120, 109, 144, 235, 112, 110, 128, 227, 120, 111, 112, 205, 112, 112, 105, 255, 248, 113, 89, 233, 240, 114, 73, 225, 248, 115, 57, 203, 240, 116, 41, 195, 248, 117, 25, 173, 240, 118, 9, 165, 248, 118, 249, 143, 240, 119, 233, 135, 248, 120, 217, 113, 240, 121, 201, 105, 248, 122, 185, 83, 240, 123, 178, 134, 120, 124, 162, 112, 112, 125, 146, 104, 120, 126, 130, 82, 112, 127, 114, 74, 120, 127, 255, 255, 255, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 4, 0, 0, 149, 36, 0, 0, 0, 0, 140, 160, 0, 4, 0, 0, 161, 184, 1, 9, 0, 0, 147, 168, 0, 15, 0, 0, 154, 176, 1, 21, 76, 77, 84, 0, 65, 69, 83, 84, 0, 43, 49, 49, 51, 48, 0, 43, 49, 48, 51, 48, 0, 43, 49, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 48, 51, 48, 62, 45, 49, 48, 58, 51, 48, 60, 43, 49, 49, 62, 45, 49, 49, 44, 77, 49, 48, 46, 49, 46, 48, 44, 77, 52, 46, 49, 46, 48, 10}, - - "zoneinfo/Australia/Lindeman": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 5, 0, 0, 0, 14, 128, 0, 0, 0, 156, 78, 166, 156, 156, 188, 32, 240, 203, 84, 179, 0, 203, 199, 87, 112, 204, 183, 86, 128, 205, 167, 57, 112, 206, 160, 115, 0, 207, 135, 27, 112, 3, 112, 57, 128, 4, 13, 28, 0, 37, 73, 205, 0, 37, 239, 234, 0, 39, 41, 175, 0, 39, 207, 204, 0, 41, 9, 145, 0, 41, 175, 174, 0, 42, 80, 104, 224, 42, 233, 115, 0, 43, 152, 202, 128, 44, 210, 143, 128, 45, 120, 172, 128, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 2, 3, 4, 3, 4, 0, 0, 139, 172, 0, 0, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 76, 77, 84, 0, 65, 69, 68, 84, 0, 65, 69, 83, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 69, 83, 84, 45, 49, 48, 10}, - - "zoneinfo/Australia/Lord_Howe": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 116, 0, 0, 0, 5, 0, 0, 0, 25, 128, 0, 0, 0, 20, 254, 102, 224, 22, 56, 64, 248, 22, 231, 138, 104, 24, 33, 93, 120, 24, 199, 108, 104, 26, 1, 63, 120, 26, 167, 78, 104, 27, 225, 33, 120, 28, 135, 48, 104, 29, 193, 3, 120, 30, 121, 142, 112, 31, 151, 170, 248, 32, 89, 112, 112, 33, 128, 199, 120, 34, 66, 140, 240, 35, 105, 227, 248, 36, 34, 110, 240, 37, 73, 197, 248, 37, 239, 219, 240, 39, 41, 167, 248, 39, 207, 189, 240, 41, 9, 137, 248, 41, 175, 159, 240, 42, 233, 107, 248, 43, 152, 188, 112, 44, 210, 136, 120, 45, 120, 158, 112, 46, 178, 106, 120, 47, 88, 128, 112, 48, 146, 76, 120, 49, 93, 76, 112, 50, 114, 46, 120, 51, 61, 46, 112, 52, 82, 16, 120, 53, 29, 16, 112, 54, 49, 242, 120, 54, 252, 242, 112, 56, 27, 14, 248, 56, 220, 212, 112, 57, 167, 226, 120, 58, 188, 182, 112, 59, 218, 210, 248, 60, 165, 210, 240, 61, 186, 180, 248, 62, 133, 180, 240, 63, 154, 150, 248, 64, 101, 150, 240, 65, 131, 179, 120, 66, 69, 120, 240, 67, 99, 149, 120, 68, 46, 149, 112, 69, 67, 119, 120, 70, 5, 60, 240, 71, 35, 89, 120, 71, 247, 147, 240, 72, 231, 139, 248, 73, 215, 117, 240, 74, 199, 109, 248, 75, 183, 87, 240, 76, 167, 79, 248, 77, 151, 57, 240, 78, 135, 49, 248, 79, 119, 27, 240, 80, 112, 78, 120, 81, 96, 56, 112, 82, 80, 48, 120, 83, 64, 26, 112, 84, 48, 18, 120, 85, 31, 252, 112, 86, 15, 244, 120, 86, 255, 222, 112, 87, 239, 214, 120, 88, 223, 192, 112, 89, 207, 184, 120, 90, 191, 162, 112, 91, 184, 212, 248, 92, 168, 190, 240, 93, 152, 182, 248, 94, 136, 160, 240, 95, 120, 152, 248, 96, 104, 130, 240, 97, 88, 122, 248, 98, 72, 100, 240, 99, 56, 92, 248, 100, 40, 70, 240, 101, 24, 62, 248, 102, 17, 99, 112, 103, 1, 91, 120, 103, 241, 69, 112, 104, 225, 61, 120, 105, 209, 39, 112, 106, 193, 31, 120, 107, 177, 9, 112, 108, 161, 1, 120, 109, 144, 235, 112, 110, 128, 227, 120, 111, 112, 205, 112, 112, 105, 255, 248, 113, 89, 233, 240, 114, 73, 225, 248, 115, 57, 203, 240, 116, 41, 195, 248, 117, 25, 173, 240, 118, 9, 165, 248, 118, 249, 143, 240, 119, 233, 135, 248, 120, 217, 113, 240, 121, 201, 105, 248, 122, 185, 83, 240, 123, 178, 134, 120, 124, 162, 112, 112, 125, 146, 104, 120, 126, 130, 82, 112, 127, 114, 74, 120, 127, 255, 255, 255, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 4, 0, 0, 149, 36, 0, 0, 0, 0, 140, 160, 0, 4, 0, 0, 161, 184, 1, 9, 0, 0, 147, 168, 0, 15, 0, 0, 154, 176, 1, 21, 76, 77, 84, 0, 65, 69, 83, 84, 0, 43, 49, 49, 51, 48, 0, 43, 49, 48, 51, 48, 0, 43, 49, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 48, 51, 48, 62, 45, 49, 48, 58, 51, 48, 60, 43, 49, 49, 62, 45, 49, 49, 44, 77, 49, 48, 46, 49, 46, 48, 44, 77, 52, 46, 49, 46, 48, 10}, - - "zoneinfo/Australia/Melbourne": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 5, 0, 0, 0, 14, 128, 0, 0, 0, 156, 78, 166, 156, 156, 188, 32, 240, 203, 84, 179, 0, 203, 199, 87, 112, 204, 183, 86, 128, 205, 167, 57, 112, 206, 160, 115, 0, 207, 135, 27, 112, 3, 112, 57, 128, 4, 13, 28, 0, 5, 80, 27, 128, 5, 246, 56, 128, 7, 47, 253, 128, 7, 214, 26, 128, 9, 15, 223, 128, 9, 181, 252, 128, 10, 239, 193, 128, 11, 159, 25, 0, 12, 216, 222, 0, 13, 126, 251, 0, 14, 184, 192, 0, 15, 94, 221, 0, 16, 152, 162, 0, 17, 62, 191, 0, 18, 120, 132, 0, 19, 30, 161, 0, 20, 88, 102, 0, 20, 254, 131, 0, 22, 56, 72, 0, 22, 231, 159, 128, 24, 33, 100, 128, 24, 199, 129, 128, 26, 1, 70, 128, 26, 167, 99, 128, 27, 225, 40, 128, 28, 135, 69, 128, 29, 193, 10, 128, 30, 121, 156, 128, 31, 151, 178, 0, 32, 89, 126, 128, 33, 119, 148, 0, 34, 66, 155, 0, 35, 105, 235, 0, 36, 34, 125, 0, 37, 73, 205, 0, 38, 2, 95, 0, 39, 41, 175, 0, 39, 207, 204, 0, 41, 9, 145, 0, 41, 175, 174, 0, 42, 233, 115, 0, 43, 152, 202, 128, 44, 210, 143, 128, 45, 120, 172, 128, 46, 178, 113, 128, 47, 116, 62, 0, 48, 146, 83, 128, 49, 93, 90, 128, 50, 114, 53, 128, 51, 61, 60, 128, 52, 82, 23, 128, 53, 29, 30, 128, 54, 49, 249, 128, 54, 253, 0, 128, 56, 27, 22, 0, 56, 220, 226, 128, 57, 167, 233, 128, 58, 188, 196, 128, 59, 218, 218, 0, 60, 165, 225, 0, 61, 186, 188, 0, 62, 133, 195, 0, 63, 154, 158, 0, 64, 101, 165, 0, 65, 131, 186, 128, 66, 69, 135, 0, 67, 99, 156, 128, 68, 46, 163, 128, 69, 67, 126, 128, 70, 5, 75, 0, 71, 35, 96, 128, 71, 247, 162, 0, 72, 231, 147, 0, 73, 215, 132, 0, 74, 199, 117, 0, 75, 183, 102, 0, 76, 167, 87, 0, 77, 151, 72, 0, 78, 135, 57, 0, 79, 119, 42, 0, 80, 112, 85, 128, 81, 96, 70, 128, 82, 80, 55, 128, 83, 64, 40, 128, 84, 48, 25, 128, 85, 32, 10, 128, 86, 15, 251, 128, 86, 255, 236, 128, 87, 239, 221, 128, 88, 223, 206, 128, 89, 207, 191, 128, 90, 191, 176, 128, 91, 184, 220, 0, 92, 168, 205, 0, 93, 152, 190, 0, 94, 136, 175, 0, 95, 120, 160, 0, 96, 104, 145, 0, 97, 88, 130, 0, 98, 72, 115, 0, 99, 56, 100, 0, 100, 40, 85, 0, 101, 24, 70, 0, 102, 17, 113, 128, 103, 1, 98, 128, 103, 241, 83, 128, 104, 225, 68, 128, 105, 209, 53, 128, 106, 193, 38, 128, 107, 177, 23, 128, 108, 161, 8, 128, 109, 144, 249, 128, 110, 128, 234, 128, 111, 112, 219, 128, 112, 106, 7, 0, 113, 89, 248, 0, 114, 73, 233, 0, 115, 57, 218, 0, 116, 41, 203, 0, 117, 25, 188, 0, 118, 9, 173, 0, 118, 249, 158, 0, 119, 233, 143, 0, 120, 217, 128, 0, 121, 201, 113, 0, 122, 185, 98, 0, 123, 178, 141, 128, 124, 162, 126, 128, 125, 146, 111, 128, 126, 130, 96, 128, 127, 114, 81, 128, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 135, 232, 0, 0, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 76, 77, 84, 0, 65, 69, 68, 84, 0, 65, 69, 83, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 69, 83, 84, 45, 49, 48, 65, 69, 68, 84, 44, 77, 49, 48, 46, 49, 46, 48, 44, 77, 52, 46, 49, 46, 48, 47, 51, 10}, - - "zoneinfo/Australia/NSW": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 5, 0, 0, 0, 14, 128, 0, 0, 0, 156, 78, 166, 156, 156, 188, 32, 240, 203, 84, 179, 0, 203, 199, 87, 112, 204, 183, 86, 128, 205, 167, 57, 112, 206, 160, 115, 0, 207, 135, 27, 112, 3, 112, 57, 128, 4, 13, 28, 0, 5, 80, 27, 128, 5, 246, 56, 128, 7, 47, 253, 128, 7, 214, 26, 128, 9, 15, 223, 128, 9, 181, 252, 128, 10, 239, 193, 128, 11, 159, 25, 0, 12, 216, 222, 0, 13, 126, 251, 0, 14, 184, 192, 0, 15, 94, 221, 0, 16, 152, 162, 0, 17, 62, 191, 0, 18, 120, 132, 0, 19, 30, 161, 0, 20, 88, 102, 0, 20, 254, 131, 0, 22, 56, 72, 0, 23, 12, 137, 128, 24, 33, 100, 128, 24, 199, 129, 128, 26, 1, 70, 128, 26, 167, 99, 128, 27, 225, 40, 128, 28, 135, 69, 128, 29, 193, 10, 128, 30, 121, 156, 128, 31, 151, 178, 0, 32, 89, 126, 128, 33, 128, 206, 128, 34, 66, 155, 0, 35, 105, 235, 0, 36, 34, 125, 0, 37, 73, 205, 0, 37, 239, 234, 0, 39, 41, 175, 0, 39, 207, 204, 0, 41, 9, 145, 0, 41, 175, 174, 0, 42, 233, 115, 0, 43, 152, 202, 128, 44, 210, 143, 128, 45, 120, 172, 128, 46, 178, 113, 128, 47, 88, 142, 128, 48, 146, 83, 128, 49, 93, 90, 128, 50, 114, 53, 128, 51, 61, 60, 128, 52, 82, 23, 128, 53, 29, 30, 128, 54, 49, 249, 128, 54, 253, 0, 128, 56, 27, 22, 0, 56, 220, 226, 128, 57, 167, 233, 128, 58, 188, 196, 128, 59, 218, 218, 0, 60, 165, 225, 0, 61, 186, 188, 0, 62, 133, 195, 0, 63, 154, 158, 0, 64, 101, 165, 0, 65, 131, 186, 128, 66, 69, 135, 0, 67, 99, 156, 128, 68, 46, 163, 128, 69, 67, 126, 128, 70, 5, 75, 0, 71, 35, 96, 128, 71, 247, 162, 0, 72, 231, 147, 0, 73, 215, 132, 0, 74, 199, 117, 0, 75, 183, 102, 0, 76, 167, 87, 0, 77, 151, 72, 0, 78, 135, 57, 0, 79, 119, 42, 0, 80, 112, 85, 128, 81, 96, 70, 128, 82, 80, 55, 128, 83, 64, 40, 128, 84, 48, 25, 128, 85, 32, 10, 128, 86, 15, 251, 128, 86, 255, 236, 128, 87, 239, 221, 128, 88, 223, 206, 128, 89, 207, 191, 128, 90, 191, 176, 128, 91, 184, 220, 0, 92, 168, 205, 0, 93, 152, 190, 0, 94, 136, 175, 0, 95, 120, 160, 0, 96, 104, 145, 0, 97, 88, 130, 0, 98, 72, 115, 0, 99, 56, 100, 0, 100, 40, 85, 0, 101, 24, 70, 0, 102, 17, 113, 128, 103, 1, 98, 128, 103, 241, 83, 128, 104, 225, 68, 128, 105, 209, 53, 128, 106, 193, 38, 128, 107, 177, 23, 128, 108, 161, 8, 128, 109, 144, 249, 128, 110, 128, 234, 128, 111, 112, 219, 128, 112, 106, 7, 0, 113, 89, 248, 0, 114, 73, 233, 0, 115, 57, 218, 0, 116, 41, 203, 0, 117, 25, 188, 0, 118, 9, 173, 0, 118, 249, 158, 0, 119, 233, 143, 0, 120, 217, 128, 0, 121, 201, 113, 0, 122, 185, 98, 0, 123, 178, 141, 128, 124, 162, 126, 128, 125, 146, 111, 128, 126, 130, 96, 128, 127, 114, 81, 128, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 141, 196, 0, 0, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 76, 77, 84, 0, 65, 69, 68, 84, 0, 65, 69, 83, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 69, 83, 84, 45, 49, 48, 65, 69, 68, 84, 44, 77, 49, 48, 46, 49, 46, 48, 44, 77, 52, 46, 49, 46, 48, 47, 51, 10}, - - "zoneinfo/Australia/North": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 3, 0, 0, 0, 10, 128, 0, 0, 0, 156, 78, 173, 164, 156, 188, 39, 248, 203, 84, 186, 8, 203, 199, 94, 120, 204, 183, 93, 136, 205, 167, 64, 120, 206, 160, 122, 8, 207, 135, 34, 120, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 126, 144, 0, 0, 0, 0, 147, 168, 1, 5, 0, 0, 133, 152, 0, 0, 65, 67, 83, 84, 0, 65, 67, 68, 84, 0, 0, 0, 0, 0, 0, 0, 10, 65, 67, 83, 84, 45, 57, 58, 51, 48, 10}, - - "zoneinfo/Australia/Perth": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 5, 0, 0, 0, 14, 128, 0, 0, 0, 156, 78, 194, 188, 156, 188, 61, 16, 203, 84, 207, 32, 203, 199, 115, 144, 204, 183, 114, 160, 205, 167, 85, 144, 9, 15, 251, 160, 9, 182, 24, 160, 26, 1, 98, 160, 26, 167, 127, 160, 41, 37, 92, 160, 41, 175, 202, 32, 69, 113, 191, 32, 70, 5, 103, 32, 71, 35, 124, 160, 71, 238, 131, 160, 73, 3, 94, 160, 73, 206, 101, 160, 2, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 0, 0, 108, 156, 0, 0, 0, 0, 126, 144, 1, 4, 0, 0, 112, 128, 0, 9, 0, 0, 126, 144, 1, 4, 0, 0, 112, 128, 0, 9, 76, 77, 84, 0, 65, 87, 68, 84, 0, 65, 87, 83, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 87, 83, 84, 45, 56, 10}, - - "zoneinfo/Australia/Queensland": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 5, 0, 0, 0, 14, 128, 0, 0, 0, 156, 78, 166, 156, 156, 188, 32, 240, 203, 84, 179, 0, 203, 199, 87, 112, 204, 183, 86, 128, 205, 167, 57, 112, 206, 160, 115, 0, 207, 135, 27, 112, 3, 112, 57, 128, 4, 13, 28, 0, 37, 73, 205, 0, 37, 239, 234, 0, 39, 41, 175, 0, 39, 207, 204, 0, 41, 9, 145, 0, 41, 175, 174, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 0, 0, 143, 120, 0, 0, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 76, 77, 84, 0, 65, 69, 68, 84, 0, 65, 69, 83, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 69, 83, 84, 45, 49, 48, 10}, - - "zoneinfo/Australia/South": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 5, 0, 0, 0, 10, 128, 0, 0, 0, 156, 78, 173, 164, 156, 188, 39, 248, 203, 84, 186, 8, 203, 199, 94, 120, 204, 183, 93, 136, 205, 167, 64, 120, 206, 160, 122, 8, 207, 135, 34, 120, 3, 112, 64, 136, 4, 13, 35, 8, 5, 80, 34, 136, 5, 246, 63, 136, 7, 48, 4, 136, 7, 214, 33, 136, 9, 15, 230, 136, 9, 182, 3, 136, 10, 239, 200, 136, 11, 159, 32, 8, 12, 216, 229, 8, 13, 127, 2, 8, 14, 184, 199, 8, 15, 94, 228, 8, 16, 152, 169, 8, 17, 62, 198, 8, 18, 120, 139, 8, 19, 30, 168, 8, 20, 88, 109, 8, 20, 254, 138, 8, 22, 56, 79, 8, 22, 231, 166, 136, 24, 33, 107, 136, 24, 199, 136, 136, 26, 1, 77, 136, 26, 167, 106, 136, 27, 225, 47, 136, 28, 135, 76, 136, 29, 193, 17, 136, 30, 121, 163, 136, 31, 151, 185, 8, 32, 89, 133, 136, 33, 128, 213, 136, 34, 66, 162, 8, 35, 105, 242, 8, 36, 34, 132, 8, 37, 73, 212, 8, 38, 2, 102, 8, 39, 41, 182, 8, 39, 207, 211, 8, 41, 9, 152, 8, 41, 203, 100, 136, 42, 233, 122, 8, 43, 152, 209, 136, 44, 210, 150, 136, 45, 139, 40, 136, 46, 178, 120, 136, 47, 116, 69, 8, 48, 146, 90, 136, 49, 93, 97, 136, 50, 114, 60, 136, 51, 61, 67, 136, 52, 82, 30, 136, 53, 29, 37, 136, 54, 50, 0, 136, 54, 253, 7, 136, 56, 27, 29, 8, 56, 220, 233, 136, 57, 250, 255, 8, 58, 188, 203, 136, 59, 218, 225, 8, 60, 165, 232, 8, 61, 186, 195, 8, 62, 133, 202, 8, 63, 154, 165, 8, 64, 101, 172, 8, 65, 131, 193, 136, 66, 69, 142, 8, 67, 99, 163, 136, 68, 46, 170, 136, 69, 67, 133, 136, 70, 5, 82, 8, 71, 35, 103, 136, 71, 247, 169, 8, 72, 231, 154, 8, 73, 215, 139, 8, 74, 199, 124, 8, 75, 183, 109, 8, 76, 167, 94, 8, 77, 151, 79, 8, 78, 135, 64, 8, 79, 119, 49, 8, 80, 112, 92, 136, 81, 96, 77, 136, 82, 80, 62, 136, 83, 64, 47, 136, 84, 48, 32, 136, 85, 32, 17, 136, 86, 16, 2, 136, 86, 255, 243, 136, 87, 239, 228, 136, 88, 223, 213, 136, 89, 207, 198, 136, 90, 191, 183, 136, 91, 184, 227, 8, 92, 168, 212, 8, 93, 152, 197, 8, 94, 136, 182, 8, 95, 120, 167, 8, 96, 104, 152, 8, 97, 88, 137, 8, 98, 72, 122, 8, 99, 56, 107, 8, 100, 40, 92, 8, 101, 24, 77, 8, 102, 17, 120, 136, 103, 1, 105, 136, 103, 241, 90, 136, 104, 225, 75, 136, 105, 209, 60, 136, 106, 193, 45, 136, 107, 177, 30, 136, 108, 161, 15, 136, 109, 145, 0, 136, 110, 128, 241, 136, 111, 112, 226, 136, 112, 106, 14, 8, 113, 89, 255, 8, 114, 73, 240, 8, 115, 57, 225, 8, 116, 41, 210, 8, 117, 25, 195, 8, 118, 9, 180, 8, 118, 249, 165, 8, 119, 233, 150, 8, 120, 217, 135, 8, 121, 201, 120, 8, 122, 185, 105, 8, 123, 178, 148, 136, 124, 162, 133, 136, 125, 146, 118, 136, 126, 130, 103, 136, 127, 114, 88, 136, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 126, 144, 0, 0, 0, 0, 147, 168, 1, 5, 0, 0, 133, 152, 0, 0, 0, 0, 147, 168, 1, 5, 0, 0, 133, 152, 0, 0, 65, 67, 83, 84, 0, 65, 67, 68, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 67, 83, 84, 45, 57, 58, 51, 48, 65, 67, 68, 84, 44, 77, 49, 48, 46, 49, 46, 48, 44, 77, 52, 46, 49, 46, 48, 47, 51, 10}, - - "zoneinfo/Australia/Sydney": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 5, 0, 0, 0, 14, 128, 0, 0, 0, 156, 78, 166, 156, 156, 188, 32, 240, 203, 84, 179, 0, 203, 199, 87, 112, 204, 183, 86, 128, 205, 167, 57, 112, 206, 160, 115, 0, 207, 135, 27, 112, 3, 112, 57, 128, 4, 13, 28, 0, 5, 80, 27, 128, 5, 246, 56, 128, 7, 47, 253, 128, 7, 214, 26, 128, 9, 15, 223, 128, 9, 181, 252, 128, 10, 239, 193, 128, 11, 159, 25, 0, 12, 216, 222, 0, 13, 126, 251, 0, 14, 184, 192, 0, 15, 94, 221, 0, 16, 152, 162, 0, 17, 62, 191, 0, 18, 120, 132, 0, 19, 30, 161, 0, 20, 88, 102, 0, 20, 254, 131, 0, 22, 56, 72, 0, 23, 12, 137, 128, 24, 33, 100, 128, 24, 199, 129, 128, 26, 1, 70, 128, 26, 167, 99, 128, 27, 225, 40, 128, 28, 135, 69, 128, 29, 193, 10, 128, 30, 121, 156, 128, 31, 151, 178, 0, 32, 89, 126, 128, 33, 128, 206, 128, 34, 66, 155, 0, 35, 105, 235, 0, 36, 34, 125, 0, 37, 73, 205, 0, 37, 239, 234, 0, 39, 41, 175, 0, 39, 207, 204, 0, 41, 9, 145, 0, 41, 175, 174, 0, 42, 233, 115, 0, 43, 152, 202, 128, 44, 210, 143, 128, 45, 120, 172, 128, 46, 178, 113, 128, 47, 88, 142, 128, 48, 146, 83, 128, 49, 93, 90, 128, 50, 114, 53, 128, 51, 61, 60, 128, 52, 82, 23, 128, 53, 29, 30, 128, 54, 49, 249, 128, 54, 253, 0, 128, 56, 27, 22, 0, 56, 220, 226, 128, 57, 167, 233, 128, 58, 188, 196, 128, 59, 218, 218, 0, 60, 165, 225, 0, 61, 186, 188, 0, 62, 133, 195, 0, 63, 154, 158, 0, 64, 101, 165, 0, 65, 131, 186, 128, 66, 69, 135, 0, 67, 99, 156, 128, 68, 46, 163, 128, 69, 67, 126, 128, 70, 5, 75, 0, 71, 35, 96, 128, 71, 247, 162, 0, 72, 231, 147, 0, 73, 215, 132, 0, 74, 199, 117, 0, 75, 183, 102, 0, 76, 167, 87, 0, 77, 151, 72, 0, 78, 135, 57, 0, 79, 119, 42, 0, 80, 112, 85, 128, 81, 96, 70, 128, 82, 80, 55, 128, 83, 64, 40, 128, 84, 48, 25, 128, 85, 32, 10, 128, 86, 15, 251, 128, 86, 255, 236, 128, 87, 239, 221, 128, 88, 223, 206, 128, 89, 207, 191, 128, 90, 191, 176, 128, 91, 184, 220, 0, 92, 168, 205, 0, 93, 152, 190, 0, 94, 136, 175, 0, 95, 120, 160, 0, 96, 104, 145, 0, 97, 88, 130, 0, 98, 72, 115, 0, 99, 56, 100, 0, 100, 40, 85, 0, 101, 24, 70, 0, 102, 17, 113, 128, 103, 1, 98, 128, 103, 241, 83, 128, 104, 225, 68, 128, 105, 209, 53, 128, 106, 193, 38, 128, 107, 177, 23, 128, 108, 161, 8, 128, 109, 144, 249, 128, 110, 128, 234, 128, 111, 112, 219, 128, 112, 106, 7, 0, 113, 89, 248, 0, 114, 73, 233, 0, 115, 57, 218, 0, 116, 41, 203, 0, 117, 25, 188, 0, 118, 9, 173, 0, 118, 249, 158, 0, 119, 233, 143, 0, 120, 217, 128, 0, 121, 201, 113, 0, 122, 185, 98, 0, 123, 178, 141, 128, 124, 162, 126, 128, 125, 146, 111, 128, 126, 130, 96, 128, 127, 114, 81, 128, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 141, 196, 0, 0, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 76, 77, 84, 0, 65, 69, 68, 84, 0, 65, 69, 83, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 69, 83, 84, 45, 49, 48, 65, 69, 68, 84, 44, 77, 49, 48, 46, 49, 46, 48, 44, 77, 52, 46, 49, 46, 48, 47, 51, 10}, - - "zoneinfo/Australia/Tasmania": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 150, 0, 0, 0, 5, 0, 0, 0, 14, 128, 0, 0, 0, 155, 213, 120, 128, 156, 188, 32, 240, 203, 84, 179, 0, 203, 199, 87, 112, 204, 183, 86, 128, 205, 167, 57, 112, 206, 160, 115, 0, 207, 135, 27, 112, 251, 194, 141, 0, 252, 178, 126, 0, 253, 199, 89, 0, 254, 118, 176, 128, 255, 167, 59, 0, 0, 86, 146, 128, 1, 135, 29, 0, 2, 63, 175, 0, 3, 112, 57, 128, 4, 13, 28, 0, 5, 80, 27, 128, 5, 246, 56, 128, 7, 47, 253, 128, 7, 214, 26, 128, 9, 15, 223, 128, 9, 181, 252, 128, 10, 239, 193, 128, 11, 159, 25, 0, 12, 216, 222, 0, 13, 126, 251, 0, 14, 184, 192, 0, 15, 94, 221, 0, 16, 152, 162, 0, 17, 62, 191, 0, 18, 120, 132, 0, 19, 30, 161, 0, 20, 88, 102, 0, 20, 254, 131, 0, 22, 56, 72, 0, 23, 3, 79, 0, 24, 33, 100, 128, 24, 227, 49, 0, 26, 1, 70, 128, 26, 167, 99, 128, 27, 225, 40, 128, 28, 135, 69, 128, 29, 193, 10, 128, 30, 103, 39, 128, 31, 151, 178, 0, 32, 89, 126, 128, 33, 128, 206, 128, 34, 66, 155, 0, 35, 105, 235, 0, 36, 34, 125, 0, 37, 73, 205, 0, 38, 2, 95, 0, 39, 41, 175, 0, 39, 244, 182, 0, 40, 237, 225, 128, 41, 212, 152, 0, 42, 205, 195, 128, 43, 180, 122, 0, 44, 173, 165, 128, 45, 148, 92, 0, 46, 141, 135, 128, 47, 116, 62, 0, 48, 109, 105, 128, 49, 93, 90, 128, 50, 86, 134, 0, 51, 61, 60, 128, 52, 54, 104, 0, 53, 29, 30, 128, 54, 22, 74, 0, 54, 253, 0, 128, 55, 246, 44, 0, 56, 220, 226, 128, 57, 167, 233, 128, 58, 188, 196, 128, 59, 191, 42, 128, 60, 165, 225, 0, 61, 159, 12, 128, 62, 133, 195, 0, 63, 126, 238, 128, 64, 101, 165, 0, 65, 94, 208, 128, 66, 69, 135, 0, 67, 62, 178, 128, 68, 46, 163, 128, 69, 30, 148, 128, 70, 5, 75, 0, 71, 7, 177, 0, 71, 247, 162, 0, 72, 231, 147, 0, 73, 215, 132, 0, 74, 199, 117, 0, 75, 183, 102, 0, 76, 167, 87, 0, 77, 151, 72, 0, 78, 135, 57, 0, 79, 119, 42, 0, 80, 112, 85, 128, 81, 96, 70, 128, 82, 80, 55, 128, 83, 64, 40, 128, 84, 48, 25, 128, 85, 32, 10, 128, 86, 15, 251, 128, 86, 255, 236, 128, 87, 239, 221, 128, 88, 223, 206, 128, 89, 207, 191, 128, 90, 191, 176, 128, 91, 184, 220, 0, 92, 168, 205, 0, 93, 152, 190, 0, 94, 136, 175, 0, 95, 120, 160, 0, 96, 104, 145, 0, 97, 88, 130, 0, 98, 72, 115, 0, 99, 56, 100, 0, 100, 40, 85, 0, 101, 24, 70, 0, 102, 17, 113, 128, 103, 1, 98, 128, 103, 241, 83, 128, 104, 225, 68, 128, 105, 209, 53, 128, 106, 193, 38, 128, 107, 177, 23, 128, 108, 161, 8, 128, 109, 144, 249, 128, 110, 128, 234, 128, 111, 112, 219, 128, 112, 106, 7, 0, 113, 89, 248, 0, 114, 73, 233, 0, 115, 57, 218, 0, 116, 41, 203, 0, 117, 25, 188, 0, 118, 9, 173, 0, 118, 249, 158, 0, 119, 233, 143, 0, 120, 217, 128, 0, 121, 201, 113, 0, 122, 185, 98, 0, 123, 178, 141, 128, 124, 162, 126, 128, 125, 146, 111, 128, 126, 130, 96, 128, 127, 114, 81, 128, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 138, 28, 0, 0, 0, 0, 140, 160, 0, 4, 0, 0, 154, 176, 1, 9, 0, 0, 154, 176, 1, 9, 0, 0, 140, 160, 0, 4, 76, 77, 84, 0, 65, 69, 83, 84, 0, 65, 69, 68, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 69, 83, 84, 45, 49, 48, 65, 69, 68, 84, 44, 77, 49, 48, 46, 49, 46, 48, 44, 77, 52, 46, 49, 46, 48, 47, 51, 10}, - - "zoneinfo/Australia/Victoria": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 5, 0, 0, 0, 14, 128, 0, 0, 0, 156, 78, 166, 156, 156, 188, 32, 240, 203, 84, 179, 0, 203, 199, 87, 112, 204, 183, 86, 128, 205, 167, 57, 112, 206, 160, 115, 0, 207, 135, 27, 112, 3, 112, 57, 128, 4, 13, 28, 0, 5, 80, 27, 128, 5, 246, 56, 128, 7, 47, 253, 128, 7, 214, 26, 128, 9, 15, 223, 128, 9, 181, 252, 128, 10, 239, 193, 128, 11, 159, 25, 0, 12, 216, 222, 0, 13, 126, 251, 0, 14, 184, 192, 0, 15, 94, 221, 0, 16, 152, 162, 0, 17, 62, 191, 0, 18, 120, 132, 0, 19, 30, 161, 0, 20, 88, 102, 0, 20, 254, 131, 0, 22, 56, 72, 0, 22, 231, 159, 128, 24, 33, 100, 128, 24, 199, 129, 128, 26, 1, 70, 128, 26, 167, 99, 128, 27, 225, 40, 128, 28, 135, 69, 128, 29, 193, 10, 128, 30, 121, 156, 128, 31, 151, 178, 0, 32, 89, 126, 128, 33, 119, 148, 0, 34, 66, 155, 0, 35, 105, 235, 0, 36, 34, 125, 0, 37, 73, 205, 0, 38, 2, 95, 0, 39, 41, 175, 0, 39, 207, 204, 0, 41, 9, 145, 0, 41, 175, 174, 0, 42, 233, 115, 0, 43, 152, 202, 128, 44, 210, 143, 128, 45, 120, 172, 128, 46, 178, 113, 128, 47, 116, 62, 0, 48, 146, 83, 128, 49, 93, 90, 128, 50, 114, 53, 128, 51, 61, 60, 128, 52, 82, 23, 128, 53, 29, 30, 128, 54, 49, 249, 128, 54, 253, 0, 128, 56, 27, 22, 0, 56, 220, 226, 128, 57, 167, 233, 128, 58, 188, 196, 128, 59, 218, 218, 0, 60, 165, 225, 0, 61, 186, 188, 0, 62, 133, 195, 0, 63, 154, 158, 0, 64, 101, 165, 0, 65, 131, 186, 128, 66, 69, 135, 0, 67, 99, 156, 128, 68, 46, 163, 128, 69, 67, 126, 128, 70, 5, 75, 0, 71, 35, 96, 128, 71, 247, 162, 0, 72, 231, 147, 0, 73, 215, 132, 0, 74, 199, 117, 0, 75, 183, 102, 0, 76, 167, 87, 0, 77, 151, 72, 0, 78, 135, 57, 0, 79, 119, 42, 0, 80, 112, 85, 128, 81, 96, 70, 128, 82, 80, 55, 128, 83, 64, 40, 128, 84, 48, 25, 128, 85, 32, 10, 128, 86, 15, 251, 128, 86, 255, 236, 128, 87, 239, 221, 128, 88, 223, 206, 128, 89, 207, 191, 128, 90, 191, 176, 128, 91, 184, 220, 0, 92, 168, 205, 0, 93, 152, 190, 0, 94, 136, 175, 0, 95, 120, 160, 0, 96, 104, 145, 0, 97, 88, 130, 0, 98, 72, 115, 0, 99, 56, 100, 0, 100, 40, 85, 0, 101, 24, 70, 0, 102, 17, 113, 128, 103, 1, 98, 128, 103, 241, 83, 128, 104, 225, 68, 128, 105, 209, 53, 128, 106, 193, 38, 128, 107, 177, 23, 128, 108, 161, 8, 128, 109, 144, 249, 128, 110, 128, 234, 128, 111, 112, 219, 128, 112, 106, 7, 0, 113, 89, 248, 0, 114, 73, 233, 0, 115, 57, 218, 0, 116, 41, 203, 0, 117, 25, 188, 0, 118, 9, 173, 0, 118, 249, 158, 0, 119, 233, 143, 0, 120, 217, 128, 0, 121, 201, 113, 0, 122, 185, 98, 0, 123, 178, 141, 128, 124, 162, 126, 128, 125, 146, 111, 128, 126, 130, 96, 128, 127, 114, 81, 128, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 135, 232, 0, 0, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 0, 0, 154, 176, 1, 4, 0, 0, 140, 160, 0, 9, 76, 77, 84, 0, 65, 69, 68, 84, 0, 65, 69, 83, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 69, 83, 84, 45, 49, 48, 65, 69, 68, 84, 44, 77, 49, 48, 46, 49, 46, 48, 44, 77, 52, 46, 49, 46, 48, 47, 51, 10}, - - "zoneinfo/Australia/West": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 19, 0, 0, 0, 5, 0, 0, 0, 14, 128, 0, 0, 0, 156, 78, 194, 188, 156, 188, 61, 16, 203, 84, 207, 32, 203, 199, 115, 144, 204, 183, 114, 160, 205, 167, 85, 144, 9, 15, 251, 160, 9, 182, 24, 160, 26, 1, 98, 160, 26, 167, 127, 160, 41, 37, 92, 160, 41, 175, 202, 32, 69, 113, 191, 32, 70, 5, 103, 32, 71, 35, 124, 160, 71, 238, 131, 160, 73, 3, 94, 160, 73, 206, 101, 160, 2, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 0, 0, 108, 156, 0, 0, 0, 0, 126, 144, 1, 4, 0, 0, 112, 128, 0, 9, 0, 0, 126, 144, 1, 4, 0, 0, 112, 128, 0, 9, 76, 77, 84, 0, 65, 87, 68, 84, 0, 65, 87, 83, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 87, 83, 84, 45, 56, 10}, - - "zoneinfo/Australia/Yancowinna": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 143, 0, 0, 0, 5, 0, 0, 0, 10, 128, 0, 0, 0, 156, 78, 173, 164, 156, 188, 39, 248, 203, 84, 186, 8, 203, 199, 94, 120, 204, 183, 93, 136, 205, 167, 64, 120, 206, 160, 122, 8, 207, 135, 34, 120, 3, 112, 64, 136, 4, 13, 35, 8, 5, 80, 34, 136, 5, 246, 63, 136, 7, 48, 4, 136, 7, 214, 33, 136, 9, 15, 230, 136, 9, 182, 3, 136, 10, 239, 200, 136, 11, 159, 32, 8, 12, 216, 229, 8, 13, 127, 2, 8, 14, 184, 199, 8, 15, 94, 228, 8, 16, 152, 169, 8, 17, 62, 198, 8, 18, 120, 139, 8, 19, 30, 168, 8, 20, 88, 109, 8, 20, 254, 138, 8, 22, 56, 79, 8, 23, 12, 144, 136, 24, 33, 107, 136, 24, 199, 136, 136, 26, 1, 77, 136, 26, 167, 106, 136, 27, 225, 47, 136, 28, 135, 76, 136, 29, 193, 17, 136, 30, 121, 163, 136, 31, 151, 185, 8, 32, 89, 133, 136, 33, 128, 213, 136, 34, 66, 162, 8, 35, 105, 242, 8, 36, 34, 132, 8, 37, 73, 212, 8, 37, 239, 241, 8, 39, 41, 182, 8, 39, 207, 211, 8, 41, 9, 152, 8, 41, 175, 181, 8, 42, 233, 122, 8, 43, 152, 209, 136, 44, 210, 150, 136, 45, 120, 179, 136, 46, 178, 120, 136, 47, 88, 149, 136, 48, 146, 90, 136, 49, 93, 97, 136, 50, 114, 60, 136, 51, 61, 67, 136, 52, 82, 30, 136, 53, 29, 37, 136, 54, 50, 0, 136, 54, 253, 7, 136, 56, 27, 29, 8, 56, 108, 175, 216, 56, 220, 233, 136, 57, 250, 255, 8, 58, 188, 203, 136, 59, 218, 225, 8, 60, 165, 232, 8, 61, 186, 195, 8, 62, 133, 202, 8, 63, 154, 165, 8, 64, 101, 172, 8, 65, 131, 193, 136, 66, 69, 142, 8, 67, 99, 163, 136, 68, 46, 170, 136, 69, 67, 133, 136, 70, 5, 82, 8, 71, 35, 103, 136, 71, 247, 169, 8, 72, 231, 154, 8, 73, 215, 139, 8, 74, 199, 124, 8, 75, 183, 109, 8, 76, 167, 94, 8, 77, 151, 79, 8, 78, 135, 64, 8, 79, 119, 49, 8, 80, 112, 92, 136, 81, 96, 77, 136, 82, 80, 62, 136, 83, 64, 47, 136, 84, 48, 32, 136, 85, 32, 17, 136, 86, 16, 2, 136, 86, 255, 243, 136, 87, 239, 228, 136, 88, 223, 213, 136, 89, 207, 198, 136, 90, 191, 183, 136, 91, 184, 227, 8, 92, 168, 212, 8, 93, 152, 197, 8, 94, 136, 182, 8, 95, 120, 167, 8, 96, 104, 152, 8, 97, 88, 137, 8, 98, 72, 122, 8, 99, 56, 107, 8, 100, 40, 92, 8, 101, 24, 77, 8, 102, 17, 120, 136, 103, 1, 105, 136, 103, 241, 90, 136, 104, 225, 75, 136, 105, 209, 60, 136, 106, 193, 45, 136, 107, 177, 30, 136, 108, 161, 15, 136, 109, 145, 0, 136, 110, 128, 241, 136, 111, 112, 226, 136, 112, 106, 14, 8, 113, 89, 255, 8, 114, 73, 240, 8, 115, 57, 225, 8, 116, 41, 210, 8, 117, 25, 195, 8, 118, 9, 180, 8, 118, 249, 165, 8, 119, 233, 150, 8, 120, 217, 135, 8, 121, 201, 120, 8, 122, 185, 105, 8, 123, 178, 148, 136, 124, 162, 133, 136, 125, 146, 118, 136, 126, 130, 103, 136, 127, 114, 88, 136, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 1, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 126, 144, 0, 0, 0, 0, 147, 168, 1, 5, 0, 0, 133, 152, 0, 0, 0, 0, 147, 168, 1, 5, 0, 0, 133, 152, 0, 0, 65, 67, 83, 84, 0, 65, 67, 68, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 65, 67, 83, 84, 45, 57, 58, 51, 48, 65, 67, 68, 84, 44, 77, 49, 48, 46, 49, 46, 48, 44, 77, 52, 46, 49, 46, 48, 47, 51, 10}, - - "zoneinfo/Brazil/Acre": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, 5, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 134, 144, 184, 15, 102, 0, 184, 253, 92, 192, 185, 241, 80, 80, 186, 222, 144, 64, 218, 56, 202, 80, 218, 236, 22, 80, 220, 25, 253, 208, 220, 185, 117, 64, 221, 251, 49, 80, 222, 155, 250, 64, 223, 221, 182, 80, 224, 84, 79, 64, 244, 152, 27, 208, 245, 5, 122, 64, 246, 192, 128, 80, 247, 14, 58, 192, 248, 81, 72, 80, 248, 199, 225, 64, 250, 10, 238, 208, 250, 169, 20, 192, 251, 236, 34, 80, 252, 139, 153, 192, 29, 201, 170, 80, 30, 120, 243, 192, 31, 160, 81, 208, 32, 51, 235, 192, 33, 129, 133, 80, 34, 11, 228, 192, 72, 96, 127, 80, 82, 127, 4, 192, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 2, 255, 255, 192, 112, 0, 0, 255, 255, 199, 192, 1, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 0, 4, 255, 255, 185, 176, 0, 8, 76, 77, 84, 0, 45, 48, 52, 0, 45, 48, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 53, 62, 53, 10}, - - "zoneinfo/Brazil/DeNoronha": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 101, 100, 184, 15, 59, 208, 184, 253, 50, 144, 185, 241, 38, 32, 186, 222, 102, 16, 218, 56, 160, 32, 218, 235, 236, 32, 220, 25, 211, 160, 220, 185, 75, 16, 221, 251, 7, 32, 222, 155, 208, 16, 223, 221, 140, 32, 224, 84, 37, 16, 244, 151, 241, 160, 245, 5, 80, 16, 246, 192, 86, 32, 247, 14, 16, 144, 248, 81, 30, 32, 248, 199, 183, 16, 250, 10, 196, 160, 250, 168, 234, 144, 251, 235, 248, 32, 252, 139, 111, 144, 29, 201, 128, 32, 30, 120, 201, 144, 31, 160, 39, 160, 32, 51, 193, 144, 33, 129, 91, 32, 34, 11, 186, 144, 35, 88, 2, 160, 35, 226, 98, 16, 37, 55, 228, 160, 37, 212, 185, 16, 55, 246, 184, 160, 56, 184, 119, 16, 57, 223, 213, 32, 57, 233, 1, 144, 59, 200, 241, 160, 60, 111, 0, 144, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 255, 255, 225, 156, 0, 0, 255, 255, 241, 240, 1, 4, 255, 255, 227, 224, 0, 8, 76, 77, 84, 0, 45, 48, 49, 0, 45, 48, 50, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 50, 62, 50, 10}, - - "zoneinfo/Brazil/East": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 129, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 114, 180, 184, 15, 73, 224, 184, 253, 64, 160, 185, 241, 52, 48, 186, 222, 116, 32, 218, 56, 174, 48, 218, 235, 250, 48, 220, 25, 225, 176, 220, 185, 89, 32, 221, 251, 21, 48, 222, 155, 222, 32, 223, 221, 154, 48, 224, 84, 51, 32, 244, 90, 9, 48, 245, 5, 94, 32, 246, 192, 100, 48, 247, 14, 30, 160, 248, 81, 44, 48, 248, 199, 197, 32, 250, 10, 210, 176, 250, 168, 248, 160, 251, 236, 6, 48, 252, 139, 125, 160, 29, 201, 142, 48, 30, 120, 215, 160, 31, 160, 53, 176, 32, 51, 207, 160, 33, 129, 105, 48, 34, 11, 200, 160, 35, 88, 16, 176, 35, 226, 112, 32, 37, 55, 242, 176, 37, 212, 199, 32, 39, 33, 15, 48, 39, 189, 227, 160, 41, 0, 241, 48, 41, 148, 139, 32, 42, 234, 13, 176, 43, 107, 50, 160, 44, 192, 181, 48, 45, 102, 196, 32, 46, 160, 151, 48, 47, 70, 166, 32, 48, 128, 121, 48, 49, 29, 77, 160, 50, 87, 32, 176, 51, 6, 106, 32, 52, 56, 84, 48, 52, 248, 193, 32, 54, 32, 31, 48, 54, 207, 104, 160, 55, 246, 198, 176, 56, 184, 133, 32, 57, 223, 227, 48, 58, 143, 44, 160, 59, 200, 255, 176, 60, 111, 14, 160, 61, 196, 145, 48, 62, 78, 240, 160, 63, 145, 254, 48, 64, 46, 210, 160, 65, 134, 248, 48, 66, 23, 239, 32, 67, 81, 194, 48, 67, 247, 209, 32, 69, 77, 83, 176, 69, 224, 237, 160, 71, 17, 134, 48, 71, 183, 149, 32, 72, 250, 162, 176, 73, 151, 119, 32, 74, 218, 132, 176, 75, 128, 147, 160, 76, 186, 102, 176, 77, 96, 117, 160, 78, 154, 72, 176, 79, 73, 146, 32, 80, 131, 101, 48, 81, 32, 57, 160, 82, 99, 71, 48, 83, 0, 27, 160, 84, 67, 41, 48, 84, 233, 56, 32, 86, 35, 11, 48, 86, 201, 26, 32, 88, 2, 237, 48, 88, 168, 252, 32, 89, 226, 207, 48, 90, 136, 222, 32, 91, 203, 235, 176, 92, 104, 192, 32, 93, 171, 205, 176, 94, 72, 162, 32, 95, 139, 175, 176, 96, 49, 190, 160, 97, 107, 145, 176, 98, 17, 160, 160, 99, 75, 115, 176, 99, 250, 189, 32, 101, 43, 85, 176, 101, 209, 100, 160, 103, 20, 114, 48, 103, 177, 70, 160, 104, 244, 84, 48, 105, 154, 99, 32, 106, 212, 54, 48, 107, 122, 69, 32, 108, 180, 24, 48, 109, 90, 39, 32, 110, 147, 250, 48, 111, 58, 9, 32, 112, 125, 22, 176, 113, 25, 235, 32, 114, 92, 248, 176, 114, 249, 205, 32, 116, 60, 218, 176, 116, 217, 175, 32, 118, 28, 188, 176, 118, 194, 203, 160, 119, 252, 158, 176, 120, 171, 232, 32, 121, 220, 128, 176, 122, 130, 143, 160, 123, 197, 157, 48, 124, 98, 113, 160, 125, 165, 127, 48, 126, 75, 142, 32, 127, 133, 97, 48, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 255, 255, 212, 76, 0, 0, 255, 255, 227, 224, 1, 4, 255, 255, 213, 208, 0, 8, 76, 77, 84, 0, 45, 48, 50, 0, 45, 48, 51, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 60, 45, 48, 50, 62, 44, 77, 49, 48, 46, 51, 46, 48, 47, 48, 44, 77, 50, 46, 51, 46, 48, 47, 48, 10}, - - "zoneinfo/Brazil/West": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 150, 170, 127, 68, 184, 15, 87, 240, 184, 253, 78, 176, 185, 241, 66, 64, 186, 222, 130, 48, 218, 56, 188, 64, 218, 236, 8, 64, 220, 25, 239, 192, 220, 185, 103, 48, 221, 251, 35, 64, 222, 155, 236, 48, 223, 221, 168, 64, 224, 84, 65, 48, 244, 152, 13, 192, 245, 5, 108, 48, 246, 192, 114, 64, 247, 14, 44, 176, 248, 81, 58, 64, 248, 199, 211, 48, 250, 10, 224, 192, 250, 169, 6, 176, 251, 236, 20, 64, 252, 139, 139, 176, 29, 201, 156, 64, 30, 120, 229, 176, 31, 160, 67, 192, 32, 51, 221, 176, 33, 129, 119, 64, 34, 11, 214, 176, 44, 192, 195, 64, 45, 102, 210, 48, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 255, 255, 199, 188, 0, 0, 255, 255, 213, 208, 1, 4, 255, 255, 199, 192, 0, 8, 76, 77, 84, 0, 45, 48, 51, 0, 45, 48, 52, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 52, 62, 52, 10}, - - "zoneinfo/CET": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 136, 0, 0, 0, 4, 0, 0, 0, 9, 155, 12, 23, 96, 155, 213, 218, 240, 156, 217, 174, 144, 157, 164, 181, 144, 158, 185, 144, 144, 159, 132, 151, 144, 200, 9, 113, 144, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 209, 114, 22, 16, 210, 78, 64, 144, 13, 164, 99, 144, 14, 139, 26, 16, 15, 132, 69, 144, 16, 116, 54, 144, 17, 100, 39, 144, 18, 84, 24, 144, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 0, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 0, 0, 28, 32, 1, 0, 0, 0, 14, 16, 0, 5, 0, 0, 28, 32, 1, 0, 0, 0, 14, 16, 0, 5, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 1, 1, 0, 0, 0, 0, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/CST6CDT": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 149, 0, 0, 0, 4, 0, 0, 0, 16, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 250, 248, 103, 0, 251, 232, 73, 240, 252, 216, 73, 0, 253, 200, 43, 240, 254, 184, 43, 0, 255, 168, 13, 240, 0, 152, 13, 0, 1, 135, 239, 240, 2, 119, 239, 0, 3, 113, 12, 112, 4, 97, 11, 128, 5, 80, 238, 112, 6, 64, 237, 128, 7, 48, 208, 112, 7, 141, 39, 128, 9, 16, 178, 112, 9, 173, 163, 0, 10, 240, 148, 112, 11, 224, 147, 128, 12, 217, 176, 240, 13, 192, 117, 128, 14, 185, 146, 240, 15, 169, 146, 0, 16, 153, 116, 240, 17, 137, 116, 0, 18, 121, 86, 240, 19, 105, 86, 0, 20, 89, 56, 240, 21, 73, 56, 0, 22, 57, 26, 240, 23, 41, 26, 0, 24, 34, 55, 112, 25, 8, 252, 0, 26, 2, 25, 112, 26, 242, 24, 128, 27, 225, 251, 112, 28, 209, 250, 128, 29, 193, 221, 112, 30, 177, 220, 128, 31, 161, 191, 112, 32, 118, 15, 0, 33, 129, 161, 112, 34, 85, 241, 0, 35, 106, 189, 240, 36, 53, 211, 0, 37, 74, 159, 240, 38, 21, 181, 0, 39, 42, 129, 240, 39, 254, 209, 128, 41, 10, 99, 240, 41, 222, 179, 128, 42, 234, 69, 240, 43, 190, 149, 128, 44, 211, 98, 112, 45, 158, 119, 128, 46, 179, 68, 112, 47, 126, 89, 128, 48, 147, 38, 112, 49, 103, 118, 0, 50, 115, 8, 112, 51, 71, 88, 0, 52, 82, 234, 112, 53, 39, 58, 0, 54, 50, 204, 112, 55, 7, 28, 0, 56, 27, 232, 240, 56, 230, 254, 0, 57, 251, 202, 240, 58, 198, 224, 0, 59, 219, 172, 240, 60, 175, 252, 128, 61, 187, 142, 240, 62, 143, 222, 128, 63, 155, 112, 240, 64, 111, 192, 128, 65, 132, 141, 112, 66, 79, 162, 128, 67, 100, 111, 112, 68, 47, 132, 128, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 109, 240, 71, 211, 153, 0, 73, 13, 79, 240, 73, 179, 123, 0, 74, 237, 49, 240, 75, 156, 151, 128, 76, 214, 78, 112, 77, 124, 121, 128, 78, 182, 48, 112, 79, 92, 91, 128, 80, 150, 18, 112, 81, 60, 61, 128, 82, 117, 244, 112, 83, 28, 31, 128, 84, 85, 214, 112, 84, 252, 1, 128, 86, 53, 184, 112, 86, 229, 30, 0, 88, 30, 212, 240, 88, 197, 0, 0, 89, 254, 182, 240, 90, 164, 226, 0, 91, 222, 152, 240, 92, 132, 196, 0, 93, 190, 122, 240, 94, 100, 166, 0, 95, 158, 92, 240, 96, 77, 194, 128, 97, 135, 121, 112, 98, 45, 164, 128, 99, 103, 91, 112, 100, 13, 134, 128, 101, 71, 61, 112, 101, 237, 104, 128, 103, 39, 31, 112, 103, 205, 74, 128, 105, 7, 1, 112, 105, 173, 44, 128, 106, 230, 227, 112, 107, 150, 73, 0, 108, 207, 255, 240, 109, 118, 43, 0, 110, 175, 225, 240, 111, 86, 13, 0, 112, 143, 195, 240, 113, 53, 239, 0, 114, 111, 165, 240, 115, 21, 209, 0, 116, 79, 135, 240, 116, 254, 237, 128, 118, 56, 164, 112, 118, 222, 207, 128, 120, 24, 134, 112, 120, 190, 177, 128, 121, 248, 104, 112, 122, 158, 147, 128, 123, 216, 74, 112, 124, 126, 117, 128, 125, 184, 44, 112, 126, 94, 87, 128, 127, 152, 14, 112, 0, 1, 0, 1, 2, 3, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 255, 255, 185, 176, 1, 0, 255, 255, 171, 160, 0, 4, 255, 255, 185, 176, 1, 8, 255, 255, 185, 176, 1, 12, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 0, 0, 0, 1, 0, 0, 0, 1, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/Canada/Atlantic": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 229, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 128, 241, 171, 160, 154, 228, 222, 192, 155, 214, 19, 48, 158, 184, 133, 96, 159, 186, 221, 80, 162, 157, 23, 64, 163, 48, 177, 48, 164, 122, 86, 64, 165, 27, 31, 48, 166, 83, 160, 192, 166, 252, 82, 176, 168, 60, 189, 64, 168, 220, 52, 176, 170, 28, 159, 64, 170, 205, 58, 48, 171, 252, 129, 64, 172, 191, 145, 48, 173, 238, 216, 64, 174, 140, 254, 48, 175, 188, 69, 64, 176, 127, 85, 48, 177, 174, 156, 64, 178, 75, 112, 176, 179, 142, 126, 64, 180, 36, 187, 48, 181, 110, 96, 64, 182, 21, 192, 176, 183, 78, 66, 64, 184, 8, 23, 176, 185, 36, 233, 192, 185, 231, 249, 176, 187, 4, 203, 192, 187, 209, 22, 48, 189, 0, 93, 64, 189, 157, 49, 176, 190, 242, 180, 64, 191, 144, 218, 48, 192, 211, 231, 192, 193, 94, 71, 48, 194, 141, 142, 64, 195, 80, 158, 48, 196, 109, 112, 64, 197, 48, 128, 48, 198, 114, 60, 64, 199, 16, 98, 48, 200, 54, 110, 192, 200, 249, 126, 176, 202, 22, 80, 192, 202, 217, 96, 176, 203, 136, 226, 96, 210, 35, 244, 112, 210, 96, 237, 208, 211, 117, 214, 224, 212, 64, 207, 208, 213, 85, 184, 224, 214, 32, 177, 208, 215, 53, 154, 224, 216, 0, 147, 208, 217, 21, 124, 224, 217, 224, 117, 208, 220, 222, 123, 96, 221, 169, 116, 80, 222, 190, 93, 96, 223, 137, 86, 80, 224, 158, 63, 96, 225, 105, 56, 80, 226, 126, 33, 96, 227, 73, 26, 80, 230, 71, 31, 224, 231, 18, 24, 208, 232, 39, 1, 224, 232, 241, 250, 208, 234, 6, 227, 224, 234, 209, 220, 208, 235, 230, 197, 224, 236, 177, 190, 208, 241, 143, 166, 96, 242, 127, 137, 80, 243, 111, 136, 96, 244, 95, 107, 80, 245, 79, 106, 96, 246, 63, 77, 80, 247, 47, 76, 96, 248, 40, 105, 208, 249, 15, 46, 96, 250, 8, 75, 208, 250, 248, 74, 224, 251, 232, 45, 208, 252, 216, 44, 224, 253, 200, 15, 208, 254, 184, 14, 224, 255, 167, 241, 208, 0, 151, 240, 224, 1, 135, 211, 208, 2, 119, 210, 224, 3, 112, 240, 80, 4, 96, 239, 96, 5, 80, 210, 80, 6, 64, 209, 96, 7, 48, 180, 80, 8, 32, 179, 96, 9, 16, 150, 80, 10, 0, 149, 96, 10, 240, 120, 80, 11, 224, 119, 96, 12, 217, 148, 208, 13, 192, 89, 96, 14, 185, 118, 208, 15, 169, 117, 224, 16, 153, 88, 208, 17, 137, 87, 224, 18, 121, 58, 208, 19, 105, 57, 224, 20, 89, 28, 208, 21, 73, 27, 224, 22, 56, 254, 208, 23, 40, 253, 224, 24, 34, 27, 80, 25, 8, 223, 224, 26, 1, 253, 80, 26, 241, 252, 96, 27, 225, 223, 80, 28, 209, 222, 96, 29, 193, 193, 80, 30, 177, 192, 96, 31, 161, 163, 80, 32, 117, 242, 224, 33, 129, 133, 80, 34, 85, 212, 224, 35, 106, 161, 208, 36, 53, 182, 224, 37, 74, 131, 208, 38, 21, 152, 224, 39, 42, 101, 208, 39, 254, 181, 96, 41, 10, 71, 208, 41, 222, 151, 96, 42, 234, 41, 208, 43, 190, 121, 96, 44, 211, 70, 80, 45, 158, 91, 96, 46, 179, 40, 80, 47, 126, 61, 96, 48, 147, 10, 80, 49, 103, 89, 224, 50, 114, 236, 80, 51, 71, 59, 224, 52, 82, 206, 80, 53, 39, 29, 224, 54, 50, 176, 80, 55, 6, 255, 224, 56, 27, 204, 208, 56, 230, 225, 224, 57, 251, 174, 208, 58, 198, 195, 224, 59, 219, 144, 208, 60, 175, 224, 96, 61, 187, 114, 208, 62, 143, 194, 96, 63, 155, 84, 208, 64, 111, 164, 96, 65, 132, 113, 80, 66, 79, 134, 96, 67, 100, 83, 80, 68, 47, 104, 96, 69, 68, 53, 80, 69, 243, 154, 224, 71, 45, 81, 208, 71, 211, 124, 224, 73, 13, 51, 208, 73, 179, 94, 224, 74, 237, 21, 208, 75, 156, 123, 96, 76, 214, 50, 80, 77, 124, 93, 96, 78, 182, 20, 80, 79, 92, 63, 96, 80, 149, 246, 80, 81, 60, 33, 96, 82, 117, 216, 80, 83, 28, 3, 96, 84, 85, 186, 80, 84, 251, 229, 96, 86, 53, 156, 80, 86, 229, 1, 224, 88, 30, 184, 208, 88, 196, 227, 224, 89, 254, 154, 208, 90, 164, 197, 224, 91, 222, 124, 208, 92, 132, 167, 224, 93, 190, 94, 208, 94, 100, 137, 224, 95, 158, 64, 208, 96, 77, 166, 96, 97, 135, 93, 80, 98, 45, 136, 96, 99, 103, 63, 80, 100, 13, 106, 96, 101, 71, 33, 80, 101, 237, 76, 96, 103, 39, 3, 80, 103, 205, 46, 96, 105, 6, 229, 80, 105, 173, 16, 96, 106, 230, 199, 80, 107, 150, 44, 224, 108, 207, 227, 208, 109, 118, 14, 224, 110, 175, 197, 208, 111, 85, 240, 224, 112, 143, 167, 208, 113, 53, 210, 224, 114, 111, 137, 208, 115, 21, 180, 224, 116, 79, 107, 208, 116, 254, 209, 96, 118, 56, 136, 80, 118, 222, 179, 96, 120, 24, 106, 80, 120, 190, 149, 96, 121, 248, 76, 80, 122, 158, 119, 96, 123, 216, 46, 80, 124, 126, 89, 96, 125, 184, 16, 80, 126, 94, 59, 96, 127, 151, 242, 80, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 196, 96, 0, 0, 255, 255, 213, 208, 1, 4, 255, 255, 199, 192, 0, 8, 255, 255, 213, 208, 1, 12, 255, 255, 213, 208, 1, 16, 76, 77, 84, 0, 65, 68, 84, 0, 65, 83, 84, 0, 65, 87, 84, 0, 65, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 65, 83, 84, 52, 65, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/Canada/Central": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 187, 0, 0, 0, 7, 0, 0, 0, 20, 128, 0, 0, 0, 155, 1, 251, 224, 155, 195, 186, 80, 158, 184, 161, 128, 159, 186, 249, 112, 194, 160, 59, 128, 195, 79, 132, 240, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 211, 136, 104, 0, 212, 83, 96, 240, 213, 85, 213, 0, 214, 32, 205, 240, 215, 53, 183, 0, 216, 0, 175, 240, 217, 21, 153, 0, 217, 224, 145, 240, 219, 0, 7, 0, 219, 200, 92, 240, 220, 222, 151, 128, 221, 169, 144, 112, 222, 190, 121, 128, 223, 137, 114, 112, 224, 158, 91, 128, 225, 105, 84, 112, 226, 126, 61, 128, 227, 73, 54, 112, 228, 94, 31, 128, 229, 41, 24, 112, 230, 71, 60, 0, 231, 18, 52, 240, 232, 39, 30, 0, 232, 242, 22, 240, 234, 7, 0, 0, 234, 209, 248, 240, 235, 230, 226, 0, 236, 214, 196, 240, 237, 198, 196, 0, 238, 145, 188, 240, 243, 111, 164, 128, 244, 49, 98, 240, 249, 15, 74, 128, 250, 8, 118, 0, 250, 248, 103, 0, 251, 232, 88, 0, 252, 216, 73, 0, 253, 200, 58, 0, 254, 184, 43, 0, 255, 168, 28, 0, 0, 152, 13, 0, 1, 135, 254, 0, 2, 119, 239, 0, 3, 113, 26, 128, 4, 97, 11, 128, 5, 80, 252, 128, 6, 64, 237, 128, 7, 48, 222, 128, 8, 32, 207, 128, 9, 16, 192, 128, 10, 0, 177, 128, 10, 240, 162, 128, 11, 224, 147, 128, 12, 217, 191, 0, 13, 192, 117, 128, 14, 185, 161, 0, 15, 169, 146, 0, 16, 153, 131, 0, 17, 137, 116, 0, 18, 121, 101, 0, 19, 105, 86, 0, 20, 89, 71, 0, 21, 73, 56, 0, 22, 57, 41, 0, 23, 41, 26, 0, 24, 34, 69, 128, 25, 8, 252, 0, 26, 2, 39, 128, 26, 242, 24, 128, 27, 226, 9, 128, 28, 209, 250, 128, 29, 193, 235, 128, 30, 177, 220, 128, 31, 161, 205, 128, 32, 118, 15, 0, 33, 129, 175, 128, 34, 85, 241, 0, 35, 106, 204, 0, 36, 53, 211, 0, 37, 74, 174, 0, 38, 21, 181, 0, 39, 42, 144, 0, 39, 254, 209, 128, 41, 10, 114, 0, 41, 222, 179, 128, 42, 234, 84, 0, 43, 190, 149, 128, 44, 211, 112, 128, 45, 158, 119, 128, 46, 179, 82, 128, 47, 126, 89, 128, 48, 147, 52, 128, 49, 103, 118, 0, 50, 115, 22, 128, 51, 71, 88, 0, 52, 82, 248, 128, 53, 39, 58, 0, 54, 50, 218, 128, 55, 7, 28, 0, 56, 27, 247, 0, 56, 230, 254, 0, 57, 251, 217, 0, 58, 198, 224, 0, 59, 219, 187, 0, 60, 175, 252, 128, 61, 187, 157, 0, 62, 143, 222, 128, 63, 155, 127, 0, 64, 111, 192, 128, 65, 132, 155, 128, 66, 79, 162, 128, 67, 100, 125, 128, 67, 183, 111, 224, 68, 47, 132, 128, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 109, 240, 71, 211, 153, 0, 73, 13, 79, 240, 73, 179, 123, 0, 74, 237, 49, 240, 75, 156, 151, 128, 76, 214, 78, 112, 77, 124, 121, 128, 78, 182, 48, 112, 79, 92, 91, 128, 80, 150, 18, 112, 81, 60, 61, 128, 82, 117, 244, 112, 83, 28, 31, 128, 84, 85, 214, 112, 84, 252, 1, 128, 86, 53, 184, 112, 86, 229, 30, 0, 88, 30, 212, 240, 88, 197, 0, 0, 89, 254, 182, 240, 90, 164, 226, 0, 91, 222, 152, 240, 92, 132, 196, 0, 93, 190, 122, 240, 94, 100, 166, 0, 95, 158, 92, 240, 96, 77, 194, 128, 97, 135, 121, 112, 98, 45, 164, 128, 99, 103, 91, 112, 100, 13, 134, 128, 101, 71, 61, 112, 101, 237, 104, 128, 103, 39, 31, 112, 103, 205, 74, 128, 105, 7, 1, 112, 105, 173, 44, 128, 106, 230, 227, 112, 107, 150, 73, 0, 108, 207, 255, 240, 109, 118, 43, 0, 110, 175, 225, 240, 111, 86, 13, 0, 112, 143, 195, 240, 113, 53, 239, 0, 114, 111, 165, 240, 115, 21, 209, 0, 116, 79, 135, 240, 116, 254, 237, 128, 118, 56, 164, 112, 118, 222, 207, 128, 120, 24, 134, 112, 120, 190, 177, 128, 121, 248, 104, 112, 122, 158, 147, 128, 123, 216, 74, 112, 124, 126, 117, 128, 125, 184, 44, 112, 126, 94, 87, 128, 127, 152, 14, 112, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 164, 236, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/Canada/Eastern": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 233, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 158, 184, 147, 112, 159, 186, 235, 96, 160, 135, 46, 200, 161, 154, 177, 64, 162, 148, 6, 240, 163, 85, 169, 64, 164, 134, 93, 240, 165, 40, 120, 96, 166, 102, 63, 240, 167, 12, 78, 224, 168, 70, 33, 240, 168, 236, 48, 224, 170, 28, 201, 112, 170, 213, 77, 96, 171, 252, 171, 112, 172, 181, 47, 96, 173, 220, 141, 112, 174, 149, 17, 96, 175, 188, 111, 112, 176, 126, 45, 224, 177, 156, 81, 112, 178, 103, 74, 96, 179, 124, 51, 112, 180, 71, 44, 96, 181, 92, 21, 112, 182, 39, 14, 96, 183, 59, 247, 112, 184, 6, 240, 96, 185, 37, 19, 240, 185, 230, 210, 96, 187, 4, 245, 240, 187, 207, 238, 224, 188, 228, 215, 240, 189, 175, 208, 224, 190, 196, 185, 240, 191, 143, 178, 224, 192, 164, 155, 240, 193, 111, 148, 224, 194, 132, 125, 240, 195, 79, 118, 224, 196, 100, 95, 240, 197, 47, 88, 224, 198, 77, 124, 112, 199, 15, 58, 224, 200, 45, 94, 112, 203, 136, 240, 112, 210, 35, 244, 112, 210, 96, 251, 224, 211, 117, 228, 240, 212, 64, 221, 224, 213, 85, 170, 208, 214, 32, 163, 192, 215, 53, 140, 208, 216, 0, 133, 192, 217, 21, 110, 208, 218, 51, 118, 64, 218, 254, 167, 112, 220, 19, 116, 96, 220, 222, 137, 112, 221, 169, 130, 96, 222, 190, 107, 112, 223, 137, 100, 96, 224, 158, 77, 112, 225, 105, 70, 96, 226, 126, 47, 112, 227, 73, 40, 96, 228, 94, 17, 112, 229, 41, 10, 96, 230, 71, 45, 240, 231, 18, 38, 224, 232, 39, 15, 240, 233, 22, 242, 224, 234, 6, 241, 240, 234, 246, 212, 224, 235, 230, 211, 240, 236, 214, 182, 224, 237, 198, 181, 240, 238, 191, 211, 96, 239, 175, 210, 112, 240, 159, 181, 96, 241, 143, 180, 112, 242, 127, 151, 96, 243, 111, 150, 112, 244, 95, 121, 96, 245, 79, 120, 112, 246, 63, 91, 96, 247, 47, 90, 112, 248, 40, 119, 224, 249, 15, 60, 112, 250, 8, 89, 224, 250, 248, 88, 240, 251, 232, 59, 224, 252, 216, 58, 240, 253, 200, 29, 224, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 2, 119, 224, 240, 3, 112, 254, 96, 4, 96, 253, 112, 5, 80, 224, 96, 6, 64, 223, 112, 7, 48, 194, 96, 8, 32, 193, 112, 9, 16, 164, 96, 10, 0, 163, 112, 10, 240, 134, 96, 11, 224, 133, 112, 12, 217, 162, 224, 13, 192, 103, 112, 14, 185, 132, 224, 15, 169, 131, 240, 16, 153, 102, 224, 17, 137, 101, 240, 18, 121, 72, 224, 19, 105, 71, 240, 20, 89, 42, 224, 21, 73, 41, 240, 22, 57, 12, 224, 23, 41, 11, 240, 24, 34, 41, 96, 25, 8, 237, 240, 26, 2, 11, 96, 26, 242, 10, 112, 27, 225, 237, 96, 28, 209, 236, 112, 29, 193, 207, 96, 30, 177, 206, 112, 31, 161, 177, 96, 32, 118, 0, 240, 33, 129, 147, 96, 34, 85, 226, 240, 35, 106, 175, 224, 36, 53, 196, 240, 37, 74, 145, 224, 38, 21, 166, 240, 39, 42, 115, 224, 39, 254, 195, 112, 41, 10, 85, 224, 41, 222, 165, 112, 42, 234, 55, 224, 43, 190, 135, 112, 44, 211, 84, 96, 45, 158, 105, 112, 46, 179, 54, 96, 47, 126, 75, 112, 48, 147, 24, 96, 49, 103, 103, 240, 50, 114, 250, 96, 51, 71, 73, 240, 52, 82, 220, 96, 53, 39, 43, 240, 54, 50, 190, 96, 55, 7, 13, 240, 56, 27, 218, 224, 56, 230, 239, 240, 57, 251, 188, 224, 58, 198, 209, 240, 59, 219, 158, 224, 60, 175, 238, 112, 61, 187, 128, 224, 62, 143, 208, 112, 63, 155, 98, 224, 64, 111, 178, 112, 65, 132, 127, 96, 66, 79, 148, 112, 67, 100, 97, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 181, 148, 0, 0, 255, 255, 199, 192, 1, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 1, 12, 255, 255, 199, 192, 1, 16, 76, 77, 84, 0, 69, 68, 84, 0, 69, 83, 84, 0, 69, 87, 84, 0, 69, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/Canada/Mountain": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 155, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 136, 222, 206, 224, 158, 184, 175, 144, 159, 187, 7, 128, 160, 152, 145, 144, 160, 210, 133, 128, 162, 138, 232, 144, 163, 132, 6, 0, 164, 106, 202, 144, 165, 53, 195, 128, 166, 83, 231, 16, 167, 21, 165, 128, 168, 51, 201, 16, 168, 254, 194, 0, 203, 137, 12, 144, 210, 35, 244, 112, 210, 97, 24, 0, 213, 85, 227, 16, 214, 32, 220, 0, 250, 248, 117, 16, 251, 232, 88, 0, 254, 184, 57, 16, 255, 168, 28, 0, 4, 97, 25, 144, 5, 80, 252, 128, 6, 64, 251, 144, 7, 48, 222, 128, 8, 32, 221, 144, 9, 16, 192, 128, 10, 0, 191, 144, 10, 240, 162, 128, 11, 224, 161, 144, 12, 217, 191, 0, 13, 192, 131, 144, 14, 185, 161, 0, 15, 169, 160, 16, 16, 153, 131, 0, 17, 137, 130, 16, 18, 121, 101, 0, 19, 105, 100, 16, 20, 89, 71, 0, 21, 73, 70, 16, 22, 57, 41, 0, 23, 41, 40, 16, 24, 34, 69, 128, 25, 9, 10, 16, 26, 2, 39, 128, 26, 242, 38, 144, 27, 226, 9, 128, 28, 210, 8, 144, 29, 193, 235, 128, 30, 177, 234, 144, 31, 161, 205, 128, 32, 118, 29, 16, 33, 129, 175, 128, 34, 85, 255, 16, 35, 106, 204, 0, 36, 53, 225, 16, 37, 74, 174, 0, 38, 21, 195, 16, 39, 42, 144, 0, 39, 254, 223, 144, 41, 10, 114, 0, 41, 222, 193, 144, 42, 234, 84, 0, 43, 190, 163, 144, 44, 211, 112, 128, 45, 158, 133, 144, 46, 179, 82, 128, 47, 126, 103, 144, 48, 147, 52, 128, 49, 103, 132, 16, 50, 115, 22, 128, 51, 71, 102, 16, 52, 82, 248, 128, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 231, 12, 16, 57, 251, 217, 0, 58, 198, 238, 16, 59, 219, 187, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 206, 144, 65, 132, 155, 128, 66, 79, 176, 144, 67, 100, 125, 128, 68, 47, 146, 144, 69, 68, 95, 128, 69, 243, 197, 16, 71, 45, 124, 0, 71, 211, 167, 16, 73, 13, 94, 0, 73, 179, 137, 16, 74, 237, 64, 0, 75, 156, 165, 144, 76, 214, 92, 128, 77, 124, 135, 144, 78, 182, 62, 128, 79, 92, 105, 144, 80, 150, 32, 128, 81, 60, 75, 144, 82, 118, 2, 128, 83, 28, 45, 144, 84, 85, 228, 128, 84, 252, 15, 144, 86, 53, 198, 128, 86, 229, 44, 16, 88, 30, 227, 0, 88, 197, 14, 16, 89, 254, 197, 0, 90, 164, 240, 16, 91, 222, 167, 0, 92, 132, 210, 16, 93, 190, 137, 0, 94, 100, 180, 16, 95, 158, 107, 0, 96, 77, 208, 144, 97, 135, 135, 128, 98, 45, 178, 144, 99, 103, 105, 128, 100, 13, 148, 144, 101, 71, 75, 128, 101, 237, 118, 144, 103, 39, 45, 128, 103, 205, 88, 144, 105, 7, 15, 128, 105, 173, 58, 144, 106, 230, 241, 128, 107, 150, 87, 16, 108, 208, 14, 0, 109, 118, 57, 16, 110, 175, 240, 0, 111, 86, 27, 16, 112, 143, 210, 0, 113, 53, 253, 16, 114, 111, 180, 0, 115, 21, 223, 16, 116, 79, 150, 0, 116, 254, 251, 144, 118, 56, 178, 128, 118, 222, 221, 144, 120, 24, 148, 128, 120, 190, 191, 144, 121, 248, 118, 128, 122, 158, 161, 144, 123, 216, 88, 128, 124, 126, 131, 144, 125, 184, 58, 128, 126, 94, 101, 144, 127, 152, 28, 128, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 149, 160, 0, 0, 255, 255, 171, 160, 1, 4, 255, 255, 157, 144, 0, 8, 255, 255, 171, 160, 1, 12, 255, 255, 171, 160, 1, 16, 76, 77, 84, 0, 77, 68, 84, 0, 77, 83, 84, 0, 77, 87, 84, 0, 77, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 77, 83, 84, 55, 77, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/Canada/Newfoundland": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 239, 0, 0, 0, 9, 0, 0, 0, 25, 128, 0, 0, 0, 156, 207, 98, 12, 157, 164, 230, 252, 158, 184, 126, 140, 159, 186, 214, 124, 160, 182, 136, 220, 161, 56, 255, 76, 162, 149, 25, 92, 163, 132, 252, 76, 164, 116, 251, 92, 165, 100, 222, 76, 166, 94, 23, 220, 167, 68, 192, 76, 168, 61, 249, 220, 169, 36, 162, 76, 170, 29, 219, 220, 171, 4, 132, 76, 171, 253, 189, 220, 172, 228, 102, 76, 173, 221, 159, 220, 174, 205, 130, 204, 175, 189, 129, 220, 176, 173, 100, 204, 177, 166, 158, 92, 178, 141, 70, 204, 179, 134, 128, 92, 180, 109, 40, 204, 181, 102, 98, 92, 182, 77, 10, 204, 183, 70, 68, 92, 184, 44, 236, 204, 185, 38, 38, 92, 186, 22, 9, 76, 187, 15, 66, 220, 187, 245, 235, 76, 188, 239, 36, 220, 189, 213, 205, 76, 190, 158, 77, 108, 190, 207, 6, 168, 191, 181, 175, 24, 192, 184, 49, 56, 193, 121, 239, 168, 194, 152, 19, 56, 195, 89, 209, 168, 196, 119, 245, 56, 197, 57, 179, 168, 198, 97, 17, 184, 199, 25, 149, 168, 200, 64, 243, 184, 201, 2, 178, 40, 202, 32, 213, 184, 202, 226, 148, 40, 204, 0, 183, 184, 210, 35, 244, 112, 210, 96, 230, 200, 211, 136, 68, 216, 212, 74, 3, 72, 213, 104, 38, 216, 214, 41, 229, 72, 215, 72, 8, 216, 216, 9, 199, 72, 217, 39, 234, 216, 217, 233, 169, 72, 219, 17, 7, 88, 219, 210, 197, 200, 220, 222, 116, 88, 221, 169, 109, 72, 222, 190, 86, 88, 223, 137, 79, 72, 224, 158, 56, 88, 225, 105, 49, 72, 226, 126, 26, 88, 227, 73, 19, 72, 228, 93, 252, 88, 229, 40, 245, 72, 230, 71, 24, 216, 231, 18, 17, 200, 232, 38, 250, 216, 232, 241, 243, 200, 234, 6, 220, 216, 234, 209, 213, 200, 235, 230, 190, 216, 236, 177, 183, 200, 237, 198, 160, 216, 238, 191, 190, 72, 239, 175, 189, 88, 240, 159, 160, 72, 241, 143, 159, 88, 242, 127, 130, 72, 243, 111, 129, 88, 244, 95, 100, 72, 245, 79, 99, 88, 246, 63, 70, 72, 247, 47, 69, 88, 248, 40, 98, 200, 249, 15, 39, 88, 250, 8, 68, 200, 250, 248, 67, 216, 251, 232, 38, 200, 252, 216, 37, 216, 253, 200, 8, 200, 254, 184, 7, 216, 255, 167, 234, 200, 0, 151, 233, 216, 1, 135, 204, 200, 2, 119, 203, 216, 3, 112, 233, 72, 4, 96, 232, 88, 5, 80, 203, 72, 6, 64, 202, 88, 7, 48, 173, 72, 8, 32, 172, 88, 9, 16, 143, 72, 10, 0, 142, 88, 10, 240, 113, 72, 11, 224, 112, 88, 12, 217, 141, 200, 13, 192, 82, 88, 14, 185, 111, 200, 15, 169, 110, 216, 16, 153, 81, 200, 17, 137, 80, 216, 18, 121, 51, 200, 19, 105, 50, 216, 20, 89, 21, 200, 21, 73, 20, 216, 22, 56, 247, 200, 23, 40, 246, 216, 24, 34, 20, 72, 25, 8, 216, 216, 26, 1, 246, 72, 26, 241, 245, 88, 27, 225, 216, 72, 28, 209, 215, 88, 29, 193, 186, 72, 30, 177, 185, 88, 31, 161, 156, 72, 32, 117, 207, 244, 33, 129, 98, 100, 34, 85, 177, 244, 35, 106, 112, 212, 36, 53, 147, 244, 37, 74, 96, 228, 38, 21, 117, 244, 39, 42, 66, 228, 39, 254, 146, 116, 41, 10, 36, 228, 41, 222, 116, 116, 42, 234, 6, 228, 43, 190, 86, 116, 44, 211, 35, 100, 45, 158, 56, 116, 46, 179, 5, 100, 47, 126, 26, 116, 48, 146, 231, 100, 49, 103, 54, 244, 50, 114, 201, 100, 51, 71, 24, 244, 52, 82, 171, 100, 53, 38, 250, 244, 54, 50, 141, 100, 55, 6, 220, 244, 56, 27, 169, 228, 56, 230, 190, 244, 57, 251, 139, 228, 58, 198, 160, 244, 59, 219, 109, 228, 60, 175, 189, 116, 61, 187, 79, 228, 62, 143, 159, 116, 63, 155, 49, 228, 64, 111, 129, 116, 65, 132, 78, 100, 66, 79, 99, 116, 67, 100, 48, 100, 68, 47, 69, 116, 69, 68, 18, 100, 69, 243, 119, 244, 71, 45, 46, 228, 71, 211, 89, 244, 73, 13, 16, 228, 73, 179, 59, 244, 74, 236, 242, 228, 75, 156, 88, 116, 76, 214, 15, 100, 77, 124, 58, 116, 78, 182, 13, 72, 79, 92, 56, 88, 80, 149, 239, 72, 81, 60, 26, 88, 82, 117, 209, 72, 83, 27, 252, 88, 84, 85, 179, 72, 84, 251, 222, 88, 86, 53, 149, 72, 86, 228, 250, 216, 88, 30, 177, 200, 88, 196, 220, 216, 89, 254, 147, 200, 90, 164, 190, 216, 91, 222, 117, 200, 92, 132, 160, 216, 93, 190, 87, 200, 94, 100, 130, 216, 95, 158, 57, 200, 96, 77, 159, 88, 97, 135, 86, 72, 98, 45, 129, 88, 99, 103, 56, 72, 100, 13, 99, 88, 101, 71, 26, 72, 101, 237, 69, 88, 103, 38, 252, 72, 103, 205, 39, 88, 105, 6, 222, 72, 105, 173, 9, 88, 106, 230, 192, 72, 107, 150, 37, 216, 108, 207, 220, 200, 109, 118, 7, 216, 110, 175, 190, 200, 111, 85, 233, 216, 112, 143, 160, 200, 113, 53, 203, 216, 114, 111, 130, 200, 115, 21, 173, 216, 116, 79, 100, 200, 116, 254, 202, 88, 118, 56, 129, 72, 118, 222, 172, 88, 120, 24, 99, 72, 120, 190, 142, 88, 121, 248, 69, 72, 122, 158, 112, 88, 123, 216, 39, 72, 124, 126, 82, 88, 125, 184, 9, 72, 126, 94, 52, 88, 127, 151, 235, 72, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 6, 5, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 7, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 255, 255, 206, 148, 0, 0, 255, 255, 220, 164, 1, 4, 255, 255, 206, 148, 0, 8, 255, 255, 220, 216, 1, 4, 255, 255, 206, 200, 0, 8, 255, 255, 220, 216, 1, 12, 255, 255, 220, 216, 1, 16, 255, 255, 234, 232, 1, 20, 255, 255, 220, 216, 1, 4, 76, 77, 84, 0, 78, 68, 84, 0, 78, 83, 84, 0, 78, 80, 84, 0, 78, 87, 84, 0, 78, 68, 68, 84, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 10, 78, 83, 84, 51, 58, 51, 48, 78, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/Canada/Pacific": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 190, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 158, 184, 189, 160, 159, 187, 21, 144, 203, 137, 26, 160, 210, 35, 244, 112, 210, 97, 38, 16, 211, 118, 15, 32, 212, 83, 125, 16, 213, 85, 241, 32, 214, 32, 234, 16, 215, 53, 211, 32, 216, 0, 204, 16, 217, 21, 181, 32, 217, 224, 174, 16, 218, 254, 209, 160, 219, 192, 144, 16, 220, 222, 179, 160, 221, 169, 172, 144, 222, 190, 149, 160, 223, 137, 142, 144, 224, 158, 119, 160, 225, 105, 112, 144, 226, 126, 89, 160, 227, 73, 82, 144, 228, 94, 59, 160, 229, 41, 52, 144, 230, 71, 88, 32, 231, 18, 81, 16, 232, 39, 58, 32, 232, 242, 51, 16, 234, 7, 28, 32, 234, 210, 21, 16, 235, 230, 254, 32, 236, 177, 247, 16, 237, 198, 224, 32, 238, 145, 217, 16, 239, 175, 252, 160, 240, 113, 187, 16, 241, 143, 222, 160, 242, 127, 193, 144, 243, 111, 192, 160, 244, 95, 163, 144, 245, 79, 162, 160, 246, 63, 133, 144, 247, 47, 132, 160, 248, 40, 162, 16, 249, 15, 102, 160, 250, 8, 132, 16, 250, 248, 131, 32, 251, 232, 102, 16, 252, 216, 101, 32, 253, 200, 72, 16, 254, 184, 71, 32, 255, 168, 42, 16, 0, 152, 41, 32, 1, 136, 12, 16, 2, 120, 11, 32, 3, 113, 40, 144, 4, 97, 39, 160, 5, 81, 10, 144, 6, 65, 9, 160, 7, 48, 236, 144, 8, 32, 235, 160, 9, 16, 206, 144, 10, 0, 205, 160, 10, 240, 176, 144, 11, 224, 175, 160, 12, 217, 205, 16, 13, 192, 145, 160, 14, 185, 175, 16, 15, 169, 174, 32, 16, 153, 145, 16, 17, 137, 144, 32, 18, 121, 115, 16, 19, 105, 114, 32, 20, 89, 85, 16, 21, 73, 84, 32, 22, 57, 55, 16, 23, 41, 54, 32, 24, 34, 83, 144, 25, 9, 24, 32, 26, 2, 53, 144, 26, 242, 52, 160, 27, 226, 23, 144, 28, 210, 22, 160, 29, 193, 249, 144, 30, 177, 248, 160, 31, 161, 219, 144, 32, 118, 43, 32, 33, 129, 189, 144, 34, 86, 13, 32, 35, 106, 218, 16, 36, 53, 239, 32, 37, 74, 188, 16, 38, 21, 209, 32, 39, 42, 158, 16, 39, 254, 237, 160, 41, 10, 128, 16, 41, 222, 207, 160, 42, 234, 98, 16, 43, 190, 177, 160, 44, 211, 126, 144, 45, 158, 147, 160, 46, 179, 96, 144, 47, 126, 117, 160, 48, 147, 66, 144, 49, 103, 146, 32, 50, 115, 36, 144, 51, 71, 116, 32, 52, 83, 6, 144, 53, 39, 86, 32, 54, 50, 232, 144, 55, 7, 56, 32, 56, 28, 5, 16, 56, 231, 26, 32, 57, 251, 231, 16, 58, 198, 252, 32, 59, 219, 201, 16, 60, 176, 24, 160, 61, 187, 171, 16, 62, 143, 250, 160, 63, 155, 141, 16, 64, 111, 220, 160, 65, 132, 169, 144, 66, 79, 190, 160, 67, 100, 139, 144, 68, 47, 160, 160, 69, 68, 109, 144, 69, 243, 211, 32, 71, 45, 138, 16, 71, 211, 181, 32, 73, 13, 108, 16, 73, 179, 151, 32, 74, 237, 78, 16, 75, 156, 179, 160, 76, 214, 106, 144, 77, 124, 149, 160, 78, 182, 76, 144, 79, 92, 119, 160, 80, 150, 46, 144, 81, 60, 89, 160, 82, 118, 16, 144, 83, 28, 59, 160, 84, 85, 242, 144, 84, 252, 29, 160, 86, 53, 212, 144, 86, 229, 58, 32, 88, 30, 241, 16, 88, 197, 28, 32, 89, 254, 211, 16, 90, 164, 254, 32, 91, 222, 181, 16, 92, 132, 224, 32, 93, 190, 151, 16, 94, 100, 194, 32, 95, 158, 121, 16, 96, 77, 222, 160, 97, 135, 149, 144, 98, 45, 192, 160, 99, 103, 119, 144, 100, 13, 162, 160, 101, 71, 89, 144, 101, 237, 132, 160, 103, 39, 59, 144, 103, 205, 102, 160, 105, 7, 29, 144, 105, 173, 72, 160, 106, 230, 255, 144, 107, 150, 101, 32, 108, 208, 28, 16, 109, 118, 71, 32, 110, 175, 254, 16, 111, 86, 41, 32, 112, 143, 224, 16, 113, 54, 11, 32, 114, 111, 194, 16, 115, 21, 237, 32, 116, 79, 164, 16, 116, 255, 9, 160, 118, 56, 192, 144, 118, 222, 235, 160, 120, 24, 162, 144, 120, 190, 205, 160, 121, 248, 132, 144, 122, 158, 175, 160, 123, 216, 102, 144, 124, 126, 145, 160, 125, 184, 72, 144, 126, 94, 115, 160, 127, 152, 42, 144, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 140, 148, 0, 0, 255, 255, 157, 144, 1, 4, 255, 255, 143, 128, 0, 8, 255, 255, 157, 144, 1, 12, 255, 255, 157, 144, 1, 16, 76, 77, 84, 0, 80, 68, 84, 0, 80, 83, 84, 0, 80, 87, 84, 0, 80, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 80, 83, 84, 56, 80, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/Canada/Saskatchewan": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 54, 0, 0, 0, 6, 0, 0, 0, 24, 128, 0, 0, 0, 134, 253, 147, 28, 158, 184, 175, 144, 159, 187, 7, 128, 181, 101, 79, 240, 182, 48, 72, 224, 183, 69, 49, 240, 184, 16, 42, 224, 185, 37, 19, 240, 185, 240, 12, 224, 187, 14, 48, 112, 187, 207, 238, 224, 188, 238, 18, 112, 189, 185, 11, 96, 194, 114, 8, 240, 195, 97, 235, 224, 196, 81, 234, 240, 197, 56, 147, 96, 198, 49, 204, 240, 199, 33, 175, 224, 200, 26, 233, 112, 201, 10, 204, 96, 201, 250, 203, 112, 202, 234, 174, 96, 203, 137, 12, 144, 210, 35, 244, 112, 210, 97, 24, 0, 211, 99, 140, 16, 212, 83, 111, 0, 213, 85, 227, 16, 214, 32, 220, 0, 215, 53, 197, 16, 216, 0, 190, 0, 217, 21, 167, 16, 217, 224, 160, 0, 218, 254, 195, 144, 219, 192, 130, 0, 220, 222, 165, 144, 221, 169, 158, 128, 222, 190, 135, 144, 223, 137, 128, 128, 224, 158, 105, 144, 225, 105, 98, 128, 226, 126, 75, 144, 227, 73, 68, 128, 228, 94, 45, 144, 229, 41, 38, 128, 230, 71, 74, 16, 231, 18, 67, 0, 232, 39, 44, 16, 232, 242, 37, 0, 235, 230, 240, 16, 236, 214, 211, 0, 237, 198, 210, 16, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 255, 255, 157, 228, 0, 0, 255, 255, 171, 160, 1, 4, 255, 255, 157, 144, 0, 8, 255, 255, 171, 160, 1, 12, 255, 255, 171, 160, 1, 16, 255, 255, 171, 160, 0, 20, 76, 77, 84, 0, 77, 68, 84, 0, 77, 83, 84, 0, 77, 87, 84, 0, 77, 80, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 10, 67, 83, 84, 54, 10}, - - "zoneinfo/Canada/Yukon": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 127, 0, 0, 0, 8, 0, 0, 0, 33, 128, 0, 0, 0, 158, 184, 203, 176, 159, 187, 35, 160, 160, 208, 12, 176, 161, 162, 210, 128, 203, 137, 40, 176, 210, 35, 244, 112, 210, 97, 52, 32, 247, 47, 118, 144, 248, 40, 162, 16, 251, 29, 95, 16, 19, 105, 114, 32, 20, 89, 85, 16, 21, 73, 84, 32, 22, 57, 55, 16, 23, 41, 54, 32, 24, 34, 83, 144, 25, 9, 24, 32, 26, 2, 53, 144, 26, 242, 52, 160, 27, 226, 23, 144, 28, 210, 22, 160, 29, 193, 249, 144, 30, 177, 248, 160, 31, 161, 219, 144, 32, 118, 43, 32, 33, 129, 189, 144, 34, 86, 13, 32, 35, 106, 218, 16, 36, 53, 239, 32, 37, 74, 188, 16, 38, 21, 209, 32, 39, 42, 158, 16, 39, 254, 237, 160, 41, 10, 128, 16, 41, 222, 207, 160, 42, 234, 98, 16, 43, 190, 177, 160, 44, 211, 126, 144, 45, 158, 147, 160, 46, 179, 96, 144, 47, 126, 117, 160, 48, 147, 66, 144, 49, 103, 146, 32, 50, 115, 36, 144, 51, 71, 116, 32, 52, 83, 6, 144, 53, 39, 86, 32, 54, 50, 232, 144, 55, 7, 56, 32, 56, 28, 5, 16, 56, 231, 26, 32, 57, 251, 231, 16, 58, 198, 252, 32, 59, 219, 201, 16, 60, 176, 24, 160, 61, 187, 171, 16, 62, 143, 250, 160, 63, 155, 141, 16, 64, 111, 220, 160, 65, 132, 169, 144, 66, 79, 190, 160, 67, 100, 139, 144, 68, 47, 160, 160, 69, 68, 109, 144, 69, 243, 211, 32, 71, 45, 138, 16, 71, 211, 181, 32, 73, 13, 108, 16, 73, 179, 151, 32, 74, 237, 78, 16, 75, 156, 179, 160, 76, 214, 106, 144, 77, 124, 149, 160, 78, 182, 76, 144, 79, 92, 119, 160, 80, 150, 46, 144, 81, 60, 89, 160, 82, 118, 16, 144, 83, 28, 59, 160, 84, 85, 242, 144, 84, 252, 29, 160, 86, 53, 212, 144, 86, 229, 58, 32, 88, 30, 241, 16, 88, 197, 28, 32, 89, 254, 211, 16, 90, 164, 254, 32, 91, 222, 181, 16, 92, 132, 224, 32, 93, 190, 151, 16, 94, 100, 194, 32, 95, 158, 121, 16, 96, 77, 222, 160, 97, 135, 149, 144, 98, 45, 192, 160, 99, 103, 119, 144, 100, 13, 162, 160, 101, 71, 89, 144, 101, 237, 132, 160, 103, 39, 59, 144, 103, 205, 102, 160, 105, 7, 29, 144, 105, 173, 72, 160, 106, 230, 255, 144, 107, 150, 101, 32, 108, 208, 28, 16, 109, 118, 71, 32, 110, 175, 254, 16, 111, 86, 41, 32, 112, 143, 224, 16, 113, 54, 11, 32, 114, 111, 194, 16, 115, 21, 237, 32, 116, 79, 164, 16, 116, 255, 9, 160, 118, 56, 192, 144, 118, 222, 235, 160, 120, 24, 162, 144, 120, 190, 205, 160, 121, 248, 132, 144, 122, 158, 175, 160, 123, 216, 102, 144, 124, 126, 145, 160, 125, 184, 72, 144, 126, 94, 115, 160, 127, 152, 42, 144, 2, 1, 2, 1, 2, 3, 4, 2, 5, 2, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 255, 255, 129, 100, 0, 0, 255, 255, 143, 128, 1, 4, 255, 255, 129, 112, 0, 8, 255, 255, 143, 128, 1, 12, 255, 255, 143, 128, 1, 16, 255, 255, 157, 144, 1, 20, 255, 255, 143, 128, 0, 25, 255, 255, 157, 144, 1, 29, 76, 77, 84, 0, 89, 68, 84, 0, 89, 83, 84, 0, 89, 87, 84, 0, 89, 80, 84, 0, 89, 68, 68, 84, 0, 80, 83, 84, 0, 80, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 10, 80, 83, 84, 56, 80, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/Chile/Continental": []byte{84, 90, 105, 102, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 160, 0, 0, 0, 8, 0, 0, 0, 20, 128, 0, 0, 0, 143, 48, 71, 70, 155, 92, 229, 80, 159, 124, 226, 198, 161, 0, 113, 192, 176, 94, 119, 198, 177, 119, 61, 64, 178, 65, 0, 208, 179, 88, 112, 192, 180, 34, 52, 80, 181, 57, 164, 64, 182, 3, 103, 208, 183, 26, 215, 192, 183, 228, 155, 80, 184, 253, 92, 192, 185, 199, 32, 80, 204, 28, 110, 64, 204, 108, 231, 208, 211, 220, 143, 192, 212, 27, 201, 176, 213, 51, 85, 192, 213, 118, 146, 64, 253, 209, 60, 64, 254, 146, 250, 176, 255, 204, 205, 192, 0, 114, 220, 176, 1, 117, 80, 192, 2, 64, 73, 176, 3, 85, 50, 192, 4, 32, 43, 176, 5, 62, 79, 64, 6, 0, 13, 176, 7, 11, 188, 64, 7, 223, 239, 176, 8, 254, 19, 64, 9, 191, 209, 176, 10, 221, 245, 64, 11, 168, 238, 48, 12, 189, 215, 64, 13, 136, 208, 48, 14, 157, 185, 64, 15, 104, 178, 48, 16, 134, 213, 192, 17, 72, 148, 48, 18, 102, 183, 192, 19, 40, 118, 48, 20, 70, 153, 192, 21, 17, 146, 176, 22, 38, 123, 192, 22, 241, 116, 176, 24, 6, 93, 192, 24, 209, 86, 176, 25, 230, 63, 192, 26, 177, 56, 176, 27, 207, 92, 64, 28, 145, 26, 176, 29, 175, 62, 64, 30, 112, 252, 176, 31, 143, 32, 64, 32, 127, 3, 48, 33, 111, 2, 64, 34, 57, 251, 48, 35, 78, 228, 64, 36, 25, 221, 48, 37, 56, 0, 192, 37, 249, 191, 48, 38, 242, 248, 192, 39, 217, 161, 48, 40, 247, 196, 192, 41, 194, 189, 176, 42, 215, 166, 192, 43, 162, 159, 176, 44, 183, 136, 192, 45, 130, 129, 176, 46, 151, 106, 192, 47, 98, 99, 176, 48, 128, 135, 64, 49, 66, 69, 176, 50, 96, 105, 64, 51, 61, 215, 48, 52, 64, 75, 64, 53, 11, 68, 48, 54, 13, 184, 64, 55, 6, 213, 176, 56, 0, 15, 64, 56, 203, 8, 48, 57, 233, 43, 192, 58, 170, 234, 48, 59, 201, 13, 192, 60, 138, 204, 48, 61, 168, 239, 192, 62, 106, 174, 48, 63, 136, 209, 192, 64, 83, 202, 176, 65, 104, 179, 192, 66, 51, 172, 176, 67, 72, 149, 192, 68, 19, 142, 176, 69, 49, 178, 64, 69, 243, 112, 176, 71, 17, 148, 64, 71, 239, 2, 48, 72, 241, 118, 64, 73, 188, 111, 48, 74, 209, 88, 64, 75, 184, 0, 176, 76, 177, 58, 64, 77, 198, 7, 48, 78, 80, 130, 192, 79, 156, 174, 176, 80, 66, 217, 192, 81, 124, 144, 176, 82, 43, 246, 64, 83, 92, 114, 176, 84, 11, 216, 64, 87, 55, 230, 48, 87, 175, 236, 192, 89, 23, 200, 48, 89, 143, 206, 192, 90, 247, 170, 48, 91, 111, 176, 192, 92, 215, 140, 48, 93, 79, 146, 192, 94, 183, 110, 48, 95, 47, 116, 192, 96, 151, 80, 48, 97, 24, 145, 64, 98, 128, 108, 176, 98, 248, 115, 64, 100, 96, 78, 176, 100, 216, 85, 64, 102, 64, 48, 176, 102, 184, 55, 64, 104, 32, 18, 176, 104, 152, 25, 64, 105, 255, 244, 176, 106, 119, 251, 64, 107, 223, 214, 176, 108, 97, 23, 192, 109, 200, 243, 48, 110, 64, 249, 192, 111, 168, 213, 48, 112, 32, 219, 192, 113, 136, 183, 48, 114, 0, 189, 192, 115, 104, 153, 48, 115, 224, 159, 192, 117, 72, 123, 48, 117, 201, 188, 64, 119, 49, 151, 176, 119, 169, 158, 64, 121, 17, 121, 176, 121, 137, 128, 64, 122, 241, 91, 176, 123, 105, 98, 64, 124, 209, 61, 176, 125, 73, 68, 64, 126, 177, 31, 176, 127, 41, 38, 64, 127, 255, 255, 255, 1, 2, 1, 3, 1, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 3, 2, 3, 5, 3, 2, 3, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 6, 255, 255, 189, 186, 0, 0, 255, 255, 189, 186, 0, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 0, 12, 255, 255, 199, 192, 1, 12, 255, 255, 213, 208, 1, 16, 255, 255, 213, 208, 1, 16, 255, 255, 199, 192, 0, 12, 76, 77, 84, 0, 83, 77, 84, 0, 45, 48, 53, 0, 45, 48, 52, 0, 45, 48, 51, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 10, 60, 45, 48, 52, 62, 52, 60, 45, 48, 51, 62, 44, 77, 56, 46, 50, 46, 54, 47, 50, 52, 44, 77, 53, 46, 50, 46, 54, 47, 50, 52, 10}, - - "zoneinfo/Chile/EasterIsland": []byte{84, 90, 105, 102, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 140, 0, 0, 0, 7, 0, 0, 0, 20, 128, 0, 0, 0, 185, 199, 64, 136, 253, 209, 60, 64, 254, 146, 250, 176, 255, 204, 205, 192, 0, 114, 220, 176, 1, 117, 80, 192, 2, 64, 73, 176, 3, 85, 50, 192, 4, 32, 43, 176, 5, 62, 79, 64, 6, 0, 13, 176, 7, 11, 188, 64, 7, 223, 239, 176, 8, 254, 19, 64, 9, 191, 209, 176, 10, 221, 245, 64, 11, 168, 238, 48, 12, 189, 215, 64, 13, 136, 208, 48, 14, 157, 185, 64, 15, 104, 178, 48, 16, 134, 213, 192, 17, 72, 148, 48, 18, 102, 183, 192, 19, 40, 118, 48, 20, 70, 153, 192, 21, 17, 146, 176, 22, 38, 123, 192, 22, 241, 116, 176, 24, 6, 93, 192, 24, 209, 86, 176, 25, 230, 63, 192, 26, 177, 56, 176, 27, 207, 92, 64, 28, 145, 26, 176, 29, 175, 62, 64, 30, 112, 252, 176, 31, 143, 32, 64, 32, 127, 3, 48, 33, 111, 2, 64, 34, 57, 251, 48, 35, 78, 228, 64, 36, 25, 221, 48, 37, 56, 0, 192, 37, 249, 191, 48, 38, 242, 248, 192, 39, 217, 161, 48, 40, 247, 196, 192, 41, 194, 189, 176, 42, 215, 166, 192, 43, 162, 159, 176, 44, 183, 136, 192, 45, 130, 129, 176, 46, 151, 106, 192, 47, 98, 99, 176, 48, 128, 135, 64, 49, 66, 69, 176, 50, 96, 105, 64, 51, 61, 215, 48, 52, 64, 75, 64, 53, 11, 68, 48, 54, 13, 184, 64, 55, 6, 213, 176, 56, 0, 15, 64, 56, 203, 8, 48, 57, 233, 43, 192, 58, 170, 234, 48, 59, 201, 13, 192, 60, 138, 204, 48, 61, 168, 239, 192, 62, 106, 174, 48, 63, 136, 209, 192, 64, 83, 202, 176, 65, 104, 179, 192, 66, 51, 172, 176, 67, 72, 149, 192, 68, 19, 142, 176, 69, 49, 178, 64, 69, 243, 112, 176, 71, 17, 148, 64, 71, 239, 2, 48, 72, 241, 118, 64, 73, 188, 111, 48, 74, 209, 88, 64, 75, 184, 0, 176, 76, 177, 58, 64, 77, 198, 7, 48, 78, 80, 130, 192, 79, 156, 174, 176, 80, 66, 217, 192, 81, 124, 144, 176, 82, 43, 246, 64, 83, 92, 114, 176, 84, 11, 216, 64, 87, 55, 230, 48, 87, 175, 236, 192, 89, 23, 200, 48, 89, 143, 206, 192, 90, 247, 170, 48, 91, 111, 176, 192, 92, 215, 140, 48, 93, 79, 146, 192, 94, 183, 110, 48, 95, 47, 116, 192, 96, 151, 80, 48, 97, 24, 145, 64, 98, 128, 108, 176, 98, 248, 115, 64, 100, 96, 78, 176, 100, 216, 85, 64, 102, 64, 48, 176, 102, 184, 55, 64, 104, 32, 18, 176, 104, 152, 25, 64, 105, 255, 244, 176, 106, 119, 251, 64, 107, 223, 214, 176, 108, 97, 23, 192, 109, 200, 243, 48, 110, 64, 249, 192, 111, 168, 213, 48, 112, 32, 219, 192, 113, 136, 183, 48, 114, 0, 189, 192, 115, 104, 153, 48, 115, 224, 159, 192, 117, 72, 123, 48, 117, 201, 188, 64, 119, 49, 151, 176, 119, 169, 158, 64, 121, 17, 121, 176, 121, 137, 128, 64, 122, 241, 91, 176, 123, 105, 98, 64, 124, 209, 61, 176, 125, 73, 68, 64, 126, 177, 31, 176, 127, 41, 38, 64, 127, 255, 255, 255, 1, 4, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 6, 255, 255, 153, 120, 0, 0, 255, 255, 153, 120, 0, 4, 255, 255, 171, 160, 1, 8, 255, 255, 157, 144, 0, 12, 255, 255, 157, 144, 0, 12, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 16, 76, 77, 84, 0, 69, 77, 84, 0, 45, 48, 54, 0, 45, 48, 55, 0, 45, 48, 53, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 10, 60, 45, 48, 54, 62, 54, 60, 45, 48, 53, 62, 44, 77, 56, 46, 50, 46, 54, 47, 50, 50, 44, 77, 53, 46, 50, 46, 54, 47, 50, 50, 10}, - - "zoneinfo/Cuba": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, 0, 6, 0, 0, 0, 16, 128, 0, 0, 0, 172, 98, 194, 128, 177, 211, 148, 80, 178, 116, 93, 64, 200, 91, 102, 208, 200, 211, 81, 64, 202, 59, 72, 208, 202, 188, 109, 192, 204, 36, 101, 80, 204, 156, 79, 192, 209, 196, 11, 80, 210, 59, 245, 192, 211, 163, 237, 80, 212, 27, 215, 192, 247, 96, 5, 208, 247, 255, 125, 64, 249, 61, 68, 208, 249, 227, 83, 192, 250, 219, 59, 208, 251, 167, 134, 64, 252, 197, 169, 208, 253, 135, 104, 64, 254, 184, 0, 208, 255, 167, 227, 192, 0, 151, 226, 208, 1, 135, 197, 192, 2, 119, 196, 208, 3, 112, 226, 64, 4, 96, 225, 80, 5, 53, 20, 192, 6, 64, 195, 80, 7, 22, 72, 64, 8, 32, 165, 80, 8, 247, 123, 192, 10, 0, 135, 80, 10, 240, 106, 64, 11, 224, 105, 80, 12, 217, 134, 192, 13, 192, 75, 80, 14, 185, 104, 192, 15, 178, 162, 80, 16, 125, 155, 64, 17, 81, 234, 208, 18, 102, 183, 192, 19, 49, 204, 208, 20, 70, 153, 192, 21, 91, 130, 208, 22, 38, 123, 192, 23, 59, 100, 208, 24, 6, 93, 192, 25, 27, 70, 208, 25, 230, 63, 192, 26, 251, 40, 208, 27, 207, 92, 64, 28, 219, 10, 208, 29, 175, 62, 64, 30, 122, 83, 80, 31, 143, 32, 64, 32, 90, 53, 80, 33, 111, 2, 64, 34, 67, 81, 208, 35, 78, 228, 64, 36, 35, 51, 208, 37, 46, 198, 64, 38, 21, 138, 208, 39, 23, 226, 192, 39, 254, 167, 80, 40, 247, 210, 208, 41, 222, 137, 80, 42, 215, 180, 208, 43, 190, 107, 80, 44, 183, 150, 208, 45, 158, 77, 80, 46, 151, 120, 208, 47, 126, 47, 80, 48, 119, 90, 208, 49, 103, 75, 208, 50, 87, 60, 208, 51, 71, 45, 208, 52, 64, 89, 80, 53, 29, 213, 80, 54, 50, 176, 80, 54, 253, 183, 80, 56, 27, 204, 208, 56, 230, 211, 208, 57, 251, 174, 208, 58, 198, 181, 208, 59, 219, 144, 208, 60, 175, 210, 80, 61, 187, 114, 208, 62, 143, 180, 80, 63, 155, 84, 208, 64, 102, 91, 208, 69, 68, 53, 80, 69, 243, 140, 208, 71, 36, 23, 80, 71, 220, 169, 80, 73, 3, 249, 80, 73, 179, 80, 208, 74, 227, 219, 80, 75, 156, 109, 80, 76, 204, 247, 208, 77, 133, 137, 208, 78, 191, 78, 208, 79, 119, 224, 208, 80, 149, 246, 80, 81, 60, 19, 80, 82, 117, 216, 80, 83, 27, 245, 80, 84, 85, 186, 80, 84, 251, 215, 80, 86, 53, 156, 80, 86, 228, 243, 208, 88, 30, 184, 208, 88, 196, 213, 208, 89, 254, 154, 208, 90, 164, 183, 208, 91, 222, 124, 208, 92, 132, 153, 208, 93, 190, 94, 208, 94, 100, 123, 208, 95, 158, 64, 208, 96, 77, 152, 80, 97, 135, 93, 80, 98, 45, 122, 80, 99, 103, 63, 80, 100, 13, 92, 80, 101, 71, 33, 80, 101, 237, 62, 80, 103, 39, 3, 80, 103, 205, 32, 80, 105, 6, 229, 80, 105, 173, 2, 80, 106, 230, 199, 80, 107, 150, 30, 208, 108, 207, 227, 208, 109, 118, 0, 208, 110, 175, 197, 208, 111, 85, 226, 208, 112, 143, 167, 208, 113, 53, 196, 208, 114, 111, 137, 208, 115, 21, 166, 208, 116, 79, 107, 208, 116, 254, 195, 80, 118, 56, 136, 80, 118, 222, 165, 80, 120, 24, 106, 80, 120, 190, 135, 80, 121, 248, 76, 80, 122, 158, 105, 80, 123, 216, 46, 80, 124, 126, 75, 80, 125, 184, 16, 80, 126, 94, 45, 80, 127, 151, 242, 80, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 255, 255, 178, 200, 0, 0, 255, 255, 178, 192, 0, 4, 255, 255, 199, 192, 1, 8, 255, 255, 185, 176, 0, 12, 255, 255, 185, 176, 0, 12, 255, 255, 199, 192, 1, 8, 76, 77, 84, 0, 72, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 53, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 47, 48, 44, 77, 49, 49, 46, 49, 46, 48, 47, 49, 10}, - - "zoneinfo/EET": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 122, 0, 0, 0, 2, 0, 0, 0, 9, 13, 164, 99, 144, 14, 139, 26, 16, 15, 132, 69, 144, 16, 116, 54, 144, 17, 100, 39, 144, 18, 84, 24, 144, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 42, 48, 1, 0, 0, 0, 28, 32, 0, 5, 69, 69, 83, 84, 0, 69, 69, 84, 0, 1, 1, 1, 1, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 51, 44, 77, 49, 48, 46, 53, 46, 48, 47, 52, 10}, - - "zoneinfo/EST": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 255, 255, 185, 176, 0, 0, 69, 83, 84, 0, 0, 0, 10, 69, 83, 84, 53, 10}, - - "zoneinfo/EST5EDT": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 149, 0, 0, 0, 4, 0, 0, 0, 16, 158, 166, 30, 112, 159, 186, 235, 96, 160, 134, 0, 112, 161, 154, 205, 96, 203, 136, 240, 112, 210, 35, 244, 112, 210, 96, 251, 224, 250, 248, 88, 240, 251, 232, 59, 224, 252, 216, 58, 240, 253, 200, 29, 224, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 2, 119, 224, 240, 3, 112, 254, 96, 4, 96, 253, 112, 5, 80, 224, 96, 6, 64, 223, 112, 7, 48, 194, 96, 7, 141, 25, 112, 9, 16, 164, 96, 9, 173, 148, 240, 10, 240, 134, 96, 11, 224, 133, 112, 12, 217, 162, 224, 13, 192, 103, 112, 14, 185, 132, 224, 15, 169, 131, 240, 16, 153, 102, 224, 17, 137, 101, 240, 18, 121, 72, 224, 19, 105, 71, 240, 20, 89, 42, 224, 21, 73, 41, 240, 22, 57, 12, 224, 23, 41, 11, 240, 24, 34, 41, 96, 25, 8, 237, 240, 26, 2, 11, 96, 26, 242, 10, 112, 27, 225, 237, 96, 28, 209, 236, 112, 29, 193, 207, 96, 30, 177, 206, 112, 31, 161, 177, 96, 32, 118, 0, 240, 33, 129, 147, 96, 34, 85, 226, 240, 35, 106, 175, 224, 36, 53, 196, 240, 37, 74, 145, 224, 38, 21, 166, 240, 39, 42, 115, 224, 39, 254, 195, 112, 41, 10, 85, 224, 41, 222, 165, 112, 42, 234, 55, 224, 43, 190, 135, 112, 44, 211, 84, 96, 45, 158, 105, 112, 46, 179, 54, 96, 47, 126, 75, 112, 48, 147, 24, 96, 49, 103, 103, 240, 50, 114, 250, 96, 51, 71, 73, 240, 52, 82, 220, 96, 53, 39, 43, 240, 54, 50, 190, 96, 55, 7, 13, 240, 56, 27, 218, 224, 56, 230, 239, 240, 57, 251, 188, 224, 58, 198, 209, 240, 59, 219, 158, 224, 60, 175, 238, 112, 61, 187, 128, 224, 62, 143, 208, 112, 63, 155, 98, 224, 64, 111, 178, 112, 65, 132, 127, 96, 66, 79, 148, 112, 67, 100, 97, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 0, 1, 0, 1, 2, 3, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 255, 255, 199, 192, 1, 0, 255, 255, 185, 176, 0, 4, 255, 255, 199, 192, 1, 8, 255, 255, 199, 192, 1, 12, 69, 68, 84, 0, 69, 83, 84, 0, 69, 87, 84, 0, 69, 80, 84, 0, 0, 0, 0, 1, 0, 0, 0, 1, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/Egypt": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 127, 0, 0, 0, 4, 0, 0, 0, 13, 128, 0, 0, 0, 200, 147, 180, 224, 200, 250, 123, 208, 201, 252, 239, 224, 202, 199, 232, 208, 203, 203, 174, 96, 204, 223, 41, 208, 205, 172, 225, 224, 206, 198, 244, 208, 207, 143, 102, 224, 208, 169, 121, 208, 209, 132, 96, 224, 210, 138, 173, 80, 232, 54, 99, 96, 232, 244, 45, 80, 234, 11, 185, 96, 234, 213, 96, 208, 235, 236, 250, 240, 236, 181, 109, 0, 237, 207, 127, 240, 238, 151, 242, 0, 239, 176, 179, 112, 240, 121, 37, 128, 241, 145, 230, 240, 242, 90, 89, 0, 243, 115, 26, 112, 244, 59, 140, 128, 245, 85, 159, 112, 246, 30, 17, 128, 247, 54, 210, 240, 247, 255, 69, 0, 249, 24, 6, 112, 249, 225, 202, 0, 250, 249, 57, 240, 251, 194, 253, 128, 252, 219, 190, 240, 253, 165, 130, 128, 254, 188, 242, 112, 255, 134, 182, 0, 0, 158, 37, 240, 1, 103, 233, 128, 2, 127, 89, 112, 3, 73, 29, 0, 4, 97, 222, 112, 5, 43, 162, 0, 6, 67, 17, 240, 7, 12, 213, 128, 8, 36, 69, 112, 8, 238, 9, 0, 10, 5, 120, 240, 10, 207, 60, 128, 11, 231, 253, 240, 12, 177, 193, 128, 13, 201, 49, 112, 14, 146, 245, 0, 15, 170, 100, 240, 16, 116, 40, 128, 17, 139, 152, 112, 18, 85, 92, 0, 19, 110, 29, 112, 20, 55, 225, 0, 21, 79, 80, 240, 22, 25, 20, 128, 23, 160, 147, 240, 23, 250, 72, 0, 25, 112, 163, 240, 25, 219, 123, 128, 26, 244, 60, 240, 27, 190, 0, 128, 28, 213, 112, 112, 29, 159, 52, 0, 30, 182, 163, 240, 31, 128, 103, 128, 32, 151, 215, 112, 33, 97, 155, 0, 34, 122, 92, 112, 35, 68, 32, 0, 36, 98, 39, 112, 37, 37, 83, 128, 38, 60, 195, 112, 39, 6, 135, 0, 40, 29, 246, 240, 40, 231, 186, 128, 42, 0, 123, 240, 42, 202, 63, 128, 43, 225, 175, 112, 44, 171, 115, 0, 45, 194, 226, 240, 46, 140, 166, 128, 47, 160, 19, 224, 48, 107, 12, 208, 49, 127, 245, 224, 50, 74, 238, 208, 51, 95, 215, 224, 52, 42, 208, 208, 53, 63, 185, 224, 54, 10, 178, 208, 55, 40, 214, 96, 55, 243, 207, 80, 57, 8, 184, 96, 57, 211, 177, 80, 58, 232, 154, 96, 59, 179, 147, 80, 60, 200, 124, 96, 61, 147, 117, 80, 62, 168, 94, 96, 63, 115, 87, 80, 64, 145, 122, 224, 65, 92, 115, 208, 66, 113, 92, 224, 67, 60, 85, 208, 68, 81, 62, 224, 69, 18, 253, 80, 70, 49, 32, 224, 70, 224, 106, 80, 72, 17, 2, 224, 72, 183, 17, 208, 73, 240, 228, 224, 74, 141, 185, 80, 75, 218, 1, 96, 76, 97, 189, 208, 76, 137, 88, 224, 76, 164, 250, 80, 83, 117, 56, 224, 83, 172, 137, 208, 83, 218, 188, 96, 84, 36, 130, 80, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 1, 2, 1, 2, 1, 2, 0, 0, 29, 85, 0, 0, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 9, 0, 0, 42, 48, 1, 4, 76, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 0, 0, 0, 1, 0, 0, 0, 0, 10, 69, 69, 84, 45, 50, 10}, - - "zoneinfo/Eire": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 230, 0, 0, 0, 10, 0, 0, 0, 20, 128, 0, 0, 0, 155, 38, 179, 145, 155, 214, 11, 17, 156, 207, 48, 160, 157, 164, 195, 160, 158, 156, 157, 160, 159, 151, 26, 160, 160, 133, 186, 32, 161, 118, 252, 160, 162, 101, 156, 32, 163, 123, 200, 160, 164, 78, 184, 160, 165, 63, 251, 32, 165, 148, 63, 0, 166, 37, 96, 32, 167, 39, 198, 32, 168, 42, 44, 32, 168, 235, 248, 160, 170, 0, 211, 160, 170, 213, 21, 32, 171, 233, 240, 32, 172, 199, 108, 32, 173, 201, 210, 32, 174, 167, 78, 32, 175, 160, 121, 160, 176, 135, 48, 32, 177, 146, 208, 160, 178, 112, 76, 160, 179, 114, 178, 160, 180, 80, 46, 160, 181, 73, 90, 32, 182, 48, 16, 160, 183, 50, 118, 160, 184, 15, 242, 160, 185, 18, 88, 160, 185, 239, 212, 160, 186, 233, 0, 32, 187, 216, 241, 32, 188, 219, 87, 32, 189, 184, 211, 32, 190, 177, 254, 160, 191, 152, 181, 32, 192, 155, 27, 32, 193, 120, 151, 32, 194, 122, 253, 32, 195, 88, 121, 32, 196, 81, 164, 160, 197, 56, 91, 32, 198, 58, 193, 32, 199, 88, 214, 160, 199, 218, 9, 160, 212, 73, 224, 32, 213, 30, 33, 160, 214, 78, 172, 32, 215, 44, 40, 32, 216, 46, 142, 32, 216, 249, 149, 32, 218, 14, 112, 32, 218, 235, 236, 32, 219, 229, 23, 160, 220, 203, 206, 32, 221, 196, 249, 160, 222, 180, 234, 160, 223, 174, 22, 32, 224, 148, 204, 160, 225, 114, 72, 160, 226, 107, 116, 32, 227, 82, 42, 160, 228, 84, 144, 160, 229, 50, 12, 160, 230, 61, 173, 32, 231, 27, 41, 32, 232, 20, 84, 160, 232, 251, 11, 32, 233, 253, 113, 32, 234, 218, 237, 32, 235, 221, 83, 32, 236, 186, 207, 32, 237, 179, 250, 160, 238, 154, 177, 32, 239, 129, 103, 160, 240, 159, 125, 32, 241, 97, 73, 160, 242, 127, 95, 32, 243, 74, 102, 32, 244, 95, 65, 32, 245, 33, 13, 160, 246, 63, 35, 32, 247, 0, 239, 160, 248, 31, 5, 32, 248, 224, 209, 160, 249, 254, 231, 32, 250, 192, 179, 160, 251, 232, 3, 160, 252, 123, 171, 160, 253, 199, 187, 112, 3, 112, 198, 32, 4, 41, 88, 32, 5, 80, 168, 32, 6, 9, 58, 32, 7, 48, 138, 32, 7, 233, 28, 32, 9, 16, 108, 32, 9, 200, 254, 32, 10, 240, 78, 32, 11, 178, 26, 160, 12, 208, 48, 32, 13, 145, 252, 160, 14, 176, 18, 32, 15, 113, 222, 160, 16, 153, 46, 160, 17, 81, 192, 160, 18, 121, 16, 160, 19, 49, 162, 160, 20, 88, 242, 160, 21, 35, 235, 144, 22, 56, 198, 144, 23, 3, 205, 144, 24, 24, 168, 144, 24, 227, 175, 144, 25, 248, 138, 144, 26, 195, 145, 144, 27, 225, 167, 16, 28, 172, 174, 16, 29, 193, 137, 16, 30, 140, 144, 16, 31, 161, 107, 16, 32, 108, 114, 16, 33, 129, 77, 16, 34, 76, 84, 16, 35, 97, 47, 16, 36, 44, 54, 16, 37, 74, 75, 144, 38, 12, 24, 16, 39, 42, 45, 144, 39, 245, 52, 144, 41, 10, 15, 144, 41, 213, 22, 144, 42, 233, 241, 144, 43, 180, 248, 144, 44, 201, 211, 144, 45, 148, 218, 144, 46, 169, 181, 144, 47, 116, 188, 144, 48, 137, 151, 144, 48, 231, 36, 0, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 2, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 6, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 7, 9, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 6, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 255, 255, 250, 36, 0, 0, 255, 255, 250, 15, 0, 4, 0, 0, 8, 31, 1, 8, 0, 0, 14, 16, 1, 12, 0, 0, 0, 0, 0, 16, 0, 0, 14, 16, 1, 8, 0, 0, 0, 0, 0, 16, 0, 0, 14, 16, 0, 8, 0, 0, 14, 16, 1, 8, 0, 0, 0, 0, 0, 16, 76, 77, 84, 0, 68, 77, 84, 0, 73, 83, 84, 0, 66, 83, 84, 0, 71, 77, 84, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 71, 77, 84, 48, 73, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 49, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/Etc/GMT": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 71, 77, 84, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Etc/GMT+0": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 71, 77, 84, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Etc/GMT+1": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 255, 255, 241, 240, 0, 0, 45, 48, 49, 0, 0, 0, 10, 60, 45, 48, 49, 62, 49, 10}, - - "zoneinfo/Etc/GMT+10": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 255, 255, 115, 96, 0, 0, 45, 49, 48, 0, 0, 0, 10, 60, 45, 49, 48, 62, 49, 48, 10}, - - "zoneinfo/Etc/GMT+11": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 255, 255, 101, 80, 0, 0, 45, 49, 49, 0, 0, 0, 10, 60, 45, 49, 49, 62, 49, 49, 10}, - - "zoneinfo/Etc/GMT+12": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 255, 255, 87, 64, 0, 0, 45, 49, 50, 0, 0, 0, 10, 60, 45, 49, 50, 62, 49, 50, 10}, - - "zoneinfo/Etc/GMT+2": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 255, 255, 227, 224, 0, 0, 45, 48, 50, 0, 0, 0, 10, 60, 45, 48, 50, 62, 50, 10}, - - "zoneinfo/Etc/GMT+3": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 255, 255, 213, 208, 0, 0, 45, 48, 51, 0, 0, 0, 10, 60, 45, 48, 51, 62, 51, 10}, - - "zoneinfo/Etc/GMT+4": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 255, 255, 199, 192, 0, 0, 45, 48, 52, 0, 0, 0, 10, 60, 45, 48, 52, 62, 52, 10}, - - "zoneinfo/Etc/GMT+5": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 255, 255, 185, 176, 0, 0, 45, 48, 53, 0, 0, 0, 10, 60, 45, 48, 53, 62, 53, 10}, - - "zoneinfo/Etc/GMT+6": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 255, 255, 171, 160, 0, 0, 45, 48, 54, 0, 0, 0, 10, 60, 45, 48, 54, 62, 54, 10}, - - "zoneinfo/Etc/GMT+7": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 255, 255, 157, 144, 0, 0, 45, 48, 55, 0, 0, 0, 10, 60, 45, 48, 55, 62, 55, 10}, - - "zoneinfo/Etc/GMT+8": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 255, 255, 143, 128, 0, 0, 45, 48, 56, 0, 0, 0, 10, 60, 45, 48, 56, 62, 56, 10}, - - "zoneinfo/Etc/GMT+9": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 255, 255, 129, 112, 0, 0, 45, 48, 57, 0, 0, 0, 10, 60, 45, 48, 57, 62, 57, 10}, - - "zoneinfo/Etc/GMT-0": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 71, 77, 84, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Etc/GMT-1": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 14, 16, 0, 0, 43, 48, 49, 0, 0, 0, 10, 60, 43, 48, 49, 62, 45, 49, 10}, - - "zoneinfo/Etc/GMT-10": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 140, 160, 0, 0, 43, 49, 48, 0, 0, 0, 10, 60, 43, 49, 48, 62, 45, 49, 48, 10}, - - "zoneinfo/Etc/GMT-11": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 154, 176, 0, 0, 43, 49, 49, 0, 0, 0, 10, 60, 43, 49, 49, 62, 45, 49, 49, 10}, - - "zoneinfo/Etc/GMT-12": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 168, 192, 0, 0, 43, 49, 50, 0, 0, 0, 10, 60, 43, 49, 50, 62, 45, 49, 50, 10}, - - "zoneinfo/Etc/GMT-13": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 182, 208, 0, 0, 43, 49, 51, 0, 0, 0, 10, 60, 43, 49, 51, 62, 45, 49, 51, 10}, - - "zoneinfo/Etc/GMT-14": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 196, 224, 0, 0, 43, 49, 52, 0, 0, 0, 10, 60, 43, 49, 52, 62, 45, 49, 52, 10}, - - "zoneinfo/Etc/GMT-2": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 28, 32, 0, 0, 43, 48, 50, 0, 0, 0, 10, 60, 43, 48, 50, 62, 45, 50, 10}, - - "zoneinfo/Etc/GMT-3": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 42, 48, 0, 0, 43, 48, 51, 0, 0, 0, 10, 60, 43, 48, 51, 62, 45, 51, 10}, - - "zoneinfo/Etc/GMT-4": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 56, 64, 0, 0, 43, 48, 52, 0, 0, 0, 10, 60, 43, 48, 52, 62, 45, 52, 10}, - - "zoneinfo/Etc/GMT-5": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 70, 80, 0, 0, 43, 48, 53, 0, 0, 0, 10, 60, 43, 48, 53, 62, 45, 53, 10}, - - "zoneinfo/Etc/GMT-6": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 84, 96, 0, 0, 43, 48, 54, 0, 0, 0, 10, 60, 43, 48, 54, 62, 45, 54, 10}, - - "zoneinfo/Etc/GMT-7": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 98, 112, 0, 0, 43, 48, 55, 0, 0, 0, 10, 60, 43, 48, 55, 62, 45, 55, 10}, - - "zoneinfo/Etc/GMT-8": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 112, 128, 0, 0, 43, 48, 56, 0, 0, 0, 10, 60, 43, 48, 56, 62, 45, 56, 10}, - - "zoneinfo/Etc/GMT-9": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 126, 144, 0, 0, 43, 48, 57, 0, 0, 0, 10, 60, 43, 48, 57, 62, 45, 57, 10}, - - "zoneinfo/Etc/GMT0": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 71, 77, 84, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Etc/Greenwich": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 71, 77, 84, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Etc/UCT": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 85, 67, 84, 0, 0, 0, 10, 85, 67, 84, 48, 10}, - - "zoneinfo/Etc/UTC": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 85, 84, 67, 0, 0, 0, 10, 85, 84, 67, 48, 10}, - - "zoneinfo/Etc/Universal": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 85, 84, 67, 0, 0, 0, 10, 85, 84, 67, 48, 10}, - - "zoneinfo/Etc/Zulu": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 85, 84, 67, 0, 0, 0, 10, 85, 84, 67, 48, 10}, - - "zoneinfo/Europe/Amsterdam": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 181, 0, 0, 0, 14, 0, 0, 0, 33, 128, 0, 0, 0, 155, 12, 46, 236, 155, 213, 214, 92, 156, 217, 184, 12, 157, 164, 191, 12, 158, 167, 37, 12, 159, 151, 22, 12, 160, 144, 65, 140, 161, 118, 248, 12, 162, 112, 35, 140, 163, 86, 218, 12, 164, 80, 5, 140, 165, 54, 188, 12, 166, 37, 91, 140, 167, 39, 193, 140, 168, 94, 227, 140, 169, 7, 163, 140, 169, 238, 90, 12, 170, 231, 133, 140, 172, 39, 226, 12, 172, 199, 103, 140, 173, 237, 102, 12, 174, 167, 73, 140, 175, 206, 153, 140, 176, 135, 43, 140, 177, 177, 30, 140, 178, 112, 72, 12, 179, 146, 82, 12, 180, 80, 42, 12, 181, 115, 133, 140, 182, 48, 12, 12, 183, 84, 185, 12, 184, 15, 238, 12, 185, 64, 120, 140, 185, 239, 208, 12, 187, 24, 113, 140, 187, 216, 236, 140, 188, 249, 165, 12, 189, 184, 206, 140, 190, 218, 216, 140, 191, 152, 176, 140, 192, 189, 93, 140, 193, 120, 146, 140, 194, 167, 203, 140, 194, 220, 93, 92, 195, 88, 116, 112, 196, 127, 196, 112, 197, 56, 86, 112, 198, 96, 247, 240, 199, 33, 114, 240, 200, 68, 178, 80, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 209, 114, 22, 16, 210, 78, 64, 144, 13, 42, 253, 112, 13, 164, 99, 144, 14, 139, 26, 16, 15, 132, 69, 144, 16, 116, 54, 144, 17, 100, 39, 144, 18, 84, 24, 144, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 7, 5, 6, 5, 6, 5, 10, 8, 9, 8, 9, 8, 9, 8, 13, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 0, 0, 4, 148, 0, 0, 0, 0, 18, 164, 1, 4, 0, 0, 4, 148, 0, 8, 0, 0, 18, 164, 1, 4, 0, 0, 4, 148, 0, 8, 0, 0, 4, 176, 0, 12, 0, 0, 18, 192, 1, 18, 0, 0, 18, 192, 1, 18, 0, 0, 14, 16, 0, 24, 0, 0, 28, 32, 1, 28, 0, 0, 28, 32, 1, 28, 0, 0, 28, 32, 1, 28, 0, 0, 14, 16, 0, 24, 0, 0, 14, 16, 0, 24, 76, 77, 84, 0, 78, 83, 84, 0, 65, 77, 84, 0, 43, 48, 48, 50, 48, 0, 43, 48, 49, 50, 48, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Andorra": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 108, 0, 0, 0, 5, 0, 0, 0, 17, 128, 0, 0, 0, 212, 65, 219, 0, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 0, 0, 1, 108, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 14, 16, 0, 8, 0, 0, 28, 32, 1, 12, 0, 0, 14, 16, 0, 8, 76, 77, 84, 0, 87, 69, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Astrakhan": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 66, 0, 0, 0, 9, 0, 0, 0, 16, 128, 0, 0, 0, 170, 24, 69, 116, 181, 164, 11, 80, 21, 39, 153, 192, 22, 24, 206, 48, 23, 8, 205, 64, 23, 250, 1, 176, 24, 234, 0, 192, 25, 219, 53, 48, 26, 204, 133, 192, 27, 188, 146, 224, 28, 172, 131, 224, 29, 156, 116, 224, 30, 140, 101, 224, 31, 124, 86, 224, 32, 108, 71, 224, 33, 92, 56, 224, 34, 76, 41, 224, 35, 60, 26, 224, 36, 44, 11, 224, 37, 28, 10, 240, 38, 11, 251, 240, 39, 5, 39, 112, 39, 245, 24, 112, 41, 212, 236, 96, 42, 196, 235, 112, 43, 180, 220, 112, 44, 164, 205, 112, 45, 148, 190, 112, 46, 132, 175, 112, 47, 116, 160, 112, 48, 100, 145, 112, 49, 93, 188, 240, 50, 114, 151, 240, 51, 61, 158, 240, 52, 82, 121, 240, 53, 29, 128, 240, 54, 50, 91, 240, 54, 253, 98, 240, 56, 27, 120, 112, 56, 221, 68, 240, 57, 251, 90, 112, 58, 189, 38, 240, 59, 219, 60, 112, 60, 166, 67, 112, 61, 187, 30, 112, 62, 134, 37, 112, 63, 155, 0, 112, 64, 102, 7, 112, 65, 132, 28, 240, 66, 69, 233, 112, 67, 99, 254, 240, 68, 37, 203, 112, 69, 67, 224, 240, 70, 5, 173, 112, 71, 35, 194, 240, 71, 238, 201, 240, 73, 3, 164, 240, 73, 206, 171, 240, 74, 227, 134, 240, 75, 174, 141, 240, 76, 204, 163, 112, 77, 142, 111, 240, 84, 76, 29, 96, 86, 247, 20, 112, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 6, 7, 4, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 4, 7, 4, 4, 0, 0, 45, 12, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 0, 12, 0, 0, 56, 64, 0, 12, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 1, 12, 0, 0, 42, 48, 0, 4, 0, 0, 56, 64, 0, 12, 76, 77, 84, 0, 43, 48, 51, 0, 43, 48, 53, 0, 43, 48, 52, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 52, 62, 45, 52, 10}, - - "zoneinfo/Europe/Athens": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 138, 0, 0, 0, 10, 0, 0, 0, 26, 128, 0, 0, 0, 155, 128, 33, 128, 185, 124, 233, 224, 185, 198, 175, 208, 201, 242, 99, 224, 202, 16, 168, 80, 204, 231, 75, 16, 205, 170, 76, 240, 206, 162, 24, 224, 207, 147, 105, 112, 223, 19, 158, 96, 223, 183, 10, 80, 9, 236, 94, 96, 11, 24, 244, 96, 11, 205, 174, 0, 12, 189, 159, 0, 13, 164, 85, 128, 14, 140, 93, 128, 15, 132, 55, 128, 16, 106, 252, 16, 17, 100, 123, 240, 18, 82, 170, 240, 19, 70, 130, 96, 20, 51, 194, 80, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 3, 2, 3, 2, 5, 4, 5, 4, 3, 2, 3, 6, 7, 6, 7, 6, 7, 6, 3, 2, 3, 2, 3, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 0, 0, 22, 60, 0, 0, 0, 0, 22, 60, 0, 4, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 0, 0, 14, 16, 0, 17, 0, 0, 28, 32, 1, 21, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 76, 77, 84, 0, 65, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 51, 44, 77, 49, 48, 46, 53, 46, 48, 47, 52, 10}, - - "zoneinfo/Europe/Belfast": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 243, 0, 0, 0, 8, 0, 0, 0, 17, 128, 0, 0, 0, 155, 38, 173, 160, 155, 214, 5, 32, 156, 207, 48, 160, 157, 164, 195, 160, 158, 156, 157, 160, 159, 151, 26, 160, 160, 133, 186, 32, 161, 118, 252, 160, 162, 101, 156, 32, 163, 123, 200, 160, 164, 78, 184, 160, 165, 63, 251, 32, 166, 37, 96, 32, 167, 39, 198, 32, 168, 42, 44, 32, 168, 235, 248, 160, 170, 0, 211, 160, 170, 213, 21, 32, 171, 233, 240, 32, 172, 199, 108, 32, 173, 201, 210, 32, 174, 167, 78, 32, 175, 160, 121, 160, 176, 135, 48, 32, 177, 146, 208, 160, 178, 112, 76, 160, 179, 114, 178, 160, 180, 80, 46, 160, 181, 73, 90, 32, 182, 48, 16, 160, 183, 50, 118, 160, 184, 15, 242, 160, 185, 18, 88, 160, 185, 239, 212, 160, 186, 233, 0, 32, 187, 216, 241, 32, 188, 219, 87, 32, 189, 184, 211, 32, 190, 177, 254, 160, 191, 152, 181, 32, 192, 155, 27, 32, 193, 120, 151, 32, 194, 122, 253, 32, 195, 88, 121, 32, 196, 81, 164, 160, 197, 56, 91, 32, 198, 58, 193, 32, 199, 88, 214, 160, 199, 218, 9, 160, 202, 22, 38, 144, 202, 151, 89, 144, 203, 209, 30, 144, 204, 119, 59, 144, 205, 177, 0, 144, 206, 96, 88, 16, 207, 144, 226, 144, 208, 110, 94, 144, 209, 114, 22, 16, 209, 251, 50, 16, 210, 105, 254, 32, 211, 99, 41, 160, 212, 73, 224, 32, 213, 30, 33, 160, 213, 66, 253, 144, 213, 223, 224, 16, 214, 78, 172, 32, 214, 254, 3, 160, 216, 46, 142, 32, 216, 249, 149, 32, 218, 14, 112, 32, 218, 235, 236, 32, 219, 229, 23, 160, 220, 203, 206, 32, 221, 196, 249, 160, 222, 180, 234, 160, 223, 174, 22, 32, 224, 148, 204, 160, 225, 114, 72, 160, 226, 107, 116, 32, 227, 82, 42, 160, 228, 84, 144, 160, 229, 50, 12, 160, 230, 61, 173, 32, 231, 27, 41, 32, 232, 20, 84, 160, 232, 251, 11, 32, 233, 253, 113, 32, 234, 218, 237, 32, 235, 221, 83, 32, 236, 186, 207, 32, 237, 179, 250, 160, 238, 154, 177, 32, 239, 129, 103, 160, 240, 159, 125, 32, 241, 97, 73, 160, 242, 127, 95, 32, 243, 74, 102, 32, 244, 95, 65, 32, 245, 33, 13, 160, 246, 63, 35, 32, 247, 0, 239, 160, 248, 31, 5, 32, 248, 224, 209, 160, 249, 254, 231, 32, 250, 192, 179, 160, 251, 232, 3, 160, 252, 123, 171, 160, 253, 199, 187, 112, 3, 112, 198, 32, 4, 41, 88, 32, 5, 80, 168, 32, 6, 9, 58, 32, 7, 48, 138, 32, 7, 233, 28, 32, 9, 16, 108, 32, 9, 200, 254, 32, 10, 240, 78, 32, 11, 178, 26, 160, 12, 208, 48, 32, 13, 145, 252, 160, 14, 176, 18, 32, 15, 113, 222, 160, 16, 153, 46, 160, 17, 81, 192, 160, 18, 121, 16, 160, 19, 49, 162, 160, 20, 88, 242, 160, 21, 35, 235, 144, 22, 56, 198, 144, 23, 3, 205, 144, 24, 24, 168, 144, 24, 227, 175, 144, 25, 248, 138, 144, 26, 195, 145, 144, 27, 225, 167, 16, 28, 172, 174, 16, 29, 193, 137, 16, 30, 140, 144, 16, 31, 161, 107, 16, 32, 108, 114, 16, 33, 129, 77, 16, 34, 76, 84, 16, 35, 97, 47, 16, 36, 44, 54, 16, 37, 74, 75, 144, 38, 12, 24, 16, 39, 42, 45, 144, 39, 245, 52, 144, 41, 10, 15, 144, 41, 213, 22, 144, 42, 233, 241, 144, 43, 180, 248, 144, 44, 201, 211, 144, 45, 148, 218, 144, 46, 169, 181, 144, 47, 116, 188, 144, 48, 137, 151, 144, 48, 231, 36, 0, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1, 3, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 4, 6, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 7, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 255, 255, 255, 181, 0, 0, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 8, 0, 0, 28, 32, 1, 12, 0, 0, 14, 16, 0, 4, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 8, 76, 77, 84, 0, 66, 83, 84, 0, 71, 77, 84, 0, 66, 68, 83, 84, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 10, 71, 77, 84, 48, 66, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 49, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/Europe/Belgrade": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 121, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 202, 2, 53, 224, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 208, 250, 1, 112, 209, 161, 140, 16, 210, 78, 64, 144, 24, 69, 95, 112, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 4, 2, 3, 2, 3, 2, 1, 3, 2, 1, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 19, 56, 0, 0, 0, 0, 14, 16, 0, 4, 0, 0, 14, 16, 0, 4, 0, 0, 28, 32, 1, 8, 0, 0, 28, 32, 1, 8, 0, 0, 28, 32, 1, 8, 0, 0, 14, 16, 0, 4, 76, 77, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Berlin": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 145, 0, 0, 0, 9, 0, 0, 0, 18, 128, 0, 0, 0, 155, 12, 23, 96, 155, 213, 218, 240, 156, 217, 174, 144, 157, 164, 181, 144, 158, 185, 144, 144, 159, 132, 151, 144, 200, 9, 113, 144, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 209, 114, 22, 16, 209, 182, 150, 0, 210, 88, 190, 128, 210, 161, 79, 16, 210, 219, 52, 240, 211, 99, 27, 144, 212, 75, 35, 144, 213, 57, 209, 32, 213, 103, 231, 144, 213, 168, 115, 0, 214, 41, 180, 16, 215, 44, 26, 16, 216, 9, 150, 16, 217, 2, 193, 144, 217, 233, 120, 16, 18, 206, 151, 240, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 5, 1, 4, 2, 3, 4, 3, 6, 1, 4, 3, 4, 3, 4, 2, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 0, 0, 12, 136, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 42, 48, 1, 13, 0, 0, 42, 48, 1, 13, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 76, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 67, 69, 77, 84, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Bratislava": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 155, 12, 23, 96, 155, 213, 218, 240, 156, 217, 174, 144, 157, 164, 181, 144, 158, 185, 144, 144, 159, 132, 151, 144, 200, 9, 113, 144, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 110, 94, 144, 209, 121, 255, 16, 210, 161, 79, 16, 211, 128, 28, 144, 212, 73, 210, 16, 213, 76, 56, 16, 214, 41, 180, 16, 215, 44, 26, 16, 216, 9, 150, 16, 217, 1, 112, 16, 217, 233, 120, 16, 16, 237, 100, 112, 17, 100, 39, 144, 18, 84, 24, 144, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 13, 136, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 80, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Brussels": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 186, 0, 0, 0, 11, 0, 0, 0, 22, 128, 0, 0, 0, 152, 68, 73, 128, 155, 12, 37, 112, 155, 213, 218, 240, 156, 217, 174, 144, 157, 164, 181, 144, 158, 185, 144, 144, 159, 132, 151, 144, 159, 206, 248, 48, 160, 96, 165, 240, 161, 126, 187, 112, 162, 46, 18, 240, 163, 122, 76, 240, 164, 53, 129, 240, 165, 94, 35, 112, 166, 37, 53, 240, 167, 39, 155, 240, 168, 42, 1, 240, 169, 7, 125, 240, 169, 238, 52, 112, 170, 231, 95, 240, 171, 215, 80, 240, 172, 199, 65, 240, 173, 201, 167, 240, 174, 167, 35, 240, 175, 160, 79, 112, 176, 135, 5, 240, 177, 137, 107, 240, 178, 112, 76, 160, 179, 114, 178, 160, 180, 80, 46, 160, 181, 73, 90, 32, 182, 48, 16, 160, 183, 50, 118, 160, 184, 15, 242, 160, 184, 255, 227, 160, 185, 239, 212, 160, 186, 214, 139, 32, 187, 216, 241, 32, 188, 200, 226, 32, 189, 184, 211, 32, 190, 159, 137, 160, 191, 152, 181, 32, 192, 155, 27, 32, 193, 120, 151, 32, 194, 104, 136, 32, 195, 88, 121, 32, 196, 63, 47, 160, 197, 56, 91, 32, 198, 58, 193, 32, 199, 88, 214, 160, 199, 218, 9, 160, 200, 74, 25, 32, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 91, 191, 96, 208, 110, 94, 144, 209, 114, 22, 16, 210, 78, 64, 144, 211, 145, 64, 16, 212, 75, 35, 144, 13, 42, 253, 112, 13, 164, 99, 144, 14, 139, 26, 16, 15, 132, 69, 144, 16, 116, 54, 144, 17, 100, 39, 144, 18, 84, 24, 144, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 2, 5, 2, 3, 4, 3, 4, 8, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 3, 4, 3, 4, 3, 5, 4, 3, 4, 3, 4, 2, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 0, 0, 4, 26, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 14, 16, 0, 8, 0, 0, 28, 32, 1, 12, 0, 0, 14, 16, 0, 8, 0, 0, 28, 32, 1, 12, 0, 0, 14, 16, 1, 17, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 4, 0, 0, 28, 32, 1, 12, 0, 0, 14, 16, 0, 8, 66, 77, 84, 0, 87, 69, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 87, 69, 83, 84, 0, 0, 0, 0, 1, 1, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Bucharest": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 138, 0, 0, 0, 8, 0, 0, 0, 17, 128, 0, 0, 0, 183, 176, 210, 8, 185, 62, 243, 96, 185, 239, 156, 96, 186, 223, 141, 96, 187, 207, 126, 96, 188, 200, 169, 224, 189, 184, 154, 224, 190, 168, 139, 224, 191, 152, 124, 224, 192, 136, 109, 224, 193, 120, 94, 224, 194, 104, 79, 224, 195, 88, 64, 224, 196, 72, 49, 224, 197, 56, 34, 224, 198, 40, 19, 224, 199, 24, 4, 224, 17, 173, 209, 96, 18, 83, 224, 80, 19, 77, 11, 208, 20, 51, 208, 96, 21, 35, 221, 128, 22, 19, 206, 128, 23, 3, 191, 128, 23, 243, 176, 128, 24, 227, 161, 128, 25, 211, 146, 128, 26, 195, 131, 128, 27, 188, 175, 0, 28, 172, 160, 0, 29, 156, 145, 0, 30, 140, 130, 0, 31, 124, 115, 0, 32, 108, 100, 0, 33, 92, 85, 0, 34, 76, 70, 0, 35, 60, 55, 0, 36, 44, 40, 0, 37, 28, 25, 0, 38, 12, 10, 0, 39, 5, 53, 128, 39, 127, 180, 224, 39, 245, 10, 96, 40, 228, 251, 96, 41, 212, 236, 96, 42, 196, 221, 96, 43, 180, 206, 96, 44, 164, 191, 96, 45, 36, 160, 224, 45, 148, 176, 96, 46, 132, 147, 80, 47, 116, 146, 96, 48, 100, 117, 80, 49, 93, 174, 224, 50, 114, 123, 208, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 5, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 4, 5, 4, 5, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 5, 2, 3, 2, 3, 2, 3, 5, 4, 5, 4, 5, 4, 5, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 0, 0, 24, 120, 0, 0, 0, 0, 24, 120, 0, 4, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 76, 77, 84, 0, 66, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 51, 44, 77, 49, 48, 46, 53, 46, 48, 47, 52, 10}, - - "zoneinfo/Europe/Budapest": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 153, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 155, 12, 23, 96, 155, 213, 218, 240, 156, 217, 174, 144, 157, 164, 181, 144, 158, 48, 88, 112, 158, 167, 41, 160, 159, 132, 151, 144, 160, 154, 210, 32, 161, 192, 194, 144, 201, 243, 195, 112, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 208, 250, 1, 112, 209, 153, 120, 224, 210, 138, 187, 96, 211, 80, 166, 144, 212, 73, 210, 16, 213, 57, 195, 16, 214, 41, 180, 16, 215, 25, 165, 16, 216, 9, 150, 16, 217, 2, 193, 144, 217, 233, 120, 16, 218, 237, 47, 144, 219, 230, 91, 16, 226, 162, 168, 240, 227, 81, 242, 96, 228, 131, 220, 112, 229, 51, 37, 224, 230, 116, 225, 240, 231, 17, 182, 96, 232, 84, 210, 0, 232, 241, 194, 144, 19, 77, 54, 0, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 4, 3, 4, 3, 4, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 1, 2, 1, 2, 1, 2, 1, 2, 1, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 0, 0, 17, 228, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 76, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Busingen": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 119, 0, 0, 0, 5, 0, 0, 0, 13, 128, 0, 0, 0, 202, 23, 106, 0, 202, 226, 113, 0, 203, 247, 76, 0, 204, 194, 83, 0, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 0, 0, 6, 250, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 66, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Chisinau": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 16, 0, 0, 0, 38, 128, 0, 0, 0, 158, 107, 159, 12, 183, 176, 210, 8, 185, 62, 243, 96, 185, 239, 156, 96, 186, 223, 141, 96, 187, 207, 126, 96, 188, 200, 169, 224, 189, 184, 154, 224, 190, 168, 139, 224, 191, 152, 124, 224, 192, 136, 109, 224, 193, 120, 94, 224, 194, 104, 79, 224, 195, 88, 64, 224, 196, 72, 49, 224, 197, 56, 34, 224, 198, 40, 19, 224, 199, 24, 4, 224, 200, 188, 147, 96, 202, 119, 125, 80, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 78, 144, 96, 21, 39, 167, 208, 22, 24, 220, 64, 23, 8, 219, 80, 23, 250, 15, 192, 24, 234, 14, 208, 25, 219, 67, 64, 26, 204, 147, 208, 27, 188, 160, 240, 28, 172, 145, 240, 29, 156, 130, 240, 30, 140, 115, 240, 31, 124, 100, 240, 32, 108, 85, 240, 33, 92, 70, 240, 34, 76, 55, 240, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 10, 240, 38, 11, 251, 240, 38, 67, 76, 224, 39, 5, 53, 128, 39, 245, 38, 128, 40, 229, 23, 128, 41, 96, 232, 96, 41, 212, 236, 96, 42, 196, 207, 80, 43, 180, 206, 96, 44, 164, 177, 80, 45, 148, 176, 96, 46, 132, 147, 80, 47, 116, 146, 96, 48, 100, 117, 80, 49, 93, 174, 224, 50, 114, 123, 208, 51, 61, 173, 0, 52, 82, 136, 0, 53, 29, 143, 0, 54, 50, 106, 0, 54, 253, 113, 0, 56, 27, 134, 128, 56, 221, 83, 0, 57, 251, 104, 128, 58, 189, 53, 0, 59, 219, 74, 128, 60, 166, 81, 128, 61, 187, 44, 128, 62, 134, 51, 128, 63, 155, 14, 128, 64, 102, 21, 128, 65, 132, 43, 0, 66, 69, 247, 128, 67, 100, 13, 0, 68, 37, 217, 128, 69, 67, 239, 0, 70, 5, 187, 128, 71, 35, 209, 0, 71, 238, 216, 0, 73, 3, 179, 0, 73, 206, 186, 0, 74, 227, 149, 0, 75, 174, 156, 0, 76, 204, 177, 128, 77, 142, 126, 0, 78, 172, 147, 128, 79, 110, 96, 0, 80, 140, 117, 128, 81, 87, 124, 128, 82, 108, 87, 128, 83, 55, 94, 128, 84, 76, 57, 128, 85, 23, 64, 128, 86, 44, 27, 128, 86, 247, 34, 128, 88, 21, 56, 0, 88, 215, 4, 128, 89, 245, 26, 0, 90, 182, 230, 128, 91, 212, 252, 0, 92, 160, 3, 0, 93, 180, 222, 0, 94, 127, 229, 0, 95, 148, 192, 0, 96, 95, 199, 0, 97, 125, 220, 128, 98, 63, 169, 0, 99, 93, 190, 128, 100, 31, 139, 0, 101, 61, 160, 128, 102, 8, 167, 128, 103, 29, 130, 128, 103, 232, 137, 128, 104, 253, 100, 128, 105, 200, 107, 128, 106, 221, 70, 128, 107, 168, 77, 128, 108, 198, 99, 0, 109, 136, 47, 128, 110, 166, 69, 0, 111, 104, 17, 128, 112, 134, 39, 0, 113, 81, 46, 0, 114, 102, 9, 0, 115, 49, 16, 0, 116, 69, 235, 0, 117, 16, 242, 0, 118, 47, 7, 128, 118, 240, 212, 0, 120, 14, 233, 128, 120, 208, 182, 0, 121, 238, 203, 128, 122, 176, 152, 0, 123, 206, 173, 128, 124, 153, 180, 128, 125, 174, 143, 128, 126, 121, 150, 128, 127, 142, 113, 128, 1, 2, 5, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 6, 9, 7, 8, 7, 8, 11, 10, 11, 10, 11, 10, 11, 10, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 6, 4, 3, 4, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 0, 0, 27, 8, 0, 0, 0, 0, 26, 244, 0, 4, 0, 0, 24, 120, 0, 8, 0, 0, 42, 48, 1, 12, 0, 0, 28, 32, 0, 17, 0, 0, 28, 32, 0, 17, 0, 0, 42, 48, 1, 12, 0, 0, 14, 16, 0, 21, 0, 0, 28, 32, 1, 25, 0, 0, 28, 32, 1, 25, 0, 0, 56, 64, 1, 30, 0, 0, 42, 48, 0, 34, 0, 0, 42, 48, 0, 34, 0, 0, 56, 64, 1, 30, 0, 0, 42, 48, 1, 12, 0, 0, 28, 32, 0, 17, 76, 77, 84, 0, 67, 77, 84, 0, 66, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 77, 83, 68, 0, 77, 83, 75, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Copenhagen": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 134, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 155, 30, 140, 96, 155, 213, 190, 208, 200, 67, 87, 112, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 209, 114, 22, 16, 210, 36, 16, 144, 211, 121, 133, 16, 212, 27, 173, 144, 213, 94, 173, 16, 213, 223, 224, 16, 215, 71, 201, 144, 215, 191, 194, 16, 18, 206, 151, 240, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 11, 204, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 67, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Dublin": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 230, 0, 0, 0, 10, 0, 0, 0, 20, 128, 0, 0, 0, 155, 38, 179, 145, 155, 214, 11, 17, 156, 207, 48, 160, 157, 164, 195, 160, 158, 156, 157, 160, 159, 151, 26, 160, 160, 133, 186, 32, 161, 118, 252, 160, 162, 101, 156, 32, 163, 123, 200, 160, 164, 78, 184, 160, 165, 63, 251, 32, 165, 148, 63, 0, 166, 37, 96, 32, 167, 39, 198, 32, 168, 42, 44, 32, 168, 235, 248, 160, 170, 0, 211, 160, 170, 213, 21, 32, 171, 233, 240, 32, 172, 199, 108, 32, 173, 201, 210, 32, 174, 167, 78, 32, 175, 160, 121, 160, 176, 135, 48, 32, 177, 146, 208, 160, 178, 112, 76, 160, 179, 114, 178, 160, 180, 80, 46, 160, 181, 73, 90, 32, 182, 48, 16, 160, 183, 50, 118, 160, 184, 15, 242, 160, 185, 18, 88, 160, 185, 239, 212, 160, 186, 233, 0, 32, 187, 216, 241, 32, 188, 219, 87, 32, 189, 184, 211, 32, 190, 177, 254, 160, 191, 152, 181, 32, 192, 155, 27, 32, 193, 120, 151, 32, 194, 122, 253, 32, 195, 88, 121, 32, 196, 81, 164, 160, 197, 56, 91, 32, 198, 58, 193, 32, 199, 88, 214, 160, 199, 218, 9, 160, 212, 73, 224, 32, 213, 30, 33, 160, 214, 78, 172, 32, 215, 44, 40, 32, 216, 46, 142, 32, 216, 249, 149, 32, 218, 14, 112, 32, 218, 235, 236, 32, 219, 229, 23, 160, 220, 203, 206, 32, 221, 196, 249, 160, 222, 180, 234, 160, 223, 174, 22, 32, 224, 148, 204, 160, 225, 114, 72, 160, 226, 107, 116, 32, 227, 82, 42, 160, 228, 84, 144, 160, 229, 50, 12, 160, 230, 61, 173, 32, 231, 27, 41, 32, 232, 20, 84, 160, 232, 251, 11, 32, 233, 253, 113, 32, 234, 218, 237, 32, 235, 221, 83, 32, 236, 186, 207, 32, 237, 179, 250, 160, 238, 154, 177, 32, 239, 129, 103, 160, 240, 159, 125, 32, 241, 97, 73, 160, 242, 127, 95, 32, 243, 74, 102, 32, 244, 95, 65, 32, 245, 33, 13, 160, 246, 63, 35, 32, 247, 0, 239, 160, 248, 31, 5, 32, 248, 224, 209, 160, 249, 254, 231, 32, 250, 192, 179, 160, 251, 232, 3, 160, 252, 123, 171, 160, 253, 199, 187, 112, 3, 112, 198, 32, 4, 41, 88, 32, 5, 80, 168, 32, 6, 9, 58, 32, 7, 48, 138, 32, 7, 233, 28, 32, 9, 16, 108, 32, 9, 200, 254, 32, 10, 240, 78, 32, 11, 178, 26, 160, 12, 208, 48, 32, 13, 145, 252, 160, 14, 176, 18, 32, 15, 113, 222, 160, 16, 153, 46, 160, 17, 81, 192, 160, 18, 121, 16, 160, 19, 49, 162, 160, 20, 88, 242, 160, 21, 35, 235, 144, 22, 56, 198, 144, 23, 3, 205, 144, 24, 24, 168, 144, 24, 227, 175, 144, 25, 248, 138, 144, 26, 195, 145, 144, 27, 225, 167, 16, 28, 172, 174, 16, 29, 193, 137, 16, 30, 140, 144, 16, 31, 161, 107, 16, 32, 108, 114, 16, 33, 129, 77, 16, 34, 76, 84, 16, 35, 97, 47, 16, 36, 44, 54, 16, 37, 74, 75, 144, 38, 12, 24, 16, 39, 42, 45, 144, 39, 245, 52, 144, 41, 10, 15, 144, 41, 213, 22, 144, 42, 233, 241, 144, 43, 180, 248, 144, 44, 201, 211, 144, 45, 148, 218, 144, 46, 169, 181, 144, 47, 116, 188, 144, 48, 137, 151, 144, 48, 231, 36, 0, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 2, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 6, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 7, 9, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 6, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 255, 255, 250, 36, 0, 0, 255, 255, 250, 15, 0, 4, 0, 0, 8, 31, 1, 8, 0, 0, 14, 16, 1, 12, 0, 0, 0, 0, 0, 16, 0, 0, 14, 16, 1, 8, 0, 0, 0, 0, 0, 16, 0, 0, 14, 16, 0, 8, 0, 0, 14, 16, 1, 8, 0, 0, 0, 0, 0, 16, 76, 77, 84, 0, 68, 77, 84, 0, 73, 83, 84, 0, 66, 83, 84, 0, 71, 77, 84, 0, 0, 0, 1, 1, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 71, 77, 84, 48, 73, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 49, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/Europe/Gibraltar": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 198, 0, 0, 0, 7, 0, 0, 0, 26, 128, 0, 0, 0, 155, 38, 173, 160, 155, 214, 5, 32, 156, 207, 48, 160, 157, 164, 195, 160, 158, 156, 157, 160, 159, 151, 26, 160, 160, 133, 186, 32, 161, 118, 252, 160, 162, 101, 156, 32, 163, 123, 200, 160, 164, 78, 184, 160, 165, 63, 251, 32, 166, 37, 96, 32, 167, 39, 198, 32, 168, 42, 44, 32, 168, 235, 248, 160, 170, 0, 211, 160, 170, 213, 21, 32, 171, 233, 240, 32, 172, 199, 108, 32, 173, 201, 210, 32, 174, 167, 78, 32, 175, 160, 121, 160, 176, 135, 48, 32, 177, 146, 208, 160, 178, 112, 76, 160, 179, 114, 178, 160, 180, 80, 46, 160, 181, 73, 90, 32, 182, 48, 16, 160, 183, 50, 118, 160, 184, 15, 242, 160, 185, 18, 88, 160, 185, 239, 212, 160, 186, 233, 0, 32, 187, 216, 241, 32, 188, 219, 87, 32, 189, 184, 211, 32, 190, 177, 254, 160, 191, 152, 181, 32, 192, 155, 27, 32, 193, 120, 151, 32, 194, 122, 253, 32, 195, 88, 121, 32, 196, 81, 164, 160, 197, 56, 91, 32, 198, 58, 193, 32, 199, 88, 214, 160, 199, 218, 9, 160, 202, 22, 38, 144, 202, 151, 89, 144, 203, 209, 30, 144, 204, 119, 59, 144, 205, 177, 0, 144, 206, 96, 88, 16, 207, 144, 226, 144, 208, 110, 94, 144, 209, 114, 22, 16, 209, 251, 50, 16, 210, 105, 254, 32, 211, 99, 41, 160, 212, 73, 224, 32, 213, 30, 33, 160, 213, 66, 253, 144, 213, 223, 224, 16, 214, 78, 172, 32, 214, 254, 3, 160, 216, 46, 142, 32, 216, 249, 149, 32, 218, 14, 112, 32, 218, 235, 236, 32, 219, 229, 23, 160, 220, 203, 206, 32, 221, 196, 249, 160, 222, 180, 234, 160, 223, 174, 22, 32, 224, 148, 204, 160, 225, 114, 72, 160, 226, 107, 116, 32, 227, 82, 42, 160, 228, 84, 144, 160, 229, 50, 12, 160, 230, 61, 173, 32, 231, 27, 41, 32, 232, 20, 84, 160, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1, 3, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 4, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 255, 255, 250, 252, 0, 0, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 8, 0, 0, 28, 32, 1, 12, 0, 0, 14, 16, 0, 17, 0, 0, 28, 32, 1, 21, 0, 0, 14, 16, 0, 17, 76, 77, 84, 0, 66, 83, 84, 0, 71, 77, 84, 0, 66, 68, 83, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Guernsey": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 243, 0, 0, 0, 8, 0, 0, 0, 17, 128, 0, 0, 0, 155, 38, 173, 160, 155, 214, 5, 32, 156, 207, 48, 160, 157, 164, 195, 160, 158, 156, 157, 160, 159, 151, 26, 160, 160, 133, 186, 32, 161, 118, 252, 160, 162, 101, 156, 32, 163, 123, 200, 160, 164, 78, 184, 160, 165, 63, 251, 32, 166, 37, 96, 32, 167, 39, 198, 32, 168, 42, 44, 32, 168, 235, 248, 160, 170, 0, 211, 160, 170, 213, 21, 32, 171, 233, 240, 32, 172, 199, 108, 32, 173, 201, 210, 32, 174, 167, 78, 32, 175, 160, 121, 160, 176, 135, 48, 32, 177, 146, 208, 160, 178, 112, 76, 160, 179, 114, 178, 160, 180, 80, 46, 160, 181, 73, 90, 32, 182, 48, 16, 160, 183, 50, 118, 160, 184, 15, 242, 160, 185, 18, 88, 160, 185, 239, 212, 160, 186, 233, 0, 32, 187, 216, 241, 32, 188, 219, 87, 32, 189, 184, 211, 32, 190, 177, 254, 160, 191, 152, 181, 32, 192, 155, 27, 32, 193, 120, 151, 32, 194, 122, 253, 32, 195, 88, 121, 32, 196, 81, 164, 160, 197, 56, 91, 32, 198, 58, 193, 32, 199, 88, 214, 160, 199, 218, 9, 160, 202, 22, 38, 144, 202, 151, 89, 144, 203, 209, 30, 144, 204, 119, 59, 144, 205, 177, 0, 144, 206, 96, 88, 16, 207, 144, 226, 144, 208, 110, 94, 144, 209, 114, 22, 16, 209, 251, 50, 16, 210, 105, 254, 32, 211, 99, 41, 160, 212, 73, 224, 32, 213, 30, 33, 160, 213, 66, 253, 144, 213, 223, 224, 16, 214, 78, 172, 32, 214, 254, 3, 160, 216, 46, 142, 32, 216, 249, 149, 32, 218, 14, 112, 32, 218, 235, 236, 32, 219, 229, 23, 160, 220, 203, 206, 32, 221, 196, 249, 160, 222, 180, 234, 160, 223, 174, 22, 32, 224, 148, 204, 160, 225, 114, 72, 160, 226, 107, 116, 32, 227, 82, 42, 160, 228, 84, 144, 160, 229, 50, 12, 160, 230, 61, 173, 32, 231, 27, 41, 32, 232, 20, 84, 160, 232, 251, 11, 32, 233, 253, 113, 32, 234, 218, 237, 32, 235, 221, 83, 32, 236, 186, 207, 32, 237, 179, 250, 160, 238, 154, 177, 32, 239, 129, 103, 160, 240, 159, 125, 32, 241, 97, 73, 160, 242, 127, 95, 32, 243, 74, 102, 32, 244, 95, 65, 32, 245, 33, 13, 160, 246, 63, 35, 32, 247, 0, 239, 160, 248, 31, 5, 32, 248, 224, 209, 160, 249, 254, 231, 32, 250, 192, 179, 160, 251, 232, 3, 160, 252, 123, 171, 160, 253, 199, 187, 112, 3, 112, 198, 32, 4, 41, 88, 32, 5, 80, 168, 32, 6, 9, 58, 32, 7, 48, 138, 32, 7, 233, 28, 32, 9, 16, 108, 32, 9, 200, 254, 32, 10, 240, 78, 32, 11, 178, 26, 160, 12, 208, 48, 32, 13, 145, 252, 160, 14, 176, 18, 32, 15, 113, 222, 160, 16, 153, 46, 160, 17, 81, 192, 160, 18, 121, 16, 160, 19, 49, 162, 160, 20, 88, 242, 160, 21, 35, 235, 144, 22, 56, 198, 144, 23, 3, 205, 144, 24, 24, 168, 144, 24, 227, 175, 144, 25, 248, 138, 144, 26, 195, 145, 144, 27, 225, 167, 16, 28, 172, 174, 16, 29, 193, 137, 16, 30, 140, 144, 16, 31, 161, 107, 16, 32, 108, 114, 16, 33, 129, 77, 16, 34, 76, 84, 16, 35, 97, 47, 16, 36, 44, 54, 16, 37, 74, 75, 144, 38, 12, 24, 16, 39, 42, 45, 144, 39, 245, 52, 144, 41, 10, 15, 144, 41, 213, 22, 144, 42, 233, 241, 144, 43, 180, 248, 144, 44, 201, 211, 144, 45, 148, 218, 144, 46, 169, 181, 144, 47, 116, 188, 144, 48, 137, 151, 144, 48, 231, 36, 0, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1, 3, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 4, 6, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 7, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 255, 255, 255, 181, 0, 0, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 8, 0, 0, 28, 32, 1, 12, 0, 0, 14, 16, 0, 4, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 8, 76, 77, 84, 0, 66, 83, 84, 0, 71, 77, 84, 0, 66, 68, 83, 84, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 10, 71, 77, 84, 48, 66, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 49, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/Europe/Helsinki": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 118, 0, 0, 0, 6, 0, 0, 0, 17, 128, 0, 0, 0, 164, 115, 111, 27, 203, 206, 81, 96, 204, 192, 229, 96, 21, 35, 221, 128, 22, 19, 206, 128, 23, 3, 191, 128, 23, 243, 176, 128, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 3, 2, 3, 2, 3, 2, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 0, 0, 23, 101, 0, 0, 0, 0, 23, 101, 0, 4, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 76, 77, 84, 0, 72, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 51, 44, 77, 49, 48, 46, 53, 46, 48, 47, 52, 10}, - - "zoneinfo/Europe/Isle_of_Man": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 243, 0, 0, 0, 8, 0, 0, 0, 17, 128, 0, 0, 0, 155, 38, 173, 160, 155, 214, 5, 32, 156, 207, 48, 160, 157, 164, 195, 160, 158, 156, 157, 160, 159, 151, 26, 160, 160, 133, 186, 32, 161, 118, 252, 160, 162, 101, 156, 32, 163, 123, 200, 160, 164, 78, 184, 160, 165, 63, 251, 32, 166, 37, 96, 32, 167, 39, 198, 32, 168, 42, 44, 32, 168, 235, 248, 160, 170, 0, 211, 160, 170, 213, 21, 32, 171, 233, 240, 32, 172, 199, 108, 32, 173, 201, 210, 32, 174, 167, 78, 32, 175, 160, 121, 160, 176, 135, 48, 32, 177, 146, 208, 160, 178, 112, 76, 160, 179, 114, 178, 160, 180, 80, 46, 160, 181, 73, 90, 32, 182, 48, 16, 160, 183, 50, 118, 160, 184, 15, 242, 160, 185, 18, 88, 160, 185, 239, 212, 160, 186, 233, 0, 32, 187, 216, 241, 32, 188, 219, 87, 32, 189, 184, 211, 32, 190, 177, 254, 160, 191, 152, 181, 32, 192, 155, 27, 32, 193, 120, 151, 32, 194, 122, 253, 32, 195, 88, 121, 32, 196, 81, 164, 160, 197, 56, 91, 32, 198, 58, 193, 32, 199, 88, 214, 160, 199, 218, 9, 160, 202, 22, 38, 144, 202, 151, 89, 144, 203, 209, 30, 144, 204, 119, 59, 144, 205, 177, 0, 144, 206, 96, 88, 16, 207, 144, 226, 144, 208, 110, 94, 144, 209, 114, 22, 16, 209, 251, 50, 16, 210, 105, 254, 32, 211, 99, 41, 160, 212, 73, 224, 32, 213, 30, 33, 160, 213, 66, 253, 144, 213, 223, 224, 16, 214, 78, 172, 32, 214, 254, 3, 160, 216, 46, 142, 32, 216, 249, 149, 32, 218, 14, 112, 32, 218, 235, 236, 32, 219, 229, 23, 160, 220, 203, 206, 32, 221, 196, 249, 160, 222, 180, 234, 160, 223, 174, 22, 32, 224, 148, 204, 160, 225, 114, 72, 160, 226, 107, 116, 32, 227, 82, 42, 160, 228, 84, 144, 160, 229, 50, 12, 160, 230, 61, 173, 32, 231, 27, 41, 32, 232, 20, 84, 160, 232, 251, 11, 32, 233, 253, 113, 32, 234, 218, 237, 32, 235, 221, 83, 32, 236, 186, 207, 32, 237, 179, 250, 160, 238, 154, 177, 32, 239, 129, 103, 160, 240, 159, 125, 32, 241, 97, 73, 160, 242, 127, 95, 32, 243, 74, 102, 32, 244, 95, 65, 32, 245, 33, 13, 160, 246, 63, 35, 32, 247, 0, 239, 160, 248, 31, 5, 32, 248, 224, 209, 160, 249, 254, 231, 32, 250, 192, 179, 160, 251, 232, 3, 160, 252, 123, 171, 160, 253, 199, 187, 112, 3, 112, 198, 32, 4, 41, 88, 32, 5, 80, 168, 32, 6, 9, 58, 32, 7, 48, 138, 32, 7, 233, 28, 32, 9, 16, 108, 32, 9, 200, 254, 32, 10, 240, 78, 32, 11, 178, 26, 160, 12, 208, 48, 32, 13, 145, 252, 160, 14, 176, 18, 32, 15, 113, 222, 160, 16, 153, 46, 160, 17, 81, 192, 160, 18, 121, 16, 160, 19, 49, 162, 160, 20, 88, 242, 160, 21, 35, 235, 144, 22, 56, 198, 144, 23, 3, 205, 144, 24, 24, 168, 144, 24, 227, 175, 144, 25, 248, 138, 144, 26, 195, 145, 144, 27, 225, 167, 16, 28, 172, 174, 16, 29, 193, 137, 16, 30, 140, 144, 16, 31, 161, 107, 16, 32, 108, 114, 16, 33, 129, 77, 16, 34, 76, 84, 16, 35, 97, 47, 16, 36, 44, 54, 16, 37, 74, 75, 144, 38, 12, 24, 16, 39, 42, 45, 144, 39, 245, 52, 144, 41, 10, 15, 144, 41, 213, 22, 144, 42, 233, 241, 144, 43, 180, 248, 144, 44, 201, 211, 144, 45, 148, 218, 144, 46, 169, 181, 144, 47, 116, 188, 144, 48, 137, 151, 144, 48, 231, 36, 0, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1, 3, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 4, 6, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 7, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 255, 255, 255, 181, 0, 0, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 8, 0, 0, 28, 32, 1, 12, 0, 0, 14, 16, 0, 4, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 8, 76, 77, 84, 0, 66, 83, 84, 0, 71, 77, 84, 0, 66, 68, 83, 84, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 10, 71, 77, 84, 48, 66, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 49, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/Europe/Istanbul": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 131, 0, 0, 0, 11, 0, 0, 0, 25, 128, 0, 0, 0, 144, 139, 245, 152, 155, 12, 23, 96, 155, 213, 190, 208, 162, 101, 99, 224, 163, 123, 130, 80, 164, 78, 128, 96, 165, 63, 180, 208, 166, 37, 39, 224, 167, 39, 127, 208, 170, 40, 40, 96, 170, 225, 253, 208, 171, 249, 137, 224, 172, 195, 49, 80, 200, 127, 238, 96, 200, 255, 193, 208, 201, 74, 245, 96, 202, 206, 128, 80, 203, 203, 174, 96, 204, 229, 193, 80, 209, 113, 235, 224, 210, 107, 9, 80, 211, 162, 57, 96, 212, 67, 2, 80, 213, 76, 13, 224, 214, 41, 123, 208, 215, 43, 239, 224, 216, 9, 93, 208, 217, 2, 151, 96, 217, 233, 63, 208, 218, 239, 168, 96, 219, 210, 92, 80, 220, 212, 208, 96, 221, 179, 143, 208, 241, 244, 185, 96, 242, 100, 186, 208, 245, 104, 6, 96, 246, 31, 56, 208, 0, 160, 186, 224, 1, 107, 179, 208, 2, 128, 156, 224, 3, 75, 149, 208, 4, 105, 185, 96, 5, 52, 178, 80, 6, 110, 147, 112, 7, 57, 168, 128, 7, 251, 117, 0, 9, 25, 166, 160, 9, 219, 58, 224, 10, 240, 7, 208, 12, 16, 206, 96, 12, 217, 36, 80, 13, 164, 57, 96, 14, 166, 145, 80, 15, 132, 27, 96, 16, 134, 115, 80, 18, 103, 152, 192, 19, 77, 54, 0, 20, 71, 122, 192, 21, 35, 221, 128, 22, 39, 92, 192, 23, 3, 191, 128, 24, 7, 62, 192, 25, 137, 148, 80, 25, 220, 148, 192, 28, 198, 211, 208, 29, 155, 21, 80, 30, 140, 115, 240, 31, 124, 100, 240, 32, 108, 85, 240, 33, 92, 70, 240, 34, 76, 55, 240, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 10, 240, 38, 11, 251, 240, 39, 5, 39, 112, 39, 245, 24, 112, 40, 229, 9, 112, 41, 212, 250, 112, 42, 196, 235, 112, 43, 180, 220, 112, 44, 164, 205, 112, 45, 139, 131, 240, 46, 132, 175, 112, 47, 116, 160, 112, 48, 100, 145, 112, 49, 93, 188, 240, 50, 114, 151, 240, 51, 61, 158, 240, 52, 82, 121, 240, 53, 29, 128, 240, 54, 50, 91, 240, 54, 253, 98, 240, 56, 27, 120, 112, 56, 221, 68, 240, 57, 251, 90, 112, 58, 189, 38, 240, 59, 219, 60, 112, 60, 166, 67, 112, 61, 187, 30, 112, 62, 134, 37, 112, 63, 155, 0, 112, 64, 102, 7, 112, 65, 132, 28, 240, 66, 69, 233, 112, 67, 99, 254, 240, 68, 37, 203, 112, 69, 67, 224, 240, 69, 152, 50, 224, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 143, 221, 144, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 56, 190, 16, 84, 76, 71, 144, 85, 23, 78, 144, 86, 62, 158, 144, 86, 247, 48, 144, 87, 207, 46, 80, 127, 255, 255, 255, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 2, 3, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 3, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 5, 5, 0, 0, 27, 40, 0, 0, 0, 0, 27, 104, 0, 4, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 0, 0, 56, 64, 1, 17, 0, 0, 42, 48, 0, 21, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 0, 0, 42, 48, 0, 21, 76, 77, 84, 0, 73, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 43, 48, 52, 0, 43, 48, 51, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 10, 60, 43, 48, 51, 62, 45, 51, 10}, - - "zoneinfo/Europe/Jersey": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 243, 0, 0, 0, 8, 0, 0, 0, 17, 128, 0, 0, 0, 155, 38, 173, 160, 155, 214, 5, 32, 156, 207, 48, 160, 157, 164, 195, 160, 158, 156, 157, 160, 159, 151, 26, 160, 160, 133, 186, 32, 161, 118, 252, 160, 162, 101, 156, 32, 163, 123, 200, 160, 164, 78, 184, 160, 165, 63, 251, 32, 166, 37, 96, 32, 167, 39, 198, 32, 168, 42, 44, 32, 168, 235, 248, 160, 170, 0, 211, 160, 170, 213, 21, 32, 171, 233, 240, 32, 172, 199, 108, 32, 173, 201, 210, 32, 174, 167, 78, 32, 175, 160, 121, 160, 176, 135, 48, 32, 177, 146, 208, 160, 178, 112, 76, 160, 179, 114, 178, 160, 180, 80, 46, 160, 181, 73, 90, 32, 182, 48, 16, 160, 183, 50, 118, 160, 184, 15, 242, 160, 185, 18, 88, 160, 185, 239, 212, 160, 186, 233, 0, 32, 187, 216, 241, 32, 188, 219, 87, 32, 189, 184, 211, 32, 190, 177, 254, 160, 191, 152, 181, 32, 192, 155, 27, 32, 193, 120, 151, 32, 194, 122, 253, 32, 195, 88, 121, 32, 196, 81, 164, 160, 197, 56, 91, 32, 198, 58, 193, 32, 199, 88, 214, 160, 199, 218, 9, 160, 202, 22, 38, 144, 202, 151, 89, 144, 203, 209, 30, 144, 204, 119, 59, 144, 205, 177, 0, 144, 206, 96, 88, 16, 207, 144, 226, 144, 208, 110, 94, 144, 209, 114, 22, 16, 209, 251, 50, 16, 210, 105, 254, 32, 211, 99, 41, 160, 212, 73, 224, 32, 213, 30, 33, 160, 213, 66, 253, 144, 213, 223, 224, 16, 214, 78, 172, 32, 214, 254, 3, 160, 216, 46, 142, 32, 216, 249, 149, 32, 218, 14, 112, 32, 218, 235, 236, 32, 219, 229, 23, 160, 220, 203, 206, 32, 221, 196, 249, 160, 222, 180, 234, 160, 223, 174, 22, 32, 224, 148, 204, 160, 225, 114, 72, 160, 226, 107, 116, 32, 227, 82, 42, 160, 228, 84, 144, 160, 229, 50, 12, 160, 230, 61, 173, 32, 231, 27, 41, 32, 232, 20, 84, 160, 232, 251, 11, 32, 233, 253, 113, 32, 234, 218, 237, 32, 235, 221, 83, 32, 236, 186, 207, 32, 237, 179, 250, 160, 238, 154, 177, 32, 239, 129, 103, 160, 240, 159, 125, 32, 241, 97, 73, 160, 242, 127, 95, 32, 243, 74, 102, 32, 244, 95, 65, 32, 245, 33, 13, 160, 246, 63, 35, 32, 247, 0, 239, 160, 248, 31, 5, 32, 248, 224, 209, 160, 249, 254, 231, 32, 250, 192, 179, 160, 251, 232, 3, 160, 252, 123, 171, 160, 253, 199, 187, 112, 3, 112, 198, 32, 4, 41, 88, 32, 5, 80, 168, 32, 6, 9, 58, 32, 7, 48, 138, 32, 7, 233, 28, 32, 9, 16, 108, 32, 9, 200, 254, 32, 10, 240, 78, 32, 11, 178, 26, 160, 12, 208, 48, 32, 13, 145, 252, 160, 14, 176, 18, 32, 15, 113, 222, 160, 16, 153, 46, 160, 17, 81, 192, 160, 18, 121, 16, 160, 19, 49, 162, 160, 20, 88, 242, 160, 21, 35, 235, 144, 22, 56, 198, 144, 23, 3, 205, 144, 24, 24, 168, 144, 24, 227, 175, 144, 25, 248, 138, 144, 26, 195, 145, 144, 27, 225, 167, 16, 28, 172, 174, 16, 29, 193, 137, 16, 30, 140, 144, 16, 31, 161, 107, 16, 32, 108, 114, 16, 33, 129, 77, 16, 34, 76, 84, 16, 35, 97, 47, 16, 36, 44, 54, 16, 37, 74, 75, 144, 38, 12, 24, 16, 39, 42, 45, 144, 39, 245, 52, 144, 41, 10, 15, 144, 41, 213, 22, 144, 42, 233, 241, 144, 43, 180, 248, 144, 44, 201, 211, 144, 45, 148, 218, 144, 46, 169, 181, 144, 47, 116, 188, 144, 48, 137, 151, 144, 48, 231, 36, 0, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1, 3, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 4, 6, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 7, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 255, 255, 255, 181, 0, 0, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 8, 0, 0, 28, 32, 1, 12, 0, 0, 14, 16, 0, 4, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 8, 76, 77, 84, 0, 66, 83, 84, 0, 71, 77, 84, 0, 66, 68, 83, 84, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 10, 71, 77, 84, 48, 66, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 49, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/Europe/Kaliningrad": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 79, 0, 0, 0, 15, 0, 0, 0, 34, 128, 0, 0, 0, 155, 12, 23, 96, 155, 213, 218, 240, 156, 217, 174, 144, 157, 164, 181, 144, 158, 185, 144, 144, 159, 132, 151, 144, 200, 9, 113, 144, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 208, 250, 1, 112, 209, 149, 132, 96, 210, 138, 173, 80, 210, 219, 38, 224, 21, 39, 167, 208, 22, 24, 220, 64, 23, 8, 219, 80, 23, 250, 15, 192, 24, 234, 14, 208, 25, 219, 67, 64, 26, 204, 147, 208, 27, 188, 160, 240, 28, 172, 145, 240, 29, 156, 130, 240, 30, 140, 115, 240, 31, 124, 100, 240, 32, 108, 85, 240, 33, 92, 70, 240, 34, 76, 55, 240, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 25, 0, 38, 12, 10, 0, 39, 5, 53, 128, 39, 245, 38, 128, 40, 229, 23, 128, 41, 213, 8, 128, 42, 196, 249, 128, 43, 180, 234, 128, 44, 164, 219, 128, 45, 148, 204, 128, 46, 132, 189, 128, 47, 116, 174, 128, 48, 100, 159, 128, 49, 93, 203, 0, 50, 114, 166, 0, 51, 61, 173, 0, 52, 82, 136, 0, 53, 29, 143, 0, 54, 50, 106, 0, 54, 253, 113, 0, 56, 27, 134, 128, 56, 221, 83, 0, 57, 251, 104, 128, 58, 189, 53, 0, 59, 219, 74, 128, 60, 166, 81, 128, 61, 187, 44, 128, 62, 134, 51, 128, 63, 155, 14, 128, 64, 102, 21, 128, 65, 132, 43, 0, 66, 69, 247, 128, 67, 100, 13, 0, 68, 37, 217, 128, 69, 67, 239, 0, 70, 5, 187, 128, 71, 35, 209, 0, 71, 238, 216, 0, 73, 3, 179, 0, 73, 206, 186, 0, 74, 227, 149, 0, 75, 174, 156, 0, 76, 204, 177, 128, 77, 142, 126, 0, 84, 76, 43, 112, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 6, 5, 6, 8, 7, 8, 7, 8, 7, 8, 7, 9, 10, 9, 10, 9, 10, 9, 10, 9, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 13, 12, 0, 0, 19, 56, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 9, 0, 0, 56, 64, 1, 13, 0, 0, 42, 48, 0, 17, 0, 0, 42, 48, 0, 17, 0, 0, 56, 64, 1, 13, 0, 0, 42, 48, 1, 21, 0, 0, 28, 32, 0, 26, 0, 0, 42, 48, 0, 30, 0, 0, 28, 32, 0, 26, 76, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 77, 83, 68, 0, 77, 83, 75, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 43, 48, 51, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 69, 84, 45, 50, 10}, - - "zoneinfo/Europe/Kiev": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 121, 0, 0, 0, 13, 0, 0, 0, 34, 128, 0, 0, 0, 170, 25, 167, 100, 181, 164, 25, 96, 202, 205, 46, 208, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 206, 205, 168, 112, 21, 39, 167, 208, 22, 24, 220, 64, 23, 8, 219, 80, 23, 250, 15, 192, 24, 234, 14, 208, 25, 219, 67, 64, 26, 204, 147, 208, 27, 188, 160, 240, 28, 172, 145, 240, 29, 156, 130, 240, 30, 140, 115, 240, 31, 124, 100, 240, 32, 108, 85, 240, 33, 92, 70, 240, 34, 76, 55, 240, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 10, 240, 38, 11, 251, 240, 38, 141, 32, 224, 40, 229, 23, 128, 41, 212, 236, 96, 42, 196, 207, 80, 43, 180, 206, 96, 44, 164, 177, 80, 45, 148, 176, 96, 46, 132, 147, 80, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 2, 3, 6, 4, 5, 4, 3, 7, 3, 7, 3, 7, 3, 7, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 10, 2, 10, 2, 10, 2, 10, 2, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 0, 0, 28, 156, 0, 0, 0, 0, 28, 156, 0, 4, 0, 0, 28, 32, 0, 8, 0, 0, 42, 48, 0, 12, 0, 0, 14, 16, 0, 16, 0, 0, 28, 32, 1, 20, 0, 0, 28, 32, 1, 20, 0, 0, 56, 64, 1, 25, 0, 0, 42, 48, 0, 12, 0, 0, 56, 64, 1, 25, 0, 0, 42, 48, 1, 29, 0, 0, 42, 48, 1, 29, 0, 0, 28, 32, 0, 8, 76, 77, 84, 0, 75, 77, 84, 0, 69, 69, 84, 0, 77, 83, 75, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 77, 83, 68, 0, 69, 69, 83, 84, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 51, 44, 77, 49, 48, 46, 53, 46, 48, 47, 52, 10}, - - "zoneinfo/Europe/Kirov": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 65, 0, 0, 0, 8, 0, 0, 0, 16, 128, 0, 0, 0, 161, 0, 57, 128, 181, 164, 11, 80, 21, 39, 153, 192, 22, 24, 206, 48, 23, 8, 205, 64, 23, 250, 1, 176, 24, 234, 0, 192, 25, 219, 53, 48, 26, 204, 133, 192, 27, 188, 146, 224, 28, 172, 131, 224, 29, 156, 116, 224, 30, 140, 101, 224, 31, 124, 86, 224, 32, 108, 71, 224, 33, 92, 56, 224, 34, 76, 41, 224, 35, 60, 26, 224, 36, 44, 11, 224, 37, 28, 10, 240, 38, 11, 251, 240, 39, 5, 39, 112, 39, 245, 24, 112, 41, 212, 236, 96, 42, 196, 235, 112, 43, 180, 220, 112, 44, 164, 205, 112, 45, 148, 190, 112, 46, 132, 175, 112, 47, 116, 160, 112, 48, 100, 145, 112, 49, 93, 188, 240, 50, 114, 151, 240, 51, 61, 158, 240, 52, 82, 121, 240, 53, 29, 128, 240, 54, 50, 91, 240, 54, 253, 98, 240, 56, 27, 120, 112, 56, 221, 68, 240, 57, 251, 90, 112, 58, 189, 38, 240, 59, 219, 60, 112, 60, 166, 67, 112, 61, 187, 30, 112, 62, 134, 37, 112, 63, 155, 0, 112, 64, 102, 7, 112, 65, 132, 28, 240, 66, 69, 233, 112, 67, 99, 254, 240, 68, 37, 203, 112, 69, 67, 224, 240, 70, 5, 173, 112, 71, 35, 194, 240, 71, 238, 201, 240, 73, 3, 164, 240, 73, 206, 171, 240, 74, 227, 134, 240, 75, 174, 141, 240, 76, 204, 163, 112, 77, 142, 111, 240, 84, 76, 29, 96, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 6, 7, 4, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 4, 7, 7, 0, 0, 46, 152, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 0, 12, 0, 0, 56, 64, 0, 12, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 1, 12, 0, 0, 42, 48, 0, 4, 76, 77, 84, 0, 43, 48, 51, 0, 43, 48, 53, 0, 43, 48, 52, 0, 0, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 51, 62, 45, 51, 10}, - - "zoneinfo/Europe/Lisbon": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 222, 0, 0, 0, 11, 0, 0, 0, 27, 128, 0, 0, 0, 146, 230, 151, 29, 155, 75, 109, 112, 155, 254, 199, 128, 156, 156, 237, 112, 157, 201, 131, 112, 158, 127, 114, 112, 159, 170, 182, 240, 160, 95, 84, 112, 161, 139, 234, 112, 162, 65, 217, 112, 163, 110, 111, 112, 164, 35, 12, 240, 165, 79, 162, 240, 170, 5, 239, 112, 170, 244, 142, 240, 173, 201, 167, 240, 174, 167, 35, 240, 175, 160, 79, 112, 176, 135, 5, 240, 177, 137, 107, 240, 178, 112, 34, 112, 179, 114, 136, 112, 180, 80, 4, 112, 183, 50, 76, 112, 184, 15, 200, 112, 184, 255, 185, 112, 185, 239, 170, 112, 188, 200, 183, 240, 189, 184, 168, 240, 190, 159, 95, 112, 191, 152, 138, 240, 192, 154, 240, 240, 193, 120, 108, 240, 194, 104, 93, 240, 195, 88, 78, 240, 196, 63, 5, 112, 197, 56, 48, 240, 198, 58, 150, 240, 199, 88, 172, 112, 199, 217, 223, 112, 201, 1, 47, 112, 201, 241, 32, 112, 202, 226, 98, 240, 203, 181, 82, 240, 203, 236, 163, 224, 204, 128, 75, 224, 204, 220, 162, 240, 205, 149, 52, 240, 205, 195, 75, 96, 206, 114, 162, 224, 206, 197, 191, 112, 207, 117, 22, 240, 207, 172, 103, 224, 208, 82, 132, 224, 208, 165, 161, 112, 209, 84, 248, 240, 209, 140, 73, 224, 210, 50, 102, 224, 210, 133, 131, 112, 211, 89, 196, 240, 212, 73, 181, 240, 213, 57, 209, 32, 214, 41, 194, 32, 215, 25, 179, 32, 216, 9, 164, 32, 216, 249, 149, 32, 217, 233, 134, 32, 220, 185, 89, 32, 221, 178, 132, 160, 222, 162, 117, 160, 223, 146, 102, 160, 224, 130, 87, 160, 225, 114, 72, 160, 226, 98, 57, 160, 227, 82, 42, 160, 228, 66, 27, 160, 229, 50, 12, 160, 230, 33, 253, 160, 231, 27, 41, 32, 232, 11, 26, 32, 232, 251, 11, 32, 233, 234, 252, 32, 234, 218, 237, 32, 235, 202, 222, 32, 236, 186, 207, 32, 237, 170, 192, 32, 238, 154, 177, 32, 239, 138, 162, 32, 240, 122, 147, 32, 241, 106, 132, 32, 242, 99, 175, 160, 243, 83, 160, 160, 244, 67, 145, 160, 245, 51, 130, 160, 246, 35, 115, 160, 247, 19, 100, 160, 248, 3, 85, 160, 248, 243, 70, 160, 12, 171, 42, 0, 13, 155, 27, 0, 14, 139, 12, 0, 15, 132, 55, 128, 16, 116, 40, 128, 17, 100, 25, 128, 18, 84, 24, 144, 19, 67, 251, 128, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 189, 160, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 0, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 5, 3, 4, 3, 5, 3, 4, 3, 5, 3, 4, 3, 5, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 6, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 7, 8, 7, 8, 7, 8, 7, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 255, 255, 247, 99, 0, 0, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 9, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 9, 0, 0, 28, 32, 1, 13, 0, 0, 14, 16, 0, 18, 0, 0, 14, 16, 0, 18, 0, 0, 28, 32, 1, 22, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 9, 76, 77, 84, 0, 87, 69, 83, 84, 0, 87, 69, 84, 0, 87, 69, 77, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 10, 87, 69, 84, 48, 87, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 49, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/Europe/Ljubljana": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 121, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 202, 2, 53, 224, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 208, 250, 1, 112, 209, 161, 140, 16, 210, 78, 64, 144, 24, 69, 95, 112, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 4, 2, 3, 2, 3, 2, 1, 3, 2, 1, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 19, 56, 0, 0, 0, 0, 14, 16, 0, 4, 0, 0, 14, 16, 0, 4, 0, 0, 28, 32, 1, 8, 0, 0, 28, 32, 1, 8, 0, 0, 28, 32, 1, 8, 0, 0, 14, 16, 0, 4, 76, 77, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/London": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 243, 0, 0, 0, 8, 0, 0, 0, 17, 128, 0, 0, 0, 155, 38, 173, 160, 155, 214, 5, 32, 156, 207, 48, 160, 157, 164, 195, 160, 158, 156, 157, 160, 159, 151, 26, 160, 160, 133, 186, 32, 161, 118, 252, 160, 162, 101, 156, 32, 163, 123, 200, 160, 164, 78, 184, 160, 165, 63, 251, 32, 166, 37, 96, 32, 167, 39, 198, 32, 168, 42, 44, 32, 168, 235, 248, 160, 170, 0, 211, 160, 170, 213, 21, 32, 171, 233, 240, 32, 172, 199, 108, 32, 173, 201, 210, 32, 174, 167, 78, 32, 175, 160, 121, 160, 176, 135, 48, 32, 177, 146, 208, 160, 178, 112, 76, 160, 179, 114, 178, 160, 180, 80, 46, 160, 181, 73, 90, 32, 182, 48, 16, 160, 183, 50, 118, 160, 184, 15, 242, 160, 185, 18, 88, 160, 185, 239, 212, 160, 186, 233, 0, 32, 187, 216, 241, 32, 188, 219, 87, 32, 189, 184, 211, 32, 190, 177, 254, 160, 191, 152, 181, 32, 192, 155, 27, 32, 193, 120, 151, 32, 194, 122, 253, 32, 195, 88, 121, 32, 196, 81, 164, 160, 197, 56, 91, 32, 198, 58, 193, 32, 199, 88, 214, 160, 199, 218, 9, 160, 202, 22, 38, 144, 202, 151, 89, 144, 203, 209, 30, 144, 204, 119, 59, 144, 205, 177, 0, 144, 206, 96, 88, 16, 207, 144, 226, 144, 208, 110, 94, 144, 209, 114, 22, 16, 209, 251, 50, 16, 210, 105, 254, 32, 211, 99, 41, 160, 212, 73, 224, 32, 213, 30, 33, 160, 213, 66, 253, 144, 213, 223, 224, 16, 214, 78, 172, 32, 214, 254, 3, 160, 216, 46, 142, 32, 216, 249, 149, 32, 218, 14, 112, 32, 218, 235, 236, 32, 219, 229, 23, 160, 220, 203, 206, 32, 221, 196, 249, 160, 222, 180, 234, 160, 223, 174, 22, 32, 224, 148, 204, 160, 225, 114, 72, 160, 226, 107, 116, 32, 227, 82, 42, 160, 228, 84, 144, 160, 229, 50, 12, 160, 230, 61, 173, 32, 231, 27, 41, 32, 232, 20, 84, 160, 232, 251, 11, 32, 233, 253, 113, 32, 234, 218, 237, 32, 235, 221, 83, 32, 236, 186, 207, 32, 237, 179, 250, 160, 238, 154, 177, 32, 239, 129, 103, 160, 240, 159, 125, 32, 241, 97, 73, 160, 242, 127, 95, 32, 243, 74, 102, 32, 244, 95, 65, 32, 245, 33, 13, 160, 246, 63, 35, 32, 247, 0, 239, 160, 248, 31, 5, 32, 248, 224, 209, 160, 249, 254, 231, 32, 250, 192, 179, 160, 251, 232, 3, 160, 252, 123, 171, 160, 253, 199, 187, 112, 3, 112, 198, 32, 4, 41, 88, 32, 5, 80, 168, 32, 6, 9, 58, 32, 7, 48, 138, 32, 7, 233, 28, 32, 9, 16, 108, 32, 9, 200, 254, 32, 10, 240, 78, 32, 11, 178, 26, 160, 12, 208, 48, 32, 13, 145, 252, 160, 14, 176, 18, 32, 15, 113, 222, 160, 16, 153, 46, 160, 17, 81, 192, 160, 18, 121, 16, 160, 19, 49, 162, 160, 20, 88, 242, 160, 21, 35, 235, 144, 22, 56, 198, 144, 23, 3, 205, 144, 24, 24, 168, 144, 24, 227, 175, 144, 25, 248, 138, 144, 26, 195, 145, 144, 27, 225, 167, 16, 28, 172, 174, 16, 29, 193, 137, 16, 30, 140, 144, 16, 31, 161, 107, 16, 32, 108, 114, 16, 33, 129, 77, 16, 34, 76, 84, 16, 35, 97, 47, 16, 36, 44, 54, 16, 37, 74, 75, 144, 38, 12, 24, 16, 39, 42, 45, 144, 39, 245, 52, 144, 41, 10, 15, 144, 41, 213, 22, 144, 42, 233, 241, 144, 43, 180, 248, 144, 44, 201, 211, 144, 45, 148, 218, 144, 46, 169, 181, 144, 47, 116, 188, 144, 48, 137, 151, 144, 48, 231, 36, 0, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1, 3, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 4, 6, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 7, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 255, 255, 255, 181, 0, 0, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 8, 0, 0, 28, 32, 1, 12, 0, 0, 14, 16, 0, 4, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 8, 76, 77, 84, 0, 66, 83, 84, 0, 71, 77, 84, 0, 66, 68, 83, 84, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 10, 71, 77, 84, 48, 66, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 49, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/Europe/Luxembourg": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 14, 0, 0, 0, 14, 0, 0, 0, 0, 0, 0, 0, 185, 0, 0, 0, 14, 0, 0, 0, 22, 128, 0, 0, 0, 132, 162, 173, 188, 155, 30, 140, 96, 155, 213, 218, 240, 156, 234, 167, 224, 157, 164, 153, 112, 158, 185, 144, 144, 159, 132, 151, 144, 159, 224, 196, 112, 160, 96, 165, 240, 161, 126, 229, 160, 162, 46, 18, 240, 163, 122, 105, 16, 164, 53, 129, 240, 165, 94, 63, 144, 166, 37, 53, 240, 167, 39, 170, 0, 168, 42, 1, 240, 169, 7, 154, 16, 169, 238, 52, 112, 170, 231, 110, 0, 171, 216, 162, 112, 172, 199, 80, 0, 173, 201, 167, 240, 174, 167, 50, 0, 175, 160, 79, 112, 176, 135, 20, 0, 177, 137, 107, 240, 178, 112, 48, 128, 179, 114, 136, 112, 180, 80, 46, 160, 181, 73, 90, 32, 182, 48, 16, 160, 183, 50, 118, 160, 184, 15, 242, 160, 184, 255, 227, 160, 185, 239, 212, 160, 186, 214, 139, 32, 187, 216, 241, 32, 188, 200, 226, 32, 189, 184, 211, 32, 190, 159, 137, 160, 191, 152, 181, 32, 192, 155, 27, 32, 193, 120, 151, 32, 194, 104, 136, 32, 195, 88, 121, 32, 196, 63, 47, 160, 197, 56, 91, 32, 198, 58, 193, 32, 199, 88, 214, 160, 199, 218, 9, 160, 200, 66, 48, 32, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 111, 176, 16, 209, 114, 22, 16, 210, 78, 64, 144, 211, 145, 64, 16, 212, 75, 35, 144, 13, 42, 253, 112, 13, 164, 99, 144, 14, 139, 26, 16, 15, 132, 69, 144, 16, 116, 54, 144, 17, 100, 39, 144, 18, 84, 24, 144, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 0, 2, 1, 2, 1, 2, 3, 4, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 11, 9, 10, 9, 10, 2, 3, 4, 3, 4, 2, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 0, 0, 5, 196, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 14, 16, 1, 13, 0, 0, 0, 0, 0, 18, 0, 0, 0, 0, 0, 18, 0, 0, 14, 16, 1, 13, 0, 0, 14, 16, 0, 18, 0, 0, 28, 32, 1, 13, 0, 0, 28, 32, 1, 13, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 76, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 87, 69, 83, 84, 0, 87, 69, 84, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Madrid": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 163, 0, 0, 0, 11, 0, 0, 0, 27, 128, 0, 0, 0, 158, 186, 197, 240, 159, 160, 57, 0, 160, 144, 27, 240, 161, 129, 108, 128, 170, 5, 239, 112, 170, 231, 110, 0, 173, 201, 167, 240, 174, 167, 50, 0, 175, 160, 79, 112, 176, 135, 20, 0, 177, 137, 122, 0, 178, 112, 48, 128, 179, 114, 136, 112, 180, 80, 18, 128, 194, 201, 236, 240, 195, 88, 93, 0, 196, 72, 63, 240, 196, 109, 27, 224, 197, 57, 116, 96, 199, 33, 91, 128, 199, 245, 142, 240, 203, 245, 222, 96, 204, 149, 113, 240, 205, 195, 75, 96, 206, 160, 213, 112, 207, 163, 45, 96, 208, 128, 183, 112, 209, 131, 15, 96, 210, 96, 153, 112, 211, 98, 241, 96, 212, 64, 123, 112, 217, 30, 70, 224, 217, 233, 91, 240, 8, 13, 205, 224, 8, 244, 146, 112, 9, 237, 175, 224, 10, 212, 116, 112, 11, 187, 28, 224, 12, 171, 27, 240, 13, 164, 57, 96, 14, 138, 253, 240, 15, 132, 69, 144, 16, 116, 54, 144, 16, 237, 100, 112, 17, 100, 39, 144, 18, 84, 24, 144, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 4, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 2, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 7, 8, 6, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 255, 255, 252, 140, 0, 0, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 9, 0, 0, 28, 32, 1, 13, 0, 0, 0, 0, 0, 9, 0, 0, 28, 32, 1, 18, 0, 0, 14, 16, 0, 23, 0, 0, 28, 32, 1, 18, 0, 0, 14, 16, 0, 23, 0, 0, 28, 32, 1, 18, 0, 0, 14, 16, 0, 23, 76, 77, 84, 0, 87, 69, 83, 84, 0, 87, 69, 84, 0, 87, 69, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Malta": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 169, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 155, 56, 248, 112, 155, 213, 204, 224, 156, 197, 203, 240, 157, 183, 0, 96, 158, 137, 254, 112, 159, 160, 28, 224, 160, 96, 165, 240, 161, 126, 173, 96, 162, 92, 55, 112, 163, 76, 26, 96, 200, 108, 53, 240, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 144, 226, 144, 208, 110, 94, 144, 209, 114, 22, 16, 210, 76, 210, 240, 211, 62, 49, 144, 212, 73, 210, 16, 213, 29, 247, 112, 214, 41, 151, 240, 214, 235, 128, 144, 216, 9, 150, 16, 249, 51, 181, 240, 249, 217, 196, 224, 251, 28, 210, 112, 251, 185, 180, 240, 252, 252, 180, 112, 253, 153, 150, 240, 254, 229, 208, 240, 255, 130, 179, 112, 0, 197, 178, 240, 1, 98, 149, 112, 2, 156, 90, 112, 3, 66, 119, 112, 4, 133, 118, 240, 5, 43, 147, 240, 6, 26, 51, 112, 7, 10, 36, 112, 8, 23, 22, 112, 8, 218, 52, 112, 9, 247, 20, 144, 10, 194, 13, 128, 11, 214, 246, 144, 12, 161, 239, 128, 13, 182, 216, 144, 14, 129, 209, 128, 15, 150, 186, 144, 16, 97, 179, 128, 17, 118, 156, 144, 18, 65, 149, 128, 19, 69, 91, 16, 20, 42, 178, 0, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 3, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 4, 3, 4, 3, 1, 2, 4, 3, 4, 3, 4, 3, 4, 2, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 13, 156, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 76, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Mariehamn": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 118, 0, 0, 0, 6, 0, 0, 0, 17, 128, 0, 0, 0, 164, 115, 111, 27, 203, 206, 81, 96, 204, 192, 229, 96, 21, 35, 221, 128, 22, 19, 206, 128, 23, 3, 191, 128, 23, 243, 176, 128, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 3, 2, 3, 2, 3, 2, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 0, 0, 23, 101, 0, 0, 0, 0, 23, 101, 0, 4, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 76, 77, 84, 0, 72, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 1, 1, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 51, 44, 77, 49, 48, 46, 53, 46, 48, 47, 52, 10}, - - "zoneinfo/Europe/Minsk": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 70, 0, 0, 0, 13, 0, 0, 0, 38, 128, 0, 0, 0, 170, 25, 170, 56, 181, 164, 25, 96, 202, 94, 112, 208, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 10, 2, 96, 21, 39, 167, 208, 22, 24, 220, 64, 23, 8, 219, 80, 23, 250, 15, 192, 24, 234, 14, 208, 25, 219, 67, 64, 26, 204, 147, 208, 27, 188, 160, 240, 28, 172, 145, 240, 29, 156, 130, 240, 30, 140, 115, 240, 31, 124, 100, 240, 32, 108, 85, 240, 33, 92, 70, 240, 34, 76, 55, 240, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 10, 240, 37, 158, 115, 80, 39, 245, 24, 112, 40, 229, 23, 128, 41, 213, 8, 128, 42, 196, 249, 128, 43, 180, 234, 128, 44, 164, 219, 128, 45, 148, 204, 128, 46, 132, 189, 128, 47, 116, 174, 128, 48, 100, 159, 128, 49, 93, 203, 0, 50, 114, 166, 0, 51, 61, 173, 0, 52, 82, 136, 0, 53, 29, 143, 0, 54, 50, 106, 0, 54, 253, 113, 0, 56, 27, 134, 128, 56, 221, 83, 0, 57, 251, 104, 128, 58, 189, 53, 0, 59, 219, 74, 128, 60, 166, 81, 128, 61, 187, 44, 128, 62, 134, 51, 128, 63, 155, 14, 128, 64, 102, 21, 128, 65, 132, 43, 0, 66, 69, 247, 128, 67, 100, 13, 0, 68, 37, 217, 128, 69, 67, 239, 0, 70, 5, 187, 128, 71, 35, 209, 0, 71, 238, 216, 0, 73, 3, 179, 0, 73, 206, 186, 0, 74, 227, 149, 0, 75, 174, 156, 0, 76, 204, 177, 128, 77, 142, 126, 0, 127, 255, 255, 255, 1, 2, 3, 6, 4, 5, 4, 5, 3, 7, 3, 7, 3, 7, 3, 7, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 3, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 12, 12, 0, 0, 25, 216, 0, 0, 0, 0, 25, 200, 0, 4, 0, 0, 28, 32, 0, 8, 0, 0, 42, 48, 0, 12, 0, 0, 14, 16, 0, 16, 0, 0, 28, 32, 1, 20, 0, 0, 28, 32, 1, 20, 0, 0, 56, 64, 1, 25, 0, 0, 42, 48, 0, 12, 0, 0, 56, 64, 1, 25, 0, 0, 42, 48, 1, 29, 0, 0, 28, 32, 0, 8, 0, 0, 42, 48, 0, 34, 76, 77, 84, 0, 77, 77, 84, 0, 69, 69, 84, 0, 77, 83, 75, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 77, 83, 68, 0, 69, 69, 83, 84, 0, 43, 48, 51, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 51, 62, 45, 51, 10}, - - "zoneinfo/Europe/Monaco": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 185, 0, 0, 0, 11, 0, 0, 0, 31, 128, 0, 0, 0, 145, 96, 80, 79, 155, 71, 120, 240, 155, 215, 44, 112, 156, 188, 145, 112, 157, 192, 72, 240, 158, 137, 254, 112, 159, 160, 42, 240, 160, 96, 165, 240, 161, 128, 12, 240, 162, 46, 18, 240, 163, 122, 76, 240, 164, 53, 129, 240, 165, 94, 35, 112, 166, 37, 53, 240, 167, 39, 155, 240, 168, 88, 38, 112, 169, 7, 125, 240, 169, 238, 52, 112, 170, 231, 95, 240, 171, 215, 80, 240, 172, 199, 65, 240, 173, 201, 167, 240, 174, 167, 35, 240, 175, 160, 79, 112, 176, 135, 5, 240, 177, 137, 107, 240, 178, 112, 34, 112, 179, 114, 136, 112, 180, 80, 4, 112, 181, 73, 47, 240, 182, 47, 230, 112, 183, 50, 76, 112, 184, 15, 200, 112, 184, 255, 185, 112, 185, 239, 170, 112, 186, 214, 96, 240, 187, 216, 198, 240, 188, 200, 183, 240, 189, 184, 168, 240, 190, 159, 95, 112, 191, 152, 138, 240, 192, 154, 240, 240, 193, 120, 108, 240, 194, 104, 93, 240, 195, 88, 78, 240, 196, 63, 5, 112, 197, 56, 48, 240, 198, 58, 150, 240, 199, 88, 172, 112, 199, 218, 9, 160, 202, 23, 91, 240, 202, 226, 84, 224, 203, 173, 105, 240, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 137, 241, 240, 209, 114, 22, 16, 210, 78, 64, 144, 11, 187, 57, 0, 12, 171, 27, 240, 13, 164, 99, 144, 14, 139, 26, 16, 15, 132, 69, 144, 16, 116, 54, 144, 17, 100, 39, 144, 18, 84, 24, 144, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 6, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 8, 7, 8, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 0, 0, 6, 236, 0, 0, 0, 0, 2, 49, 0, 4, 0, 0, 14, 16, 1, 8, 0, 0, 0, 0, 0, 13, 0, 0, 14, 16, 1, 8, 0, 0, 28, 32, 1, 17, 0, 0, 0, 0, 0, 13, 0, 0, 28, 32, 1, 22, 0, 0, 14, 16, 0, 27, 0, 0, 28, 32, 1, 22, 0, 0, 14, 16, 0, 27, 76, 77, 84, 0, 80, 77, 84, 0, 87, 69, 83, 84, 0, 87, 69, 84, 0, 87, 69, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Moscow": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, 78, 0, 0, 0, 17, 0, 0, 0, 38, 128, 0, 0, 0, 155, 95, 30, 199, 157, 62, 242, 121, 158, 42, 238, 249, 158, 247, 57, 105, 159, 132, 87, 249, 160, 216, 108, 233, 161, 0, 57, 128, 161, 60, 166, 64, 164, 16, 109, 192, 164, 61, 50, 176, 165, 21, 104, 176, 165, 61, 3, 192, 167, 30, 69, 80, 181, 164, 25, 96, 21, 39, 167, 208, 22, 24, 220, 64, 23, 8, 219, 80, 23, 250, 15, 192, 24, 234, 14, 208, 25, 219, 67, 64, 26, 204, 147, 208, 27, 188, 160, 240, 28, 172, 145, 240, 29, 156, 130, 240, 30, 140, 115, 240, 31, 124, 100, 240, 32, 108, 85, 240, 33, 92, 70, 240, 34, 76, 55, 240, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 10, 240, 38, 11, 251, 240, 39, 5, 39, 112, 39, 245, 24, 112, 40, 229, 23, 128, 41, 120, 191, 128, 41, 212, 250, 112, 42, 196, 235, 112, 43, 180, 220, 112, 44, 164, 205, 112, 45, 148, 190, 112, 46, 132, 175, 112, 47, 116, 160, 112, 48, 100, 145, 112, 49, 93, 188, 240, 50, 114, 151, 240, 51, 61, 158, 240, 52, 82, 121, 240, 53, 29, 128, 240, 54, 50, 91, 240, 54, 253, 98, 240, 56, 27, 120, 112, 56, 221, 68, 240, 57, 251, 90, 112, 58, 189, 38, 240, 59, 219, 60, 112, 60, 166, 67, 112, 61, 187, 30, 112, 62, 134, 37, 112, 63, 155, 0, 112, 64, 102, 7, 112, 65, 132, 28, 240, 66, 69, 233, 112, 67, 99, 254, 240, 68, 37, 203, 112, 69, 67, 224, 240, 70, 5, 173, 112, 71, 35, 194, 240, 71, 238, 201, 240, 73, 3, 164, 240, 73, 206, 171, 240, 74, 227, 134, 240, 75, 174, 141, 240, 76, 204, 163, 112, 77, 142, 111, 240, 84, 76, 29, 96, 1, 3, 2, 3, 4, 2, 4, 5, 6, 7, 8, 7, 6, 9, 6, 7, 6, 7, 6, 7, 6, 7, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 12, 13, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 14, 10, 0, 0, 35, 57, 0, 0, 0, 0, 35, 57, 0, 4, 0, 0, 49, 135, 1, 8, 0, 0, 35, 119, 0, 4, 0, 0, 63, 151, 1, 12, 0, 0, 56, 64, 1, 17, 0, 0, 42, 48, 0, 21, 0, 0, 56, 64, 1, 17, 0, 0, 70, 80, 1, 25, 0, 0, 28, 32, 0, 29, 0, 0, 42, 48, 0, 21, 0, 0, 56, 64, 1, 17, 0, 0, 42, 48, 1, 33, 0, 0, 28, 32, 0, 29, 0, 0, 56, 64, 0, 21, 0, 0, 56, 64, 1, 17, 0, 0, 42, 48, 0, 21, 76, 77, 84, 0, 77, 77, 84, 0, 77, 83, 84, 0, 77, 68, 83, 84, 0, 77, 83, 68, 0, 77, 83, 75, 0, 43, 48, 53, 0, 69, 69, 84, 0, 69, 69, 83, 84, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 77, 83, 75, 45, 51, 10}, - - "zoneinfo/Europe/Nicosia": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 5, 0, 0, 0, 13, 128, 0, 0, 0, 165, 119, 30, 184, 9, 237, 175, 224, 10, 221, 146, 208, 11, 250, 100, 224, 12, 190, 198, 80, 13, 164, 57, 96, 14, 138, 225, 208, 15, 132, 27, 96, 16, 117, 79, 208, 17, 99, 253, 96, 18, 83, 224, 80, 19, 77, 25, 224, 20, 51, 194, 80, 21, 35, 193, 96, 22, 19, 164, 80, 23, 3, 163, 96, 23, 243, 134, 80, 24, 227, 133, 96, 25, 211, 104, 80, 26, 195, 103, 96, 27, 188, 132, 208, 28, 172, 131, 224, 29, 156, 102, 208, 30, 140, 101, 224, 31, 124, 72, 208, 32, 108, 71, 224, 33, 92, 42, 208, 34, 76, 41, 224, 35, 60, 12, 208, 36, 44, 11, 224, 37, 27, 238, 208, 38, 11, 237, 224, 39, 5, 11, 80, 39, 245, 10, 96, 40, 228, 237, 80, 41, 212, 236, 96, 42, 196, 207, 80, 43, 180, 206, 96, 44, 164, 177, 80, 45, 148, 176, 96, 46, 132, 147, 80, 47, 116, 146, 96, 48, 100, 117, 80, 49, 93, 174, 224, 50, 77, 145, 208, 51, 61, 144, 224, 52, 45, 115, 208, 53, 29, 114, 224, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 31, 72, 0, 0, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 9, 0, 0, 28, 32, 0, 9, 0, 0, 42, 48, 1, 4, 76, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 51, 44, 77, 49, 48, 46, 53, 46, 48, 47, 52, 10}, - - "zoneinfo/Europe/Oslo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 155, 39, 227, 0, 155, 212, 123, 96, 200, 183, 77, 96, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 209, 114, 22, 16, 210, 98, 7, 16, 235, 175, 32, 144, 236, 168, 76, 16, 237, 152, 61, 16, 238, 136, 46, 16, 239, 120, 31, 16, 240, 104, 16, 16, 241, 88, 1, 16, 242, 71, 242, 16, 243, 55, 227, 16, 244, 39, 212, 16, 245, 23, 197, 16, 246, 16, 240, 144, 247, 47, 6, 16, 247, 240, 210, 144, 18, 206, 151, 240, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 10, 20, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 76, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Paris": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 184, 0, 0, 0, 13, 0, 0, 0, 31, 128, 0, 0, 0, 145, 96, 80, 139, 155, 71, 120, 240, 155, 215, 44, 112, 156, 188, 145, 112, 157, 192, 72, 240, 158, 137, 254, 112, 159, 160, 42, 240, 160, 96, 165, 240, 161, 128, 12, 240, 162, 46, 18, 240, 163, 122, 76, 240, 164, 53, 129, 240, 165, 94, 35, 112, 166, 37, 53, 240, 167, 39, 155, 240, 168, 88, 38, 112, 169, 7, 125, 240, 169, 238, 52, 112, 170, 231, 95, 240, 171, 215, 80, 240, 172, 199, 65, 240, 173, 201, 167, 240, 174, 167, 35, 240, 175, 160, 79, 112, 176, 135, 5, 240, 177, 137, 107, 240, 178, 112, 34, 112, 179, 114, 136, 112, 180, 80, 4, 112, 181, 73, 47, 240, 182, 47, 230, 112, 183, 50, 76, 112, 184, 15, 200, 112, 184, 255, 185, 112, 185, 239, 170, 112, 186, 214, 96, 240, 187, 216, 198, 240, 188, 200, 183, 240, 189, 184, 168, 240, 190, 159, 95, 112, 191, 152, 138, 240, 192, 154, 240, 240, 193, 120, 108, 240, 194, 104, 93, 240, 195, 88, 78, 240, 196, 63, 5, 112, 197, 56, 48, 240, 198, 58, 150, 240, 199, 88, 172, 112, 199, 218, 9, 160, 200, 108, 39, 224, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 79, 225, 224, 208, 137, 241, 240, 209, 114, 22, 16, 210, 78, 64, 144, 11, 187, 57, 0, 12, 171, 27, 240, 13, 164, 99, 144, 14, 139, 26, 16, 15, 132, 69, 144, 16, 116, 54, 144, 17, 100, 39, 144, 18, 84, 24, 144, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 5, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 4, 8, 6, 7, 6, 7, 9, 4, 9, 10, 8, 10, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 0, 0, 2, 49, 0, 0, 0, 0, 2, 49, 0, 4, 0, 0, 14, 16, 1, 8, 0, 0, 0, 0, 0, 13, 0, 0, 14, 16, 1, 8, 0, 0, 0, 0, 0, 13, 0, 0, 14, 16, 0, 17, 0, 0, 28, 32, 1, 21, 0, 0, 28, 32, 1, 21, 0, 0, 28, 32, 1, 26, 0, 0, 14, 16, 0, 17, 0, 0, 28, 32, 1, 21, 0, 0, 14, 16, 0, 17, 76, 77, 84, 0, 80, 77, 84, 0, 87, 69, 83, 84, 0, 87, 69, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 87, 69, 77, 84, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Podgorica": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 121, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 202, 2, 53, 224, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 208, 250, 1, 112, 209, 161, 140, 16, 210, 78, 64, 144, 24, 69, 95, 112, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 4, 2, 3, 2, 3, 2, 1, 3, 2, 1, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 19, 56, 0, 0, 0, 0, 14, 16, 0, 4, 0, 0, 14, 16, 0, 4, 0, 0, 28, 32, 1, 8, 0, 0, 28, 32, 1, 8, 0, 0, 28, 32, 1, 8, 0, 0, 14, 16, 0, 4, 76, 77, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Prague": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 155, 12, 23, 96, 155, 213, 218, 240, 156, 217, 174, 144, 157, 164, 181, 144, 158, 185, 144, 144, 159, 132, 151, 144, 200, 9, 113, 144, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 110, 94, 144, 209, 121, 255, 16, 210, 161, 79, 16, 211, 128, 28, 144, 212, 73, 210, 16, 213, 76, 56, 16, 214, 41, 180, 16, 215, 44, 26, 16, 216, 9, 150, 16, 217, 1, 112, 16, 217, 233, 120, 16, 16, 237, 100, 112, 17, 100, 39, 144, 18, 84, 24, 144, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 13, 136, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 80, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Riga": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 128, 0, 0, 0, 15, 0, 0, 0, 38, 128, 0, 0, 0, 158, 185, 135, 254, 159, 132, 142, 254, 160, 136, 70, 126, 160, 203, 130, 254, 173, 231, 241, 222, 200, 175, 100, 96, 202, 98, 101, 80, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 208, 144, 137, 112, 21, 39, 167, 208, 22, 24, 220, 64, 23, 8, 219, 80, 23, 250, 15, 192, 24, 234, 14, 208, 25, 219, 67, 64, 26, 204, 147, 208, 27, 188, 160, 240, 28, 172, 145, 240, 29, 156, 130, 240, 30, 140, 115, 240, 31, 124, 100, 240, 32, 108, 85, 240, 33, 92, 70, 240, 34, 76, 55, 240, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 25, 0, 38, 12, 10, 0, 39, 5, 53, 128, 39, 245, 38, 128, 40, 229, 23, 128, 41, 213, 8, 128, 42, 196, 249, 128, 43, 180, 234, 128, 44, 164, 219, 128, 45, 148, 204, 128, 46, 132, 189, 128, 47, 116, 174, 128, 48, 100, 159, 128, 49, 93, 203, 0, 50, 77, 188, 0, 50, 227, 234, 224, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 186, 239, 224, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 2, 1, 2, 1, 3, 4, 7, 5, 6, 5, 6, 5, 4, 8, 4, 8, 4, 8, 4, 8, 9, 10, 9, 10, 9, 10, 9, 10, 9, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 3, 13, 14, 13, 14, 13, 14, 3, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 0, 0, 22, 162, 0, 0, 0, 0, 22, 162, 0, 4, 0, 0, 36, 178, 1, 8, 0, 0, 28, 32, 0, 12, 0, 0, 42, 48, 0, 16, 0, 0, 14, 16, 0, 20, 0, 0, 28, 32, 1, 24, 0, 0, 28, 32, 1, 24, 0, 0, 56, 64, 1, 29, 0, 0, 42, 48, 0, 16, 0, 0, 56, 64, 1, 29, 0, 0, 42, 48, 1, 33, 0, 0, 28, 32, 0, 12, 0, 0, 42, 48, 1, 33, 0, 0, 28, 32, 0, 12, 76, 77, 84, 0, 82, 77, 84, 0, 76, 83, 84, 0, 69, 69, 84, 0, 77, 83, 75, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 77, 83, 68, 0, 69, 69, 83, 84, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 51, 44, 77, 49, 48, 46, 53, 46, 48, 47, 52, 10}, - - "zoneinfo/Europe/Rome": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 172, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 155, 56, 248, 112, 155, 213, 204, 224, 156, 197, 203, 240, 157, 183, 0, 96, 158, 137, 254, 112, 159, 160, 28, 224, 160, 96, 165, 240, 161, 126, 173, 96, 162, 92, 55, 112, 163, 76, 26, 96, 200, 108, 53, 240, 204, 231, 75, 16, 205, 169, 23, 144, 206, 130, 116, 224, 206, 162, 67, 16, 207, 146, 52, 16, 207, 227, 198, 224, 208, 110, 94, 144, 209, 114, 22, 16, 210, 76, 210, 240, 211, 62, 49, 144, 212, 73, 210, 16, 213, 29, 247, 112, 214, 41, 151, 240, 214, 235, 128, 144, 216, 9, 150, 16, 249, 51, 181, 240, 249, 217, 196, 224, 251, 28, 210, 112, 251, 185, 180, 240, 252, 252, 180, 112, 253, 153, 150, 240, 254, 229, 208, 240, 255, 130, 179, 112, 0, 197, 178, 240, 1, 98, 149, 112, 2, 156, 90, 112, 3, 66, 119, 112, 4, 133, 118, 240, 5, 43, 147, 240, 6, 110, 147, 112, 7, 11, 117, 240, 8, 69, 58, 240, 8, 235, 87, 240, 10, 46, 87, 112, 10, 203, 57, 240, 12, 14, 57, 112, 12, 171, 27, 240, 13, 228, 224, 240, 14, 138, 253, 240, 15, 205, 253, 112, 16, 116, 26, 112, 17, 173, 223, 112, 18, 83, 252, 112, 18, 206, 151, 240, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 4, 1, 3, 4, 1, 3, 1, 2, 4, 3, 4, 3, 4, 3, 4, 2, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 11, 180, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 82, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Samara": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 66, 0, 0, 0, 12, 0, 0, 0, 20, 128, 0, 0, 0, 161, 0, 57, 128, 181, 164, 11, 80, 21, 39, 153, 192, 22, 24, 206, 48, 23, 8, 205, 64, 23, 250, 1, 176, 24, 234, 0, 192, 25, 219, 53, 48, 26, 204, 133, 192, 27, 188, 146, 224, 28, 172, 131, 224, 29, 156, 116, 224, 30, 140, 101, 224, 31, 124, 86, 224, 32, 108, 71, 224, 33, 92, 56, 224, 34, 76, 41, 224, 35, 60, 26, 224, 36, 44, 11, 224, 37, 28, 10, 240, 38, 11, 251, 240, 39, 5, 39, 112, 39, 245, 24, 112, 40, 229, 23, 128, 41, 0, 199, 0, 41, 212, 236, 96, 42, 196, 221, 96, 43, 180, 206, 96, 44, 164, 191, 96, 45, 148, 176, 96, 46, 132, 161, 96, 47, 116, 146, 96, 48, 100, 131, 96, 49, 93, 174, 224, 50, 114, 137, 224, 51, 61, 144, 224, 52, 82, 107, 224, 53, 29, 114, 224, 54, 50, 77, 224, 54, 253, 84, 224, 56, 27, 106, 96, 56, 221, 54, 224, 57, 251, 76, 96, 58, 189, 24, 224, 59, 219, 46, 96, 60, 166, 53, 96, 61, 187, 16, 96, 62, 134, 23, 96, 63, 154, 242, 96, 64, 101, 249, 96, 65, 132, 14, 224, 66, 69, 219, 96, 67, 99, 240, 224, 68, 37, 189, 96, 69, 67, 210, 224, 70, 5, 159, 96, 71, 35, 180, 224, 71, 238, 187, 224, 73, 3, 150, 224, 73, 206, 157, 224, 74, 227, 120, 224, 75, 174, 127, 224, 76, 204, 163, 112, 77, 142, 111, 240, 127, 255, 255, 255, 0, 1, 2, 3, 2, 3, 2, 3, 2, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 6, 7, 8, 7, 2, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 4, 4, 0, 0, 46, 244, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 56, 64, 0, 8, 0, 0, 70, 80, 1, 12, 0, 0, 56, 64, 0, 8, 0, 0, 70, 80, 1, 12, 0, 0, 56, 64, 1, 8, 0, 0, 42, 48, 0, 4, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 16, 0, 0, 56, 64, 1, 8, 0, 0, 56, 64, 0, 8, 76, 77, 84, 0, 43, 48, 51, 0, 43, 48, 52, 0, 43, 48, 53, 0, 43, 48, 50, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 52, 62, 45, 52, 10}, - - "zoneinfo/Europe/San_Marino": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 172, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 155, 56, 248, 112, 155, 213, 204, 224, 156, 197, 203, 240, 157, 183, 0, 96, 158, 137, 254, 112, 159, 160, 28, 224, 160, 96, 165, 240, 161, 126, 173, 96, 162, 92, 55, 112, 163, 76, 26, 96, 200, 108, 53, 240, 204, 231, 75, 16, 205, 169, 23, 144, 206, 130, 116, 224, 206, 162, 67, 16, 207, 146, 52, 16, 207, 227, 198, 224, 208, 110, 94, 144, 209, 114, 22, 16, 210, 76, 210, 240, 211, 62, 49, 144, 212, 73, 210, 16, 213, 29, 247, 112, 214, 41, 151, 240, 214, 235, 128, 144, 216, 9, 150, 16, 249, 51, 181, 240, 249, 217, 196, 224, 251, 28, 210, 112, 251, 185, 180, 240, 252, 252, 180, 112, 253, 153, 150, 240, 254, 229, 208, 240, 255, 130, 179, 112, 0, 197, 178, 240, 1, 98, 149, 112, 2, 156, 90, 112, 3, 66, 119, 112, 4, 133, 118, 240, 5, 43, 147, 240, 6, 110, 147, 112, 7, 11, 117, 240, 8, 69, 58, 240, 8, 235, 87, 240, 10, 46, 87, 112, 10, 203, 57, 240, 12, 14, 57, 112, 12, 171, 27, 240, 13, 228, 224, 240, 14, 138, 253, 240, 15, 205, 253, 112, 16, 116, 26, 112, 17, 173, 223, 112, 18, 83, 252, 112, 18, 206, 151, 240, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 4, 1, 3, 4, 1, 3, 1, 2, 4, 3, 4, 3, 4, 3, 4, 2, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 11, 180, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 82, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Sarajevo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 121, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 202, 2, 53, 224, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 208, 250, 1, 112, 209, 161, 140, 16, 210, 78, 64, 144, 24, 69, 95, 112, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 4, 2, 3, 2, 3, 2, 1, 3, 2, 1, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 19, 56, 0, 0, 0, 0, 14, 16, 0, 4, 0, 0, 14, 16, 0, 4, 0, 0, 28, 32, 1, 8, 0, 0, 28, 32, 1, 8, 0, 0, 28, 32, 1, 8, 0, 0, 14, 16, 0, 4, 76, 77, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Saratov": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 66, 0, 0, 0, 9, 0, 0, 0, 16, 128, 0, 0, 0, 161, 0, 57, 128, 181, 164, 11, 80, 21, 39, 153, 192, 22, 24, 206, 48, 23, 8, 205, 64, 23, 250, 1, 176, 24, 234, 0, 192, 25, 219, 53, 48, 26, 204, 133, 192, 27, 188, 146, 224, 28, 172, 131, 224, 29, 156, 116, 224, 30, 140, 101, 224, 31, 124, 86, 224, 32, 108, 71, 224, 33, 92, 56, 224, 34, 76, 41, 224, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 10, 240, 38, 11, 251, 240, 39, 5, 39, 112, 39, 245, 24, 112, 41, 212, 236, 96, 42, 196, 235, 112, 43, 180, 220, 112, 44, 164, 205, 112, 45, 148, 190, 112, 46, 132, 175, 112, 47, 116, 160, 112, 48, 100, 145, 112, 49, 93, 188, 240, 50, 114, 151, 240, 51, 61, 158, 240, 52, 82, 121, 240, 53, 29, 128, 240, 54, 50, 91, 240, 54, 253, 98, 240, 56, 27, 120, 112, 56, 221, 68, 240, 57, 251, 90, 112, 58, 189, 38, 240, 59, 219, 60, 112, 60, 166, 67, 112, 61, 187, 30, 112, 62, 134, 37, 112, 63, 155, 0, 112, 64, 102, 7, 112, 65, 132, 28, 240, 66, 69, 233, 112, 67, 99, 254, 240, 68, 37, 203, 112, 69, 67, 224, 240, 70, 5, 173, 112, 71, 35, 194, 240, 71, 238, 201, 240, 73, 3, 164, 240, 73, 206, 171, 240, 74, 227, 134, 240, 75, 174, 141, 240, 76, 204, 163, 112, 77, 142, 111, 240, 84, 76, 29, 96, 88, 67, 78, 112, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 6, 7, 6, 7, 6, 7, 4, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 4, 7, 4, 4, 0, 0, 43, 50, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 0, 12, 0, 0, 56, 64, 0, 12, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 1, 12, 0, 0, 42, 48, 0, 4, 0, 0, 56, 64, 0, 12, 76, 77, 84, 0, 43, 48, 51, 0, 43, 48, 53, 0, 43, 48, 52, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 52, 62, 45, 52, 10}, - - "zoneinfo/Europe/Simferopol": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 15, 0, 0, 0, 15, 0, 0, 0, 0, 0, 0, 0, 77, 0, 0, 0, 15, 0, 0, 0, 34, 128, 0, 0, 0, 170, 25, 164, 32, 181, 164, 25, 96, 203, 4, 141, 208, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 207, 159, 56, 224, 21, 39, 167, 208, 22, 24, 220, 64, 23, 8, 219, 80, 23, 250, 15, 192, 24, 234, 14, 208, 25, 219, 67, 64, 26, 204, 147, 208, 27, 188, 160, 240, 28, 172, 145, 240, 29, 156, 130, 240, 30, 140, 115, 240, 31, 124, 100, 240, 32, 108, 85, 240, 33, 92, 70, 240, 34, 76, 55, 240, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 10, 240, 37, 158, 115, 80, 38, 141, 46, 240, 41, 212, 236, 96, 42, 196, 207, 80, 43, 180, 206, 96, 44, 164, 177, 80, 45, 148, 176, 96, 45, 194, 198, 208, 46, 132, 133, 64, 47, 116, 132, 80, 48, 100, 103, 64, 49, 93, 160, 208, 50, 114, 166, 0, 50, 201, 126, 208, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 94, 128, 84, 76, 29, 96, 1, 2, 3, 6, 4, 5, 4, 5, 3, 7, 3, 7, 3, 7, 3, 7, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 3, 2, 10, 2, 10, 2, 10, 7, 3, 7, 3, 9, 8, 3, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 13, 8, 0, 0, 31, 248, 0, 0, 0, 0, 31, 224, 0, 4, 0, 0, 28, 32, 0, 8, 0, 0, 42, 48, 0, 12, 0, 0, 14, 16, 0, 16, 0, 0, 28, 32, 1, 20, 0, 0, 28, 32, 1, 20, 0, 0, 56, 64, 1, 25, 0, 0, 42, 48, 0, 12, 0, 0, 56, 64, 1, 25, 0, 0, 42, 48, 1, 29, 0, 0, 42, 48, 1, 29, 0, 0, 28, 32, 0, 8, 0, 0, 56, 64, 0, 12, 0, 0, 42, 48, 0, 12, 76, 77, 84, 0, 83, 77, 84, 0, 69, 69, 84, 0, 77, 83, 75, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 77, 83, 68, 0, 69, 69, 83, 84, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 10, 77, 83, 75, 45, 51, 10}, - - "zoneinfo/Europe/Skopje": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 121, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 202, 2, 53, 224, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 208, 250, 1, 112, 209, 161, 140, 16, 210, 78, 64, 144, 24, 69, 95, 112, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 4, 2, 3, 2, 3, 2, 1, 3, 2, 1, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 19, 56, 0, 0, 0, 0, 14, 16, 0, 4, 0, 0, 14, 16, 0, 4, 0, 0, 28, 32, 1, 8, 0, 0, 28, 32, 1, 8, 0, 0, 28, 32, 1, 8, 0, 0, 14, 16, 0, 4, 76, 77, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Sofia": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 0, 0, 0, 10, 0, 0, 0, 0, 0, 0, 0, 127, 0, 0, 0, 10, 0, 0, 0, 22, 128, 0, 0, 0, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 208, 250, 1, 112, 209, 114, 36, 32, 17, 99, 239, 80, 18, 85, 63, 224, 19, 77, 11, 208, 20, 53, 33, 224, 21, 44, 237, 208, 22, 19, 192, 112, 23, 12, 207, 208, 23, 243, 176, 128, 24, 227, 161, 128, 25, 211, 146, 128, 26, 195, 131, 128, 27, 188, 175, 0, 28, 172, 160, 0, 29, 156, 145, 0, 30, 140, 130, 0, 31, 124, 115, 0, 32, 108, 100, 0, 33, 92, 85, 0, 34, 76, 70, 0, 35, 60, 55, 0, 36, 44, 40, 0, 37, 28, 25, 0, 38, 12, 10, 0, 39, 5, 53, 128, 39, 127, 180, 224, 39, 245, 10, 96, 40, 228, 237, 80, 41, 212, 236, 96, 42, 196, 207, 80, 43, 180, 206, 96, 44, 164, 177, 80, 45, 148, 176, 96, 46, 132, 147, 80, 47, 116, 146, 96, 48, 100, 117, 80, 49, 93, 174, 224, 50, 114, 123, 208, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 2, 3, 2, 3, 2, 4, 1, 5, 1, 5, 1, 5, 1, 5, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 5, 1, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 0, 0, 27, 104, 0, 0, 0, 0, 28, 32, 0, 4, 0, 0, 14, 16, 0, 8, 0, 0, 28, 32, 1, 12, 0, 0, 14, 16, 0, 8, 0, 0, 42, 48, 1, 17, 0, 0, 28, 32, 0, 4, 0, 0, 42, 48, 1, 17, 0, 0, 42, 48, 1, 17, 0, 0, 28, 32, 0, 4, 73, 77, 84, 0, 69, 69, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 69, 69, 83, 84, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 51, 44, 77, 49, 48, 46, 53, 46, 48, 47, 52, 10}, - - "zoneinfo/Europe/Stockholm": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 119, 0, 0, 0, 5, 0, 0, 0, 13, 128, 0, 0, 0, 155, 30, 140, 96, 155, 213, 218, 240, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 2, 1, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 0, 0, 14, 30, 0, 0, 0, 0, 14, 16, 0, 4, 0, 0, 28, 32, 1, 8, 0, 0, 28, 32, 1, 8, 0, 0, 14, 16, 0, 4, 83, 69, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Tallinn": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 124, 0, 0, 0, 16, 0, 0, 0, 34, 128, 0, 0, 0, 158, 89, 45, 204, 158, 185, 144, 144, 159, 132, 151, 144, 161, 0, 43, 112, 164, 115, 111, 76, 200, 176, 181, 224, 202, 198, 151, 80, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 116, 203, 224, 21, 39, 167, 208, 22, 24, 220, 64, 23, 8, 219, 80, 23, 250, 15, 192, 24, 234, 14, 208, 25, 219, 67, 64, 26, 204, 147, 208, 27, 188, 160, 240, 28, 172, 145, 240, 29, 156, 130, 240, 30, 140, 115, 240, 31, 124, 100, 240, 32, 108, 85, 240, 33, 92, 70, 240, 34, 76, 55, 240, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 25, 0, 38, 12, 10, 0, 39, 5, 53, 128, 39, 245, 38, 128, 40, 229, 23, 128, 41, 213, 8, 128, 42, 196, 249, 128, 43, 180, 234, 128, 44, 164, 219, 128, 45, 148, 204, 128, 46, 132, 189, 128, 47, 116, 174, 128, 48, 100, 159, 128, 49, 93, 203, 0, 50, 114, 166, 0, 51, 61, 173, 0, 52, 82, 136, 0, 53, 29, 143, 0, 54, 6, 190, 80, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 4, 2, 3, 1, 5, 6, 7, 3, 2, 3, 2, 6, 8, 6, 8, 6, 8, 6, 8, 9, 10, 9, 10, 9, 10, 9, 10, 9, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 15, 13, 14, 5, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 14, 13, 0, 0, 23, 52, 0, 0, 0, 0, 23, 52, 0, 4, 0, 0, 28, 32, 1, 8, 0, 0, 14, 16, 0, 13, 0, 0, 14, 16, 0, 13, 0, 0, 28, 32, 0, 17, 0, 0, 42, 48, 0, 21, 0, 0, 28, 32, 1, 8, 0, 0, 56, 64, 1, 25, 0, 0, 42, 48, 0, 21, 0, 0, 56, 64, 1, 25, 0, 0, 42, 48, 1, 29, 0, 0, 28, 32, 0, 17, 0, 0, 28, 32, 0, 17, 0, 0, 42, 48, 1, 29, 0, 0, 42, 48, 1, 29, 76, 77, 84, 0, 84, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 69, 69, 84, 0, 77, 83, 75, 0, 77, 83, 68, 0, 69, 69, 83, 84, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 51, 44, 77, 49, 48, 46, 53, 46, 48, 47, 52, 10}, - - "zoneinfo/Europe/Tirane": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 134, 0, 0, 0, 5, 0, 0, 0, 13, 128, 0, 0, 0, 150, 170, 52, 104, 200, 109, 135, 112, 204, 231, 75, 16, 205, 169, 23, 144, 205, 184, 233, 144, 8, 40, 57, 240, 8, 239, 62, 96, 10, 5, 120, 240, 10, 208, 113, 224, 11, 233, 79, 112, 12, 180, 72, 96, 13, 210, 107, 240, 14, 148, 42, 96, 15, 176, 252, 112, 16, 116, 12, 96, 17, 144, 222, 112, 18, 83, 238, 96, 19, 112, 192, 112, 20, 59, 185, 96, 21, 72, 185, 112, 22, 19, 178, 96, 23, 49, 213, 240, 23, 252, 206, 224, 25, 0, 148, 112, 25, 219, 95, 96, 26, 204, 175, 240, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 0, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 0, 0, 18, 152, 0, 0, 0, 0, 14, 16, 0, 4, 0, 0, 28, 32, 1, 8, 0, 0, 14, 16, 0, 4, 0, 0, 28, 32, 1, 8, 76, 77, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Tiraspol": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 16, 0, 0, 0, 16, 0, 0, 0, 0, 0, 0, 0, 142, 0, 0, 0, 16, 0, 0, 0, 38, 128, 0, 0, 0, 158, 107, 159, 12, 183, 176, 210, 8, 185, 62, 243, 96, 185, 239, 156, 96, 186, 223, 141, 96, 187, 207, 126, 96, 188, 200, 169, 224, 189, 184, 154, 224, 190, 168, 139, 224, 191, 152, 124, 224, 192, 136, 109, 224, 193, 120, 94, 224, 194, 104, 79, 224, 195, 88, 64, 224, 196, 72, 49, 224, 197, 56, 34, 224, 198, 40, 19, 224, 199, 24, 4, 224, 200, 188, 147, 96, 202, 119, 125, 80, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 78, 144, 96, 21, 39, 167, 208, 22, 24, 220, 64, 23, 8, 219, 80, 23, 250, 15, 192, 24, 234, 14, 208, 25, 219, 67, 64, 26, 204, 147, 208, 27, 188, 160, 240, 28, 172, 145, 240, 29, 156, 130, 240, 30, 140, 115, 240, 31, 124, 100, 240, 32, 108, 85, 240, 33, 92, 70, 240, 34, 76, 55, 240, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 10, 240, 38, 11, 251, 240, 38, 67, 76, 224, 39, 5, 53, 128, 39, 245, 38, 128, 40, 229, 23, 128, 41, 96, 232, 96, 41, 212, 236, 96, 42, 196, 207, 80, 43, 180, 206, 96, 44, 164, 177, 80, 45, 148, 176, 96, 46, 132, 147, 80, 47, 116, 146, 96, 48, 100, 117, 80, 49, 93, 174, 224, 50, 114, 123, 208, 51, 61, 173, 0, 52, 82, 136, 0, 53, 29, 143, 0, 54, 50, 106, 0, 54, 253, 113, 0, 56, 27, 134, 128, 56, 221, 83, 0, 57, 251, 104, 128, 58, 189, 53, 0, 59, 219, 74, 128, 60, 166, 81, 128, 61, 187, 44, 128, 62, 134, 51, 128, 63, 155, 14, 128, 64, 102, 21, 128, 65, 132, 43, 0, 66, 69, 247, 128, 67, 100, 13, 0, 68, 37, 217, 128, 69, 67, 239, 0, 70, 5, 187, 128, 71, 35, 209, 0, 71, 238, 216, 0, 73, 3, 179, 0, 73, 206, 186, 0, 74, 227, 149, 0, 75, 174, 156, 0, 76, 204, 177, 128, 77, 142, 126, 0, 78, 172, 147, 128, 79, 110, 96, 0, 80, 140, 117, 128, 81, 87, 124, 128, 82, 108, 87, 128, 83, 55, 94, 128, 84, 76, 57, 128, 85, 23, 64, 128, 86, 44, 27, 128, 86, 247, 34, 128, 88, 21, 56, 0, 88, 215, 4, 128, 89, 245, 26, 0, 90, 182, 230, 128, 91, 212, 252, 0, 92, 160, 3, 0, 93, 180, 222, 0, 94, 127, 229, 0, 95, 148, 192, 0, 96, 95, 199, 0, 97, 125, 220, 128, 98, 63, 169, 0, 99, 93, 190, 128, 100, 31, 139, 0, 101, 61, 160, 128, 102, 8, 167, 128, 103, 29, 130, 128, 103, 232, 137, 128, 104, 253, 100, 128, 105, 200, 107, 128, 106, 221, 70, 128, 107, 168, 77, 128, 108, 198, 99, 0, 109, 136, 47, 128, 110, 166, 69, 0, 111, 104, 17, 128, 112, 134, 39, 0, 113, 81, 46, 0, 114, 102, 9, 0, 115, 49, 16, 0, 116, 69, 235, 0, 117, 16, 242, 0, 118, 47, 7, 128, 118, 240, 212, 0, 120, 14, 233, 128, 120, 208, 182, 0, 121, 238, 203, 128, 122, 176, 152, 0, 123, 206, 173, 128, 124, 153, 180, 128, 125, 174, 143, 128, 126, 121, 150, 128, 127, 142, 113, 128, 1, 2, 5, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 6, 9, 7, 8, 7, 8, 11, 10, 11, 10, 11, 10, 11, 10, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 6, 4, 3, 4, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 0, 0, 27, 8, 0, 0, 0, 0, 26, 244, 0, 4, 0, 0, 24, 120, 0, 8, 0, 0, 42, 48, 1, 12, 0, 0, 28, 32, 0, 17, 0, 0, 28, 32, 0, 17, 0, 0, 42, 48, 1, 12, 0, 0, 14, 16, 0, 21, 0, 0, 28, 32, 1, 25, 0, 0, 28, 32, 1, 25, 0, 0, 56, 64, 1, 30, 0, 0, 42, 48, 0, 34, 0, 0, 42, 48, 0, 34, 0, 0, 56, 64, 1, 30, 0, 0, 42, 48, 1, 12, 0, 0, 28, 32, 0, 17, 76, 77, 84, 0, 67, 77, 84, 0, 66, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 77, 83, 68, 0, 77, 83, 75, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Ulyanovsk": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 12, 0, 0, 0, 12, 0, 0, 0, 0, 0, 0, 0, 68, 0, 0, 0, 12, 0, 0, 0, 20, 128, 0, 0, 0, 161, 0, 57, 128, 181, 164, 11, 80, 21, 39, 153, 192, 22, 24, 206, 48, 23, 8, 205, 64, 23, 250, 1, 176, 24, 234, 0, 192, 25, 219, 53, 48, 26, 204, 133, 192, 27, 188, 146, 224, 28, 172, 131, 224, 29, 156, 116, 224, 30, 140, 101, 224, 31, 124, 86, 224, 32, 108, 71, 224, 33, 92, 56, 224, 34, 76, 41, 224, 35, 60, 26, 224, 36, 44, 11, 224, 37, 28, 10, 240, 38, 11, 251, 240, 39, 5, 39, 112, 39, 245, 24, 112, 40, 229, 23, 128, 41, 120, 191, 128, 41, 212, 250, 112, 42, 196, 235, 112, 43, 180, 220, 112, 44, 164, 205, 112, 45, 148, 190, 112, 46, 132, 175, 112, 47, 116, 160, 112, 48, 100, 145, 112, 49, 93, 188, 240, 50, 114, 151, 240, 51, 61, 158, 240, 52, 82, 121, 240, 53, 29, 128, 240, 54, 50, 91, 240, 54, 253, 98, 240, 56, 27, 120, 112, 56, 221, 68, 240, 57, 251, 90, 112, 58, 189, 38, 240, 59, 219, 60, 112, 60, 166, 67, 112, 61, 187, 30, 112, 62, 134, 37, 112, 63, 155, 0, 112, 64, 102, 7, 112, 65, 132, 28, 240, 66, 69, 233, 112, 67, 99, 254, 240, 68, 37, 203, 112, 69, 67, 224, 240, 70, 5, 173, 112, 71, 35, 194, 240, 71, 238, 201, 240, 73, 3, 164, 240, 73, 206, 171, 240, 74, 227, 134, 240, 75, 174, 141, 240, 76, 204, 163, 112, 77, 142, 111, 240, 84, 76, 29, 96, 86, 247, 20, 112, 127, 255, 255, 255, 0, 1, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 6, 7, 6, 7, 8, 9, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 4, 7, 4, 4, 0, 0, 45, 96, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 0, 12, 0, 0, 56, 64, 0, 12, 0, 0, 70, 80, 1, 8, 0, 0, 56, 64, 1, 12, 0, 0, 42, 48, 0, 4, 0, 0, 42, 48, 1, 4, 0, 0, 28, 32, 0, 16, 0, 0, 56, 64, 1, 12, 0, 0, 56, 64, 0, 12, 76, 77, 84, 0, 43, 48, 51, 0, 43, 48, 53, 0, 43, 48, 52, 0, 43, 48, 50, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 52, 62, 45, 52, 10}, - - "zoneinfo/Europe/Uzhgorod": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 122, 0, 0, 0, 13, 0, 0, 0, 30, 128, 0, 0, 0, 200, 9, 113, 144, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 128, 169, 96, 208, 161, 158, 224, 209, 229, 253, 240, 21, 39, 167, 208, 22, 24, 220, 64, 23, 8, 219, 80, 23, 250, 15, 192, 24, 234, 14, 208, 25, 219, 67, 64, 26, 204, 147, 208, 27, 188, 160, 240, 28, 172, 145, 240, 29, 156, 130, 240, 30, 140, 115, 240, 31, 124, 100, 240, 32, 108, 85, 240, 33, 92, 70, 240, 34, 76, 55, 240, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 10, 240, 37, 158, 115, 80, 38, 141, 46, 240, 39, 245, 66, 160, 41, 212, 236, 96, 42, 196, 207, 80, 43, 180, 206, 96, 44, 164, 177, 80, 45, 148, 176, 96, 46, 132, 147, 80, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 2, 3, 2, 3, 2, 4, 1, 6, 5, 6, 5, 6, 5, 6, 5, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 6, 1, 9, 10, 9, 10, 9, 10, 9, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 0, 0, 20, 232, 0, 0, 0, 0, 14, 16, 0, 4, 0, 0, 28, 32, 1, 8, 0, 0, 14, 16, 0, 4, 0, 0, 28, 32, 1, 8, 0, 0, 56, 64, 1, 13, 0, 0, 42, 48, 0, 17, 0, 0, 42, 48, 0, 17, 0, 0, 56, 64, 1, 13, 0, 0, 28, 32, 0, 21, 0, 0, 42, 48, 1, 25, 0, 0, 42, 48, 1, 25, 0, 0, 28, 32, 0, 21, 76, 77, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 77, 83, 68, 0, 77, 83, 75, 0, 69, 69, 84, 0, 69, 69, 83, 84, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 51, 44, 77, 49, 48, 46, 53, 46, 48, 47, 52, 10}, - - "zoneinfo/Europe/Vaduz": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 119, 0, 0, 0, 5, 0, 0, 0, 13, 128, 0, 0, 0, 202, 23, 106, 0, 202, 226, 113, 0, 203, 247, 76, 0, 204, 194, 83, 0, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 0, 0, 6, 250, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 66, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Vatican": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 172, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 155, 56, 248, 112, 155, 213, 204, 224, 156, 197, 203, 240, 157, 183, 0, 96, 158, 137, 254, 112, 159, 160, 28, 224, 160, 96, 165, 240, 161, 126, 173, 96, 162, 92, 55, 112, 163, 76, 26, 96, 200, 108, 53, 240, 204, 231, 75, 16, 205, 169, 23, 144, 206, 130, 116, 224, 206, 162, 67, 16, 207, 146, 52, 16, 207, 227, 198, 224, 208, 110, 94, 144, 209, 114, 22, 16, 210, 76, 210, 240, 211, 62, 49, 144, 212, 73, 210, 16, 213, 29, 247, 112, 214, 41, 151, 240, 214, 235, 128, 144, 216, 9, 150, 16, 249, 51, 181, 240, 249, 217, 196, 224, 251, 28, 210, 112, 251, 185, 180, 240, 252, 252, 180, 112, 253, 153, 150, 240, 254, 229, 208, 240, 255, 130, 179, 112, 0, 197, 178, 240, 1, 98, 149, 112, 2, 156, 90, 112, 3, 66, 119, 112, 4, 133, 118, 240, 5, 43, 147, 240, 6, 110, 147, 112, 7, 11, 117, 240, 8, 69, 58, 240, 8, 235, 87, 240, 10, 46, 87, 112, 10, 203, 57, 240, 12, 14, 57, 112, 12, 171, 27, 240, 13, 228, 224, 240, 14, 138, 253, 240, 15, 205, 253, 112, 16, 116, 26, 112, 17, 173, 223, 112, 18, 83, 252, 112, 18, 206, 151, 240, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 4, 1, 3, 4, 1, 3, 1, 2, 4, 3, 4, 3, 4, 3, 4, 2, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 11, 180, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 82, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Vienna": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 141, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 155, 12, 23, 96, 155, 213, 218, 240, 156, 217, 174, 144, 157, 164, 181, 144, 158, 185, 144, 144, 159, 132, 151, 144, 161, 242, 191, 112, 162, 112, 26, 16, 163, 68, 91, 144, 200, 9, 113, 144, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 209, 114, 22, 16, 209, 127, 69, 16, 210, 219, 52, 240, 211, 99, 27, 144, 212, 73, 210, 16, 213, 57, 195, 16, 214, 41, 180, 16, 215, 44, 26, 16, 216, 9, 150, 16, 19, 77, 39, 240, 20, 51, 208, 96, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 3, 4, 3, 4, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 2, 3, 4, 3, 4, 3, 4, 1, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 15, 81, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 76, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Vilnius": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 18, 0, 0, 0, 18, 0, 0, 0, 0, 0, 0, 0, 122, 0, 0, 0, 18, 0, 0, 0, 38, 128, 0, 0, 0, 156, 79, 31, 80, 161, 133, 74, 152, 162, 241, 48, 240, 163, 102, 120, 96, 200, 172, 207, 112, 202, 89, 42, 208, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 48, 61, 224, 21, 39, 167, 208, 22, 24, 220, 64, 23, 8, 219, 80, 23, 250, 15, 192, 24, 234, 14, 208, 25, 219, 67, 64, 26, 204, 147, 208, 27, 188, 160, 240, 28, 172, 145, 240, 29, 156, 130, 240, 30, 140, 115, 240, 31, 124, 100, 240, 32, 108, 85, 240, 33, 92, 70, 240, 34, 76, 55, 240, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 25, 0, 38, 12, 10, 0, 39, 5, 53, 128, 39, 245, 38, 128, 40, 229, 23, 128, 41, 213, 8, 128, 42, 196, 249, 128, 43, 180, 234, 128, 44, 164, 219, 128, 45, 148, 204, 128, 46, 132, 189, 128, 47, 116, 174, 128, 48, 100, 159, 128, 49, 93, 203, 0, 50, 114, 166, 0, 51, 61, 173, 0, 52, 82, 136, 0, 52, 170, 192, 96, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 62, 18, 19, 96, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 2, 3, 4, 3, 5, 8, 6, 7, 6, 7, 5, 9, 5, 9, 5, 9, 5, 9, 10, 11, 10, 11, 10, 11, 10, 11, 10, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 12, 13, 4, 14, 15, 14, 16, 4, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 17, 16, 0, 0, 23, 188, 0, 0, 0, 0, 19, 176, 0, 4, 0, 0, 22, 104, 0, 8, 0, 0, 14, 16, 0, 12, 0, 0, 28, 32, 0, 16, 0, 0, 42, 48, 0, 20, 0, 0, 14, 16, 0, 12, 0, 0, 28, 32, 1, 24, 0, 0, 28, 32, 1, 24, 0, 0, 56, 64, 1, 29, 0, 0, 42, 48, 0, 20, 0, 0, 56, 64, 1, 29, 0, 0, 42, 48, 1, 33, 0, 0, 28, 32, 0, 16, 0, 0, 28, 32, 1, 24, 0, 0, 14, 16, 0, 12, 0, 0, 28, 32, 0, 16, 0, 0, 42, 48, 1, 33, 76, 77, 84, 0, 87, 77, 84, 0, 75, 77, 84, 0, 67, 69, 84, 0, 69, 69, 84, 0, 77, 83, 75, 0, 67, 69, 83, 84, 0, 77, 83, 68, 0, 69, 69, 83, 84, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 51, 44, 77, 49, 48, 46, 53, 46, 48, 47, 52, 10}, - - "zoneinfo/Europe/Volgograd": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 65, 0, 0, 0, 8, 0, 0, 0, 16, 128, 0, 0, 0, 161, 245, 70, 220, 181, 164, 11, 80, 21, 39, 153, 192, 22, 24, 206, 48, 23, 8, 205, 64, 23, 250, 1, 176, 24, 234, 0, 192, 25, 219, 53, 48, 26, 204, 133, 192, 27, 188, 146, 224, 28, 172, 131, 224, 29, 156, 116, 224, 30, 140, 101, 224, 31, 124, 86, 224, 32, 108, 71, 224, 33, 92, 56, 224, 34, 76, 41, 224, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 10, 240, 38, 11, 251, 240, 39, 5, 39, 112, 39, 245, 24, 112, 41, 212, 236, 96, 42, 196, 235, 112, 43, 180, 220, 112, 44, 164, 205, 112, 45, 148, 190, 112, 46, 132, 175, 112, 47, 116, 160, 112, 48, 100, 145, 112, 49, 93, 188, 240, 50, 114, 151, 240, 51, 61, 158, 240, 52, 82, 121, 240, 53, 29, 128, 240, 54, 50, 91, 240, 54, 253, 98, 240, 56, 27, 120, 112, 56, 221, 68, 240, 57, 251, 90, 112, 58, 189, 38, 240, 59, 219, 60, 112, 60, 166, 67, 112, 61, 187, 30, 112, 62, 134, 37, 112, 63, 155, 0, 112, 64, 102, 7, 112, 65, 132, 28, 240, 66, 69, 233, 112, 67, 99, 254, 240, 68, 37, 203, 112, 69, 67, 224, 240, 70, 5, 173, 112, 71, 35, 194, 240, 71, 238, 201, 240, 73, 3, 164, 240, 73, 206, 171, 240, 74, 227, 134, 240, 75, 174, 141, 240, 76, 204, 163, 112, 77, 142, 111, 240, 84, 76, 29, 96, 127, 255, 255, 255, 0, 1, 2, 3, 2, 3, 2, 3, 2, 3, 4, 5, 4, 5, 4, 5, 4, 6, 7, 6, 7, 6, 7, 4, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 4, 7, 7, 0, 0, 41, 164, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 56, 64, 0, 8, 0, 0, 70, 80, 1, 12, 0, 0, 56, 64, 0, 8, 0, 0, 70, 80, 1, 12, 0, 0, 56, 64, 1, 8, 0, 0, 42, 48, 0, 4, 76, 77, 84, 0, 43, 48, 51, 0, 43, 48, 52, 0, 43, 48, 53, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 51, 62, 45, 51, 10}, - - "zoneinfo/Europe/Warsaw": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 168, 0, 0, 0, 11, 0, 0, 0, 26, 128, 0, 0, 0, 153, 168, 42, 208, 155, 12, 23, 96, 155, 213, 218, 240, 156, 217, 174, 144, 157, 164, 181, 144, 158, 185, 144, 144, 159, 132, 151, 144, 160, 154, 182, 0, 161, 101, 189, 0, 166, 125, 124, 96, 200, 118, 222, 16, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 128, 169, 96, 208, 132, 186, 0, 209, 149, 146, 112, 210, 138, 187, 96, 211, 98, 255, 112, 212, 75, 35, 144, 213, 94, 173, 16, 214, 41, 180, 16, 215, 44, 26, 16, 216, 9, 150, 16, 217, 2, 193, 144, 217, 233, 120, 16, 232, 84, 210, 0, 232, 241, 180, 128, 233, 225, 165, 128, 234, 209, 150, 128, 236, 20, 150, 0, 236, 186, 179, 0, 237, 170, 164, 0, 238, 154, 149, 0, 239, 212, 90, 0, 240, 122, 119, 0, 241, 180, 60, 0, 242, 90, 89, 0, 243, 148, 30, 0, 244, 58, 59, 0, 245, 125, 58, 128, 246, 26, 29, 0, 13, 42, 253, 112, 13, 164, 85, 128, 14, 139, 12, 0, 15, 132, 55, 128, 16, 116, 40, 128, 17, 100, 25, 128, 18, 84, 10, 128, 19, 77, 54, 0, 20, 51, 236, 128, 21, 35, 221, 128, 22, 19, 206, 128, 23, 3, 191, 128, 23, 243, 176, 128, 24, 227, 161, 128, 25, 211, 146, 128, 26, 195, 131, 128, 27, 188, 175, 0, 28, 172, 160, 0, 29, 156, 145, 0, 30, 140, 130, 0, 31, 124, 115, 0, 32, 108, 100, 0, 33, 92, 85, 0, 33, 218, 214, 240, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 3, 2, 3, 4, 5, 4, 8, 6, 7, 3, 2, 5, 4, 5, 4, 2, 3, 2, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 3, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 0, 0, 19, 176, 0, 0, 0, 0, 19, 176, 0, 4, 0, 0, 28, 32, 1, 8, 0, 0, 14, 16, 0, 13, 0, 0, 28, 32, 1, 8, 0, 0, 14, 16, 0, 13, 0, 0, 42, 48, 1, 17, 0, 0, 28, 32, 0, 22, 0, 0, 28, 32, 0, 22, 0, 0, 28, 32, 1, 8, 0, 0, 14, 16, 0, 13, 76, 77, 84, 0, 87, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Zagreb": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 121, 0, 0, 0, 7, 0, 0, 0, 13, 128, 0, 0, 0, 202, 2, 53, 224, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 208, 250, 1, 112, 209, 161, 140, 16, 210, 78, 64, 144, 24, 69, 95, 112, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 4, 2, 3, 2, 3, 2, 1, 3, 2, 1, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 0, 0, 19, 56, 0, 0, 0, 0, 14, 16, 0, 4, 0, 0, 14, 16, 0, 4, 0, 0, 28, 32, 1, 8, 0, 0, 28, 32, 1, 8, 0, 0, 28, 32, 1, 8, 0, 0, 14, 16, 0, 4, 76, 77, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Europe/Zaporozhye": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 13, 0, 0, 0, 13, 0, 0, 0, 0, 0, 0, 0, 122, 0, 0, 0, 13, 0, 0, 0, 36, 128, 0, 0, 0, 170, 25, 163, 48, 181, 164, 25, 96, 202, 170, 231, 208, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 206, 189, 214, 112, 21, 39, 167, 208, 22, 24, 220, 64, 23, 8, 219, 80, 23, 250, 15, 192, 24, 234, 14, 208, 25, 219, 67, 64, 26, 204, 147, 208, 27, 188, 160, 240, 28, 172, 145, 240, 29, 156, 130, 240, 30, 140, 115, 240, 31, 124, 100, 240, 32, 108, 85, 240, 33, 92, 70, 240, 34, 76, 55, 240, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 10, 240, 38, 11, 251, 240, 39, 5, 39, 112, 39, 245, 24, 112, 40, 228, 237, 80, 41, 212, 236, 96, 42, 196, 207, 80, 43, 180, 206, 96, 44, 164, 177, 80, 45, 148, 176, 96, 46, 132, 147, 80, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 2, 3, 6, 4, 5, 4, 3, 7, 3, 7, 3, 7, 3, 7, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 10, 2, 10, 2, 10, 2, 10, 2, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 11, 12, 0, 0, 32, 248, 0, 0, 0, 0, 32, 208, 0, 4, 0, 0, 28, 32, 0, 10, 0, 0, 42, 48, 0, 14, 0, 0, 14, 16, 0, 18, 0, 0, 28, 32, 1, 22, 0, 0, 28, 32, 1, 22, 0, 0, 56, 64, 1, 27, 0, 0, 42, 48, 0, 14, 0, 0, 56, 64, 1, 27, 0, 0, 42, 48, 1, 31, 0, 0, 42, 48, 1, 31, 0, 0, 28, 32, 0, 10, 76, 77, 84, 0, 43, 48, 50, 50, 48, 0, 69, 69, 84, 0, 77, 83, 75, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 77, 83, 68, 0, 69, 69, 83, 84, 0, 0, 0, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 69, 69, 84, 45, 50, 69, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 51, 44, 77, 49, 48, 46, 53, 46, 48, 47, 52, 10}, - - "zoneinfo/Europe/Zurich": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 119, 0, 0, 0, 5, 0, 0, 0, 13, 128, 0, 0, 0, 202, 23, 106, 0, 202, 226, 113, 0, 203, 247, 76, 0, 204, 194, 83, 0, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 0, 0, 6, 250, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 66, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Factory": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 1, 0, 0, 0, 4, 128, 0, 0, 0, 127, 255, 255, 255, 0, 0, 0, 0, 0, 0, 0, 0, 45, 48, 48, 0, 0, 0, 10, 60, 45, 48, 48, 62, 48, 10}, - - "zoneinfo/GB": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 243, 0, 0, 0, 8, 0, 0, 0, 17, 128, 0, 0, 0, 155, 38, 173, 160, 155, 214, 5, 32, 156, 207, 48, 160, 157, 164, 195, 160, 158, 156, 157, 160, 159, 151, 26, 160, 160, 133, 186, 32, 161, 118, 252, 160, 162, 101, 156, 32, 163, 123, 200, 160, 164, 78, 184, 160, 165, 63, 251, 32, 166, 37, 96, 32, 167, 39, 198, 32, 168, 42, 44, 32, 168, 235, 248, 160, 170, 0, 211, 160, 170, 213, 21, 32, 171, 233, 240, 32, 172, 199, 108, 32, 173, 201, 210, 32, 174, 167, 78, 32, 175, 160, 121, 160, 176, 135, 48, 32, 177, 146, 208, 160, 178, 112, 76, 160, 179, 114, 178, 160, 180, 80, 46, 160, 181, 73, 90, 32, 182, 48, 16, 160, 183, 50, 118, 160, 184, 15, 242, 160, 185, 18, 88, 160, 185, 239, 212, 160, 186, 233, 0, 32, 187, 216, 241, 32, 188, 219, 87, 32, 189, 184, 211, 32, 190, 177, 254, 160, 191, 152, 181, 32, 192, 155, 27, 32, 193, 120, 151, 32, 194, 122, 253, 32, 195, 88, 121, 32, 196, 81, 164, 160, 197, 56, 91, 32, 198, 58, 193, 32, 199, 88, 214, 160, 199, 218, 9, 160, 202, 22, 38, 144, 202, 151, 89, 144, 203, 209, 30, 144, 204, 119, 59, 144, 205, 177, 0, 144, 206, 96, 88, 16, 207, 144, 226, 144, 208, 110, 94, 144, 209, 114, 22, 16, 209, 251, 50, 16, 210, 105, 254, 32, 211, 99, 41, 160, 212, 73, 224, 32, 213, 30, 33, 160, 213, 66, 253, 144, 213, 223, 224, 16, 214, 78, 172, 32, 214, 254, 3, 160, 216, 46, 142, 32, 216, 249, 149, 32, 218, 14, 112, 32, 218, 235, 236, 32, 219, 229, 23, 160, 220, 203, 206, 32, 221, 196, 249, 160, 222, 180, 234, 160, 223, 174, 22, 32, 224, 148, 204, 160, 225, 114, 72, 160, 226, 107, 116, 32, 227, 82, 42, 160, 228, 84, 144, 160, 229, 50, 12, 160, 230, 61, 173, 32, 231, 27, 41, 32, 232, 20, 84, 160, 232, 251, 11, 32, 233, 253, 113, 32, 234, 218, 237, 32, 235, 221, 83, 32, 236, 186, 207, 32, 237, 179, 250, 160, 238, 154, 177, 32, 239, 129, 103, 160, 240, 159, 125, 32, 241, 97, 73, 160, 242, 127, 95, 32, 243, 74, 102, 32, 244, 95, 65, 32, 245, 33, 13, 160, 246, 63, 35, 32, 247, 0, 239, 160, 248, 31, 5, 32, 248, 224, 209, 160, 249, 254, 231, 32, 250, 192, 179, 160, 251, 232, 3, 160, 252, 123, 171, 160, 253, 199, 187, 112, 3, 112, 198, 32, 4, 41, 88, 32, 5, 80, 168, 32, 6, 9, 58, 32, 7, 48, 138, 32, 7, 233, 28, 32, 9, 16, 108, 32, 9, 200, 254, 32, 10, 240, 78, 32, 11, 178, 26, 160, 12, 208, 48, 32, 13, 145, 252, 160, 14, 176, 18, 32, 15, 113, 222, 160, 16, 153, 46, 160, 17, 81, 192, 160, 18, 121, 16, 160, 19, 49, 162, 160, 20, 88, 242, 160, 21, 35, 235, 144, 22, 56, 198, 144, 23, 3, 205, 144, 24, 24, 168, 144, 24, 227, 175, 144, 25, 248, 138, 144, 26, 195, 145, 144, 27, 225, 167, 16, 28, 172, 174, 16, 29, 193, 137, 16, 30, 140, 144, 16, 31, 161, 107, 16, 32, 108, 114, 16, 33, 129, 77, 16, 34, 76, 84, 16, 35, 97, 47, 16, 36, 44, 54, 16, 37, 74, 75, 144, 38, 12, 24, 16, 39, 42, 45, 144, 39, 245, 52, 144, 41, 10, 15, 144, 41, 213, 22, 144, 42, 233, 241, 144, 43, 180, 248, 144, 44, 201, 211, 144, 45, 148, 218, 144, 46, 169, 181, 144, 47, 116, 188, 144, 48, 137, 151, 144, 48, 231, 36, 0, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1, 3, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 4, 6, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 7, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 255, 255, 255, 181, 0, 0, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 8, 0, 0, 28, 32, 1, 12, 0, 0, 14, 16, 0, 4, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 8, 76, 77, 84, 0, 66, 83, 84, 0, 71, 77, 84, 0, 66, 68, 83, 84, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 10, 71, 77, 84, 48, 66, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 49, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/GB-Eire": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 243, 0, 0, 0, 8, 0, 0, 0, 17, 128, 0, 0, 0, 155, 38, 173, 160, 155, 214, 5, 32, 156, 207, 48, 160, 157, 164, 195, 160, 158, 156, 157, 160, 159, 151, 26, 160, 160, 133, 186, 32, 161, 118, 252, 160, 162, 101, 156, 32, 163, 123, 200, 160, 164, 78, 184, 160, 165, 63, 251, 32, 166, 37, 96, 32, 167, 39, 198, 32, 168, 42, 44, 32, 168, 235, 248, 160, 170, 0, 211, 160, 170, 213, 21, 32, 171, 233, 240, 32, 172, 199, 108, 32, 173, 201, 210, 32, 174, 167, 78, 32, 175, 160, 121, 160, 176, 135, 48, 32, 177, 146, 208, 160, 178, 112, 76, 160, 179, 114, 178, 160, 180, 80, 46, 160, 181, 73, 90, 32, 182, 48, 16, 160, 183, 50, 118, 160, 184, 15, 242, 160, 185, 18, 88, 160, 185, 239, 212, 160, 186, 233, 0, 32, 187, 216, 241, 32, 188, 219, 87, 32, 189, 184, 211, 32, 190, 177, 254, 160, 191, 152, 181, 32, 192, 155, 27, 32, 193, 120, 151, 32, 194, 122, 253, 32, 195, 88, 121, 32, 196, 81, 164, 160, 197, 56, 91, 32, 198, 58, 193, 32, 199, 88, 214, 160, 199, 218, 9, 160, 202, 22, 38, 144, 202, 151, 89, 144, 203, 209, 30, 144, 204, 119, 59, 144, 205, 177, 0, 144, 206, 96, 88, 16, 207, 144, 226, 144, 208, 110, 94, 144, 209, 114, 22, 16, 209, 251, 50, 16, 210, 105, 254, 32, 211, 99, 41, 160, 212, 73, 224, 32, 213, 30, 33, 160, 213, 66, 253, 144, 213, 223, 224, 16, 214, 78, 172, 32, 214, 254, 3, 160, 216, 46, 142, 32, 216, 249, 149, 32, 218, 14, 112, 32, 218, 235, 236, 32, 219, 229, 23, 160, 220, 203, 206, 32, 221, 196, 249, 160, 222, 180, 234, 160, 223, 174, 22, 32, 224, 148, 204, 160, 225, 114, 72, 160, 226, 107, 116, 32, 227, 82, 42, 160, 228, 84, 144, 160, 229, 50, 12, 160, 230, 61, 173, 32, 231, 27, 41, 32, 232, 20, 84, 160, 232, 251, 11, 32, 233, 253, 113, 32, 234, 218, 237, 32, 235, 221, 83, 32, 236, 186, 207, 32, 237, 179, 250, 160, 238, 154, 177, 32, 239, 129, 103, 160, 240, 159, 125, 32, 241, 97, 73, 160, 242, 127, 95, 32, 243, 74, 102, 32, 244, 95, 65, 32, 245, 33, 13, 160, 246, 63, 35, 32, 247, 0, 239, 160, 248, 31, 5, 32, 248, 224, 209, 160, 249, 254, 231, 32, 250, 192, 179, 160, 251, 232, 3, 160, 252, 123, 171, 160, 253, 199, 187, 112, 3, 112, 198, 32, 4, 41, 88, 32, 5, 80, 168, 32, 6, 9, 58, 32, 7, 48, 138, 32, 7, 233, 28, 32, 9, 16, 108, 32, 9, 200, 254, 32, 10, 240, 78, 32, 11, 178, 26, 160, 12, 208, 48, 32, 13, 145, 252, 160, 14, 176, 18, 32, 15, 113, 222, 160, 16, 153, 46, 160, 17, 81, 192, 160, 18, 121, 16, 160, 19, 49, 162, 160, 20, 88, 242, 160, 21, 35, 235, 144, 22, 56, 198, 144, 23, 3, 205, 144, 24, 24, 168, 144, 24, 227, 175, 144, 25, 248, 138, 144, 26, 195, 145, 144, 27, 225, 167, 16, 28, 172, 174, 16, 29, 193, 137, 16, 30, 140, 144, 16, 31, 161, 107, 16, 32, 108, 114, 16, 33, 129, 77, 16, 34, 76, 84, 16, 35, 97, 47, 16, 36, 44, 54, 16, 37, 74, 75, 144, 38, 12, 24, 16, 39, 42, 45, 144, 39, 245, 52, 144, 41, 10, 15, 144, 41, 213, 22, 144, 42, 233, 241, 144, 43, 180, 248, 144, 44, 201, 211, 144, 45, 148, 218, 144, 46, 169, 181, 144, 47, 116, 188, 144, 48, 137, 151, 144, 48, 231, 36, 0, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 2, 1, 2, 1, 3, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 4, 6, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 7, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 255, 255, 255, 181, 0, 0, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 8, 0, 0, 28, 32, 1, 12, 0, 0, 14, 16, 0, 4, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 8, 76, 77, 84, 0, 66, 83, 84, 0, 71, 77, 84, 0, 66, 68, 83, 84, 0, 0, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 10, 71, 77, 84, 48, 66, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 49, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/GMT": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 71, 77, 84, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/GMT+0": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 71, 77, 84, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/GMT-0": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 71, 77, 84, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/GMT0": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 71, 77, 84, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Greenwich": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 71, 77, 84, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/HST": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 255, 255, 115, 96, 0, 0, 72, 83, 84, 0, 0, 0, 10, 72, 83, 84, 49, 48, 10}, - - "zoneinfo/Hongkong": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 70, 0, 0, 0, 5, 0, 0, 0, 17, 128, 0, 0, 0, 133, 105, 90, 246, 201, 234, 87, 184, 202, 218, 58, 168, 203, 75, 120, 128, 210, 76, 98, 112, 211, 106, 183, 56, 212, 147, 74, 168, 213, 66, 176, 56, 214, 154, 185, 168, 215, 62, 65, 184, 216, 46, 36, 168, 216, 249, 57, 184, 218, 14, 6, 168, 218, 217, 27, 184, 219, 237, 232, 168, 220, 184, 253, 184, 221, 205, 202, 168, 222, 162, 26, 56, 223, 172, 91, 40, 224, 129, 252, 56, 225, 150, 201, 40, 226, 79, 105, 56, 227, 118, 171, 40, 228, 47, 75, 56, 229, 95, 199, 168, 230, 15, 45, 56, 231, 63, 169, 168, 231, 248, 73, 184, 233, 31, 139, 168, 233, 216, 43, 184, 234, 255, 109, 168, 235, 184, 13, 184, 236, 223, 79, 168, 237, 151, 239, 184, 238, 200, 108, 40, 239, 119, 209, 184, 240, 168, 78, 40, 241, 87, 179, 184, 242, 136, 48, 40, 243, 64, 208, 56, 244, 104, 18, 40, 245, 32, 178, 56, 246, 71, 244, 40, 247, 37, 126, 56, 248, 21, 97, 40, 249, 5, 96, 56, 249, 245, 67, 40, 250, 229, 66, 56, 251, 222, 95, 168, 252, 206, 94, 184, 253, 190, 65, 168, 254, 174, 64, 184, 255, 158, 35, 168, 0, 142, 34, 184, 1, 126, 5, 168, 2, 110, 4, 184, 3, 93, 231, 168, 4, 77, 230, 184, 5, 71, 4, 40, 6, 55, 3, 56, 7, 38, 230, 40, 7, 131, 61, 56, 9, 6, 200, 40, 9, 246, 199, 56, 10, 230, 170, 40, 11, 214, 169, 56, 12, 198, 140, 40, 17, 155, 57, 56, 18, 111, 108, 168, 0, 2, 1, 2, 3, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 107, 10, 0, 0, 0, 0, 126, 144, 1, 4, 0, 0, 112, 128, 0, 9, 0, 0, 126, 144, 0, 13, 0, 0, 112, 128, 0, 9, 76, 77, 84, 0, 72, 75, 83, 84, 0, 72, 75, 84, 0, 74, 83, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 72, 75, 84, 45, 56, 10}, - - "zoneinfo/Iceland": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 69, 0, 0, 0, 6, 0, 0, 0, 16, 128, 0, 0, 0, 139, 96, 131, 160, 156, 145, 30, 0, 157, 209, 136, 144, 158, 114, 81, 128, 159, 213, 3, 16, 160, 83, 133, 0, 161, 182, 54, 144, 164, 60, 39, 128, 164, 185, 116, 16, 198, 77, 26, 0, 199, 61, 39, 32, 199, 218, 23, 176, 201, 38, 67, 160, 201, 195, 38, 32, 203, 6, 37, 160, 203, 172, 66, 160, 204, 220, 205, 32, 205, 140, 36, 160, 206, 188, 175, 32, 207, 108, 6, 160, 208, 156, 145, 32, 209, 75, 232, 160, 210, 133, 173, 160, 211, 43, 202, 160, 212, 101, 143, 160, 213, 57, 209, 32, 214, 69, 113, 160, 215, 25, 179, 32, 216, 37, 83, 160, 216, 249, 149, 32, 218, 14, 112, 32, 218, 217, 119, 32, 219, 229, 23, 160, 220, 185, 89, 32, 221, 206, 52, 32, 222, 162, 117, 160, 223, 174, 22, 32, 224, 130, 87, 160, 225, 141, 248, 32, 226, 98, 57, 160, 227, 109, 218, 32, 228, 66, 27, 160, 229, 77, 188, 32, 230, 33, 253, 160, 231, 54, 216, 160, 232, 11, 26, 32, 233, 22, 186, 160, 233, 234, 252, 32, 234, 246, 156, 160, 235, 202, 222, 32, 236, 214, 126, 160, 237, 170, 192, 32, 238, 182, 96, 160, 239, 138, 162, 32, 240, 150, 66, 160, 241, 106, 132, 32, 242, 127, 95, 32, 243, 83, 160, 160, 244, 95, 65, 32, 245, 51, 130, 160, 246, 63, 35, 32, 247, 19, 100, 160, 248, 31, 5, 32, 248, 243, 70, 160, 249, 254, 231, 32, 250, 211, 40, 160, 251, 232, 3, 160, 252, 188, 69, 32, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 5, 255, 255, 235, 96, 0, 0, 0, 0, 0, 0, 1, 4, 255, 255, 241, 240, 0, 8, 255, 255, 241, 240, 0, 8, 0, 0, 0, 0, 1, 4, 0, 0, 0, 0, 0, 12, 76, 77, 84, 0, 43, 48, 48, 0, 45, 48, 49, 0, 71, 77, 84, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 0, 10, 71, 77, 84, 48, 10}, - - "zoneinfo/Indian/Antananarivo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 177, 238, 218, 252, 180, 194, 154, 208, 199, 145, 71, 216, 237, 47, 225, 212, 0, 1, 2, 3, 1, 0, 0, 34, 132, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 35, 40, 0, 8, 0, 0, 38, 172, 0, 14, 0, 0, 42, 48, 0, 4, 76, 77, 84, 0, 69, 65, 84, 0, 43, 48, 50, 51, 48, 0, 43, 48, 50, 52, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 65, 84, 45, 51, 10}, - - "zoneinfo/Indian/Chagos": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 137, 126, 247, 156, 48, 230, 221, 176, 127, 255, 255, 255, 0, 1, 2, 2, 0, 0, 67, 228, 0, 0, 0, 0, 70, 80, 0, 4, 0, 0, 84, 96, 0, 8, 76, 77, 84, 0, 43, 48, 53, 0, 43, 48, 54, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 54, 62, 45, 54, 10}, - - "zoneinfo/Indian/Christmas": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 127, 255, 255, 255, 1, 1, 0, 0, 99, 28, 0, 0, 0, 0, 98, 112, 0, 4, 76, 77, 84, 0, 43, 48, 55, 0, 0, 0, 0, 0, 10, 60, 43, 48, 55, 62, 45, 55, 10}, - - "zoneinfo/Indian/Cocos": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 10, 128, 0, 0, 0, 127, 255, 255, 255, 1, 1, 0, 0, 90, 220, 0, 0, 0, 0, 91, 104, 0, 4, 76, 77, 84, 0, 43, 48, 54, 51, 48, 0, 0, 0, 0, 0, 10, 60, 43, 48, 54, 51, 48, 62, 45, 54, 58, 51, 48, 10}, - - "zoneinfo/Indian/Comoro": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 177, 238, 218, 252, 180, 194, 154, 208, 199, 145, 71, 216, 237, 47, 225, 212, 0, 1, 2, 3, 1, 0, 0, 34, 132, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 35, 40, 0, 8, 0, 0, 38, 172, 0, 14, 0, 0, 42, 48, 0, 4, 76, 77, 84, 0, 69, 65, 84, 0, 43, 48, 50, 51, 48, 0, 43, 48, 50, 52, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 65, 84, 45, 51, 10}, - - "zoneinfo/Indian/Kerguelen": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 218, 97, 98, 128, 127, 255, 255, 255, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 70, 80, 0, 4, 45, 48, 48, 0, 43, 48, 53, 0, 0, 0, 0, 0, 10, 60, 43, 48, 53, 62, 45, 53, 10}, - - "zoneinfo/Indian/Mahe": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 136, 100, 230, 132, 127, 255, 255, 255, 0, 1, 1, 0, 0, 51, 252, 0, 0, 0, 0, 56, 64, 0, 4, 76, 77, 84, 0, 43, 48, 52, 0, 0, 0, 0, 0, 10, 60, 43, 48, 52, 62, 45, 52, 10}, - - "zoneinfo/Indian/Maldives": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 237, 47, 195, 152, 127, 255, 255, 255, 1, 2, 2, 0, 0, 68, 232, 0, 0, 0, 0, 68, 232, 0, 4, 0, 0, 70, 80, 0, 8, 76, 77, 84, 0, 77, 77, 84, 0, 43, 48, 53, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 53, 62, 45, 53, 10}, - - "zoneinfo/Indian/Mauritius": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 137, 127, 5, 152, 24, 5, 237, 64, 24, 219, 114, 48, 73, 3, 150, 224, 73, 206, 143, 208, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 2, 0, 0, 53, 232, 0, 0, 0, 0, 70, 80, 1, 4, 0, 0, 56, 64, 0, 8, 76, 77, 84, 0, 43, 48, 53, 0, 43, 48, 52, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 52, 62, 45, 52, 10}, - - "zoneinfo/Indian/Mayotte": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 177, 238, 218, 252, 180, 194, 154, 208, 199, 145, 71, 216, 237, 47, 225, 212, 0, 1, 2, 3, 1, 0, 0, 34, 132, 0, 0, 0, 0, 42, 48, 0, 4, 0, 0, 35, 40, 0, 8, 0, 0, 38, 172, 0, 14, 0, 0, 42, 48, 0, 4, 76, 77, 84, 0, 69, 65, 84, 0, 43, 48, 50, 51, 48, 0, 43, 48, 50, 52, 53, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 65, 84, 45, 51, 10}, - - "zoneinfo/Indian/Reunion": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 145, 204, 57, 128, 127, 255, 255, 255, 0, 1, 1, 0, 0, 52, 0, 0, 0, 0, 0, 56, 64, 0, 4, 76, 77, 84, 0, 43, 48, 52, 0, 0, 0, 0, 0, 10, 60, 43, 48, 52, 62, 45, 52, 10}, - - "zoneinfo/Iran": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 102, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 154, 108, 125, 200, 210, 219, 18, 200, 14, 187, 162, 72, 15, 116, 45, 64, 16, 142, 64, 48, 16, 237, 58, 64, 17, 85, 103, 200, 18, 69, 74, 184, 19, 55, 236, 200, 20, 45, 21, 184, 40, 32, 118, 200, 40, 219, 157, 184, 41, 203, 156, 200, 42, 190, 34, 184, 43, 172, 208, 72, 44, 159, 86, 56, 45, 142, 3, 200, 46, 128, 137, 184, 47, 111, 55, 72, 48, 97, 189, 56, 49, 80, 106, 200, 50, 66, 240, 184, 51, 50, 239, 200, 52, 37, 117, 184, 53, 20, 35, 72, 54, 6, 169, 56, 54, 245, 86, 200, 55, 231, 220, 184, 56, 214, 138, 72, 57, 201, 16, 56, 58, 185, 15, 72, 59, 171, 149, 56, 60, 154, 66, 200, 61, 140, 200, 184, 62, 123, 118, 72, 63, 109, 252, 56, 64, 92, 169, 200, 65, 79, 47, 184, 66, 63, 46, 200, 67, 49, 180, 184, 71, 226, 201, 72, 72, 213, 79, 56, 73, 197, 78, 72, 74, 183, 212, 56, 75, 166, 129, 200, 76, 153, 7, 184, 77, 135, 181, 72, 78, 122, 59, 56, 79, 104, 232, 200, 80, 91, 110, 184, 81, 75, 109, 200, 82, 61, 243, 184, 83, 44, 161, 72, 84, 31, 39, 56, 85, 13, 212, 200, 86, 0, 90, 184, 86, 239, 8, 72, 87, 225, 142, 56, 88, 209, 141, 72, 89, 196, 19, 56, 90, 178, 192, 200, 91, 165, 70, 184, 92, 147, 244, 72, 93, 134, 122, 56, 94, 117, 39, 200, 95, 103, 173, 184, 96, 87, 172, 200, 97, 74, 50, 184, 98, 56, 224, 72, 99, 43, 102, 56, 100, 26, 19, 200, 101, 12, 153, 184, 101, 251, 71, 72, 102, 237, 205, 56, 103, 221, 204, 72, 104, 208, 82, 56, 105, 190, 255, 200, 106, 177, 133, 184, 107, 160, 51, 72, 108, 146, 185, 56, 109, 129, 102, 200, 110, 115, 236, 184, 111, 98, 154, 72, 112, 85, 32, 56, 113, 69, 31, 72, 114, 55, 165, 56, 115, 38, 82, 200, 116, 24, 216, 184, 117, 7, 134, 72, 117, 250, 12, 56, 118, 232, 185, 200, 119, 219, 63, 184, 120, 203, 62, 200, 121, 189, 196, 184, 122, 172, 114, 72, 123, 158, 248, 56, 124, 141, 165, 200, 125, 128, 43, 184, 126, 110, 217, 72, 127, 97, 95, 56, 127, 255, 255, 255, 0, 1, 2, 4, 3, 4, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 2, 0, 0, 48, 56, 0, 0, 0, 0, 48, 56, 0, 4, 0, 0, 49, 56, 0, 8, 0, 0, 70, 80, 1, 14, 0, 0, 56, 64, 0, 18, 0, 0, 63, 72, 1, 22, 0, 0, 49, 56, 0, 8, 76, 77, 84, 0, 84, 77, 84, 0, 43, 48, 51, 51, 48, 0, 43, 48, 53, 0, 43, 48, 52, 0, 43, 48, 52, 51, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 51, 51, 48, 62, 45, 51, 58, 51, 48, 60, 43, 48, 52, 51, 48, 62, 44, 74, 56, 48, 47, 48, 44, 74, 50, 54, 52, 47, 48, 10}, - - "zoneinfo/Israel": []byte{84, 90, 105, 102, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 143, 0, 0, 0, 6, 0, 0, 0, 21, 128, 0, 0, 0, 158, 48, 69, 136, 200, 89, 178, 224, 204, 229, 193, 80, 205, 172, 254, 0, 206, 198, 244, 208, 207, 143, 102, 224, 208, 169, 121, 208, 209, 132, 96, 224, 210, 138, 201, 112, 211, 101, 176, 128, 212, 107, 224, 208, 215, 90, 20, 96, 215, 223, 31, 192, 216, 47, 181, 112, 217, 30, 70, 224, 218, 16, 232, 240, 218, 235, 179, 224, 219, 180, 52, 0, 220, 185, 32, 224, 221, 224, 141, 0, 222, 180, 206, 128, 223, 164, 191, 128, 224, 139, 118, 0, 225, 86, 125, 0, 226, 190, 74, 96, 227, 54, 52, 208, 228, 156, 247, 0, 229, 22, 22, 208, 230, 116, 211, 224, 231, 17, 210, 128, 232, 39, 255, 0, 232, 232, 79, 208, 8, 124, 139, 224, 8, 253, 176, 208, 9, 246, 234, 96, 10, 166, 51, 208, 28, 190, 248, 224, 29, 137, 241, 208, 30, 204, 255, 96, 31, 96, 153, 80, 32, 130, 177, 96, 33, 73, 181, 208, 34, 94, 158, 224, 35, 32, 93, 80, 36, 90, 48, 96, 37, 0, 63, 80, 38, 11, 237, 224, 38, 214, 230, 208, 39, 235, 207, 224, 40, 192, 3, 80, 41, 212, 236, 96, 42, 169, 31, 208, 43, 187, 101, 224, 44, 137, 1, 208, 45, 155, 71, 224, 46, 95, 169, 80, 47, 123, 41, 224, 48, 72, 197, 208, 49, 72, 150, 224, 50, 60, 110, 80, 51, 49, 179, 96, 52, 26, 254, 208, 53, 17, 149, 96, 53, 241, 166, 80, 55, 4, 8, 128, 55, 207, 1, 112, 56, 246, 95, 128, 57, 220, 249, 224, 58, 208, 237, 112, 59, 174, 91, 96, 60, 163, 160, 112, 61, 160, 178, 96, 62, 131, 130, 112, 63, 124, 159, 224, 64, 115, 54, 112, 65, 80, 164, 96, 66, 76, 143, 0, 67, 72, 79, 112, 68, 44, 113, 0, 69, 30, 246, 240, 70, 12, 83, 0, 70, 236, 99, 240, 71, 236, 53, 0, 72, 231, 245, 112, 73, 204, 23, 0, 74, 190, 156, 240, 75, 171, 249, 0, 76, 140, 9, 240, 77, 149, 21, 128, 78, 135, 155, 112, 79, 116, 247, 128, 80, 94, 66, 240, 81, 84, 217, 128, 82, 108, 73, 112, 83, 52, 187, 128, 84, 76, 43, 112, 85, 20, 157, 128, 86, 44, 13, 112, 86, 244, 127, 128, 88, 21, 41, 240, 88, 212, 97, 128, 89, 245, 11, 240, 90, 180, 67, 128, 91, 212, 237, 240, 92, 157, 96, 0, 93, 180, 207, 240, 94, 125, 66, 0, 95, 148, 177, 240, 96, 93, 36, 0, 97, 125, 206, 112, 98, 61, 6, 0, 99, 93, 176, 112, 100, 28, 232, 0, 101, 61, 146, 112, 102, 6, 4, 128, 103, 29, 116, 112, 103, 229, 230, 128, 104, 253, 86, 112, 105, 197, 200, 128, 106, 221, 56, 112, 107, 165, 170, 128, 108, 198, 84, 240, 109, 133, 140, 128, 110, 166, 54, 240, 111, 101, 110, 128, 112, 134, 24, 240, 113, 78, 139, 0, 114, 101, 250, 240, 115, 46, 109, 0, 116, 69, 220, 240, 117, 14, 79, 0, 118, 46, 249, 112, 118, 238, 49, 0, 120, 14, 219, 112, 120, 206, 19, 0, 121, 238, 189, 112, 122, 173, 245, 0, 123, 206, 159, 112, 124, 151, 17, 128, 125, 174, 129, 112, 126, 118, 243, 128, 127, 142, 99, 112, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 4, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 0, 0, 33, 6, 0, 0, 0, 0, 32, 248, 0, 4, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 12, 0, 0, 56, 64, 1, 16, 0, 0, 42, 48, 1, 8, 76, 77, 84, 0, 74, 77, 84, 0, 73, 68, 84, 0, 73, 83, 84, 0, 73, 68, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 73, 83, 84, 45, 50, 73, 68, 84, 44, 77, 51, 46, 52, 46, 52, 47, 50, 54, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/Jamaica": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 4, 0, 0, 0, 16, 128, 0, 0, 0, 147, 15, 180, 255, 7, 141, 25, 112, 9, 16, 164, 96, 9, 173, 148, 240, 10, 240, 134, 96, 11, 224, 133, 112, 12, 217, 162, 224, 13, 192, 103, 112, 14, 185, 132, 224, 15, 169, 131, 240, 16, 153, 102, 224, 17, 137, 101, 240, 18, 121, 72, 224, 19, 105, 71, 240, 20, 89, 42, 224, 21, 73, 41, 240, 22, 57, 12, 224, 23, 41, 11, 240, 24, 34, 41, 96, 25, 8, 237, 240, 26, 2, 11, 96, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 255, 255, 184, 1, 0, 0, 255, 255, 184, 1, 0, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 1, 12, 76, 77, 84, 0, 75, 77, 84, 0, 69, 83, 84, 0, 69, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 83, 84, 53, 10}, - - "zoneinfo/Japan": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 4, 0, 0, 0, 12, 128, 0, 0, 0, 215, 62, 30, 144, 215, 236, 22, 128, 216, 249, 22, 144, 217, 203, 248, 128, 219, 7, 29, 16, 219, 171, 218, 128, 220, 230, 255, 16, 221, 139, 188, 128, 3, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 131, 3, 0, 0, 0, 0, 140, 160, 1, 4, 0, 0, 126, 144, 0, 8, 0, 0, 126, 144, 0, 8, 76, 77, 84, 0, 74, 68, 84, 0, 74, 83, 84, 0, 0, 0, 0, 1, 0, 0, 0, 1, 10, 74, 83, 84, 45, 57, 10}, - - "zoneinfo/Kwajalein": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 16, 128, 0, 0, 0, 255, 134, 27, 80, 44, 116, 188, 192, 127, 255, 255, 255, 1, 2, 3, 3, 0, 0, 156, 224, 0, 0, 0, 0, 154, 176, 0, 4, 255, 255, 87, 64, 0, 8, 0, 0, 168, 192, 0, 12, 76, 77, 84, 0, 43, 49, 49, 0, 45, 49, 50, 0, 43, 49, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 50, 62, 45, 49, 50, 10}, - - "zoneinfo/Libya": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 33, 0, 0, 0, 4, 0, 0, 0, 17, 128, 0, 0, 0, 161, 242, 193, 36, 221, 187, 177, 16, 222, 35, 173, 96, 225, 120, 210, 16, 225, 231, 101, 224, 229, 47, 63, 112, 229, 169, 204, 224, 235, 78, 198, 240, 22, 146, 66, 96, 23, 8, 247, 112, 23, 250, 43, 224, 24, 234, 42, 240, 25, 219, 95, 96, 26, 204, 175, 240, 27, 189, 228, 96, 28, 180, 122, 240, 29, 159, 23, 224, 30, 147, 11, 112, 31, 130, 238, 96, 32, 112, 74, 112, 33, 97, 126, 224, 34, 82, 207, 112, 35, 68, 3, 224, 36, 52, 2, 240, 37, 37, 55, 96, 38, 64, 183, 240, 50, 78, 241, 96, 51, 68, 54, 112, 52, 53, 106, 224, 80, 157, 153, 0, 81, 84, 217, 128, 82, 105, 180, 128, 0, 2, 1, 2, 1, 2, 1, 2, 3, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 1, 3, 2, 1, 3, 0, 0, 12, 92, 0, 0, 0, 0, 28, 32, 1, 4, 0, 0, 14, 16, 0, 9, 0, 0, 28, 32, 0, 13, 76, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 69, 69, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 69, 69, 84, 45, 50, 10}, - - "zoneinfo/MET": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 136, 0, 0, 0, 4, 0, 0, 0, 9, 155, 12, 23, 96, 155, 213, 218, 240, 156, 217, 174, 144, 157, 164, 181, 144, 158, 185, 144, 144, 159, 132, 151, 144, 200, 9, 113, 144, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 130, 37, 16, 209, 114, 22, 16, 210, 78, 64, 144, 13, 164, 99, 144, 14, 139, 26, 16, 15, 132, 69, 144, 16, 116, 54, 144, 17, 100, 39, 144, 18, 84, 24, 144, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 0, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 0, 0, 28, 32, 1, 0, 0, 0, 14, 16, 0, 5, 0, 0, 28, 32, 1, 0, 0, 0, 14, 16, 0, 5, 77, 69, 83, 84, 0, 77, 69, 84, 0, 0, 0, 1, 1, 0, 0, 0, 0, 10, 77, 69, 84, 45, 49, 77, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/MST": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 255, 255, 157, 144, 0, 0, 77, 83, 84, 0, 0, 0, 10, 77, 83, 84, 55, 10}, - - "zoneinfo/MST7MDT": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 149, 0, 0, 0, 4, 0, 0, 0, 16, 158, 166, 58, 144, 159, 187, 7, 128, 160, 134, 28, 144, 161, 154, 233, 128, 203, 137, 12, 144, 210, 35, 244, 112, 210, 97, 24, 0, 250, 248, 117, 16, 251, 232, 88, 0, 252, 216, 87, 16, 253, 200, 58, 0, 254, 184, 57, 16, 255, 168, 28, 0, 0, 152, 27, 16, 1, 135, 254, 0, 2, 119, 253, 16, 3, 113, 26, 128, 4, 97, 25, 144, 5, 80, 252, 128, 6, 64, 251, 144, 7, 48, 222, 128, 7, 141, 53, 144, 9, 16, 192, 128, 9, 173, 177, 16, 10, 240, 162, 128, 11, 224, 161, 144, 12, 217, 191, 0, 13, 192, 131, 144, 14, 185, 161, 0, 15, 169, 160, 16, 16, 153, 131, 0, 17, 137, 130, 16, 18, 121, 101, 0, 19, 105, 100, 16, 20, 89, 71, 0, 21, 73, 70, 16, 22, 57, 41, 0, 23, 41, 40, 16, 24, 34, 69, 128, 25, 9, 10, 16, 26, 2, 39, 128, 26, 242, 38, 144, 27, 226, 9, 128, 28, 210, 8, 144, 29, 193, 235, 128, 30, 177, 234, 144, 31, 161, 205, 128, 32, 118, 29, 16, 33, 129, 175, 128, 34, 85, 255, 16, 35, 106, 204, 0, 36, 53, 225, 16, 37, 74, 174, 0, 38, 21, 195, 16, 39, 42, 144, 0, 39, 254, 223, 144, 41, 10, 114, 0, 41, 222, 193, 144, 42, 234, 84, 0, 43, 190, 163, 144, 44, 211, 112, 128, 45, 158, 133, 144, 46, 179, 82, 128, 47, 126, 103, 144, 48, 147, 52, 128, 49, 103, 132, 16, 50, 115, 22, 128, 51, 71, 102, 16, 52, 82, 248, 128, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 231, 12, 16, 57, 251, 217, 0, 58, 198, 238, 16, 59, 219, 187, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 206, 144, 65, 132, 155, 128, 66, 79, 176, 144, 67, 100, 125, 128, 68, 47, 146, 144, 69, 68, 95, 128, 69, 243, 197, 16, 71, 45, 124, 0, 71, 211, 167, 16, 73, 13, 94, 0, 73, 179, 137, 16, 74, 237, 64, 0, 75, 156, 165, 144, 76, 214, 92, 128, 77, 124, 135, 144, 78, 182, 62, 128, 79, 92, 105, 144, 80, 150, 32, 128, 81, 60, 75, 144, 82, 118, 2, 128, 83, 28, 45, 144, 84, 85, 228, 128, 84, 252, 15, 144, 86, 53, 198, 128, 86, 229, 44, 16, 88, 30, 227, 0, 88, 197, 14, 16, 89, 254, 197, 0, 90, 164, 240, 16, 91, 222, 167, 0, 92, 132, 210, 16, 93, 190, 137, 0, 94, 100, 180, 16, 95, 158, 107, 0, 96, 77, 208, 144, 97, 135, 135, 128, 98, 45, 178, 144, 99, 103, 105, 128, 100, 13, 148, 144, 101, 71, 75, 128, 101, 237, 118, 144, 103, 39, 45, 128, 103, 205, 88, 144, 105, 7, 15, 128, 105, 173, 58, 144, 106, 230, 241, 128, 107, 150, 87, 16, 108, 208, 14, 0, 109, 118, 57, 16, 110, 175, 240, 0, 111, 86, 27, 16, 112, 143, 210, 0, 113, 53, 253, 16, 114, 111, 180, 0, 115, 21, 223, 16, 116, 79, 150, 0, 116, 254, 251, 144, 118, 56, 178, 128, 118, 222, 221, 144, 120, 24, 148, 128, 120, 190, 191, 144, 121, 248, 118, 128, 122, 158, 161, 144, 123, 216, 88, 128, 124, 126, 131, 144, 125, 184, 58, 128, 126, 94, 101, 144, 127, 152, 28, 128, 0, 1, 0, 1, 2, 3, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 255, 255, 171, 160, 1, 0, 255, 255, 157, 144, 0, 4, 255, 255, 171, 160, 1, 8, 255, 255, 171, 160, 1, 12, 77, 68, 84, 0, 77, 83, 84, 0, 77, 87, 84, 0, 77, 80, 84, 0, 0, 0, 0, 1, 0, 0, 0, 1, 10, 77, 83, 84, 55, 77, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/Mexico/BajaNorte": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 150, 0, 0, 0, 6, 0, 0, 0, 24, 128, 0, 0, 0, 165, 182, 246, 128, 169, 121, 79, 112, 175, 242, 124, 240, 182, 102, 100, 112, 183, 27, 16, 0, 184, 10, 242, 240, 203, 234, 141, 128, 210, 35, 244, 112, 210, 153, 186, 112, 215, 27, 89, 0, 216, 145, 180, 240, 226, 126, 75, 144, 227, 73, 82, 144, 228, 94, 45, 144, 229, 41, 52, 144, 230, 71, 74, 16, 231, 18, 81, 16, 232, 39, 44, 16, 232, 242, 51, 16, 234, 7, 14, 16, 234, 210, 21, 16, 235, 230, 240, 16, 236, 177, 247, 16, 237, 198, 210, 16, 238, 145, 217, 16, 11, 224, 175, 160, 12, 217, 205, 16, 13, 192, 145, 160, 14, 185, 175, 16, 15, 169, 174, 32, 16, 153, 145, 16, 17, 137, 144, 32, 18, 121, 115, 16, 19, 105, 114, 32, 20, 89, 85, 16, 21, 73, 84, 32, 22, 57, 55, 16, 23, 41, 54, 32, 24, 34, 83, 144, 25, 9, 24, 32, 26, 2, 53, 144, 26, 242, 52, 160, 27, 226, 23, 144, 28, 210, 22, 160, 29, 193, 249, 144, 30, 177, 248, 160, 31, 161, 219, 144, 32, 118, 43, 32, 33, 129, 189, 144, 34, 86, 13, 32, 35, 106, 218, 16, 36, 53, 239, 32, 37, 74, 188, 16, 38, 21, 209, 32, 39, 42, 158, 16, 39, 254, 237, 160, 41, 10, 128, 16, 41, 222, 207, 160, 42, 234, 98, 16, 43, 190, 177, 160, 44, 211, 126, 144, 45, 158, 147, 160, 46, 179, 96, 144, 47, 126, 117, 160, 48, 147, 66, 144, 49, 103, 146, 32, 50, 115, 36, 144, 51, 71, 116, 32, 52, 83, 6, 144, 53, 39, 86, 32, 54, 50, 232, 144, 55, 7, 56, 32, 56, 28, 5, 16, 56, 231, 26, 32, 57, 251, 231, 16, 58, 198, 252, 32, 59, 219, 201, 16, 60, 176, 24, 160, 61, 187, 171, 16, 62, 143, 250, 160, 63, 155, 141, 16, 64, 111, 220, 160, 65, 132, 169, 144, 66, 79, 190, 160, 67, 100, 139, 144, 68, 47, 160, 160, 69, 68, 109, 144, 70, 15, 130, 160, 71, 36, 79, 144, 71, 248, 159, 32, 73, 4, 49, 144, 73, 216, 129, 32, 74, 228, 19, 144, 75, 156, 179, 160, 76, 214, 106, 144, 77, 124, 149, 160, 78, 182, 76, 144, 79, 92, 119, 160, 80, 150, 46, 144, 81, 60, 89, 160, 82, 118, 16, 144, 83, 28, 59, 160, 84, 85, 242, 144, 84, 252, 29, 160, 86, 53, 212, 144, 86, 229, 58, 32, 88, 30, 241, 16, 88, 197, 28, 32, 89, 254, 211, 16, 90, 164, 254, 32, 91, 222, 181, 16, 92, 132, 224, 32, 93, 190, 151, 16, 94, 100, 194, 32, 95, 158, 121, 16, 96, 77, 222, 160, 97, 135, 149, 144, 98, 45, 192, 160, 99, 103, 119, 144, 100, 13, 162, 160, 101, 71, 89, 144, 101, 237, 132, 160, 103, 39, 59, 144, 103, 205, 102, 160, 105, 7, 29, 144, 105, 173, 72, 160, 106, 230, 255, 144, 107, 150, 101, 32, 108, 208, 28, 16, 109, 118, 71, 32, 110, 175, 254, 16, 111, 86, 41, 32, 112, 143, 224, 16, 113, 54, 11, 32, 114, 111, 194, 16, 115, 21, 237, 32, 116, 79, 164, 16, 116, 255, 9, 160, 118, 56, 192, 144, 118, 222, 235, 160, 120, 24, 162, 144, 120, 190, 205, 160, 121, 248, 132, 144, 122, 158, 175, 160, 123, 216, 102, 144, 124, 126, 145, 160, 125, 184, 72, 144, 126, 94, 115, 160, 127, 152, 42, 144, 0, 1, 2, 1, 2, 3, 2, 4, 5, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 255, 255, 146, 76, 0, 0, 255, 255, 157, 144, 0, 4, 255, 255, 143, 128, 0, 8, 255, 255, 157, 144, 1, 12, 255, 255, 157, 144, 1, 16, 255, 255, 157, 144, 1, 20, 76, 77, 84, 0, 77, 83, 84, 0, 80, 83, 84, 0, 80, 68, 84, 0, 80, 87, 84, 0, 80, 80, 84, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 10, 80, 83, 84, 56, 80, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/Mexico/BajaSur": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 94, 0, 0, 0, 6, 0, 0, 0, 20, 128, 0, 0, 0, 165, 182, 232, 112, 175, 242, 110, 224, 182, 102, 86, 96, 183, 67, 210, 96, 184, 12, 54, 96, 184, 253, 134, 240, 203, 234, 113, 96, 216, 145, 180, 240, 0, 0, 112, 128, 49, 103, 132, 16, 50, 115, 22, 128, 51, 71, 102, 16, 52, 82, 248, 128, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 231, 12, 16, 57, 251, 217, 0, 58, 245, 18, 144, 59, 182, 209, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 206, 144, 65, 132, 155, 128, 66, 79, 176, 144, 67, 100, 125, 128, 68, 47, 146, 144, 69, 68, 95, 128, 70, 15, 116, 144, 71, 36, 65, 128, 71, 248, 145, 16, 73, 4, 35, 128, 73, 216, 115, 16, 74, 228, 5, 128, 75, 184, 85, 16, 76, 205, 34, 0, 77, 152, 55, 16, 78, 173, 4, 0, 79, 120, 25, 16, 80, 140, 230, 0, 81, 97, 53, 144, 82, 108, 200, 0, 83, 65, 23, 144, 84, 76, 170, 0, 85, 32, 249, 144, 86, 44, 140, 0, 87, 0, 219, 144, 88, 21, 168, 128, 88, 224, 189, 144, 89, 245, 138, 128, 90, 192, 159, 144, 91, 213, 108, 128, 92, 169, 188, 16, 93, 181, 78, 128, 94, 137, 158, 16, 95, 149, 48, 128, 96, 105, 128, 16, 97, 126, 77, 0, 98, 73, 98, 16, 99, 94, 47, 0, 100, 41, 68, 16, 101, 62, 17, 0, 102, 18, 96, 144, 103, 29, 243, 0, 103, 242, 66, 144, 104, 253, 213, 0, 105, 210, 36, 144, 106, 221, 183, 0, 107, 178, 6, 144, 108, 198, 211, 128, 109, 145, 232, 144, 110, 166, 181, 128, 111, 113, 202, 144, 112, 134, 151, 128, 113, 90, 231, 16, 114, 102, 121, 128, 115, 58, 201, 16, 116, 70, 91, 128, 117, 26, 171, 16, 118, 47, 120, 0, 118, 250, 141, 16, 120, 15, 90, 0, 120, 218, 111, 16, 121, 239, 60, 0, 122, 186, 81, 16, 123, 207, 30, 0, 124, 163, 109, 144, 125, 175, 0, 0, 126, 131, 79, 144, 127, 142, 226, 0, 0, 1, 2, 1, 2, 1, 2, 1, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 255, 255, 156, 60, 0, 0, 255, 255, 157, 144, 0, 4, 255, 255, 171, 160, 0, 8, 255, 255, 143, 128, 0, 12, 255, 255, 171, 160, 1, 16, 255, 255, 157, 144, 0, 4, 76, 77, 84, 0, 77, 83, 84, 0, 67, 83, 84, 0, 80, 83, 84, 0, 77, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 77, 83, 84, 55, 77, 68, 84, 44, 77, 52, 46, 49, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/Mexico/General": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 99, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 165, 182, 232, 112, 175, 242, 110, 224, 182, 102, 86, 96, 183, 67, 210, 96, 184, 12, 54, 96, 184, 253, 134, 240, 197, 222, 176, 96, 198, 151, 52, 80, 201, 85, 241, 224, 201, 234, 221, 80, 207, 2, 198, 224, 207, 183, 86, 80, 218, 153, 21, 224, 219, 118, 131, 208, 49, 103, 118, 0, 50, 115, 8, 112, 51, 71, 88, 0, 52, 82, 234, 112, 53, 39, 58, 0, 54, 50, 204, 112, 55, 7, 28, 0, 56, 27, 232, 240, 56, 230, 254, 0, 57, 251, 202, 240, 58, 245, 4, 128, 59, 182, 194, 240, 60, 175, 252, 128, 61, 187, 142, 240, 62, 143, 222, 128, 63, 155, 112, 240, 64, 111, 192, 128, 65, 132, 141, 112, 66, 79, 162, 128, 67, 100, 111, 112, 68, 47, 132, 128, 69, 68, 81, 112, 70, 15, 102, 128, 71, 36, 51, 112, 71, 248, 131, 0, 73, 4, 21, 112, 73, 216, 101, 0, 74, 227, 247, 112, 75, 184, 71, 0, 76, 205, 19, 240, 77, 152, 41, 0, 78, 172, 245, 240, 79, 120, 11, 0, 80, 140, 215, 240, 81, 97, 39, 128, 82, 108, 185, 240, 83, 65, 9, 128, 84, 76, 155, 240, 85, 32, 235, 128, 86, 44, 125, 240, 87, 0, 205, 128, 88, 21, 154, 112, 88, 224, 175, 128, 89, 245, 124, 112, 90, 192, 145, 128, 91, 213, 94, 112, 92, 169, 174, 0, 93, 181, 64, 112, 94, 137, 144, 0, 95, 149, 34, 112, 96, 105, 114, 0, 97, 126, 62, 240, 98, 73, 84, 0, 99, 94, 32, 240, 100, 41, 54, 0, 101, 62, 2, 240, 102, 18, 82, 128, 103, 29, 228, 240, 103, 242, 52, 128, 104, 253, 198, 240, 105, 210, 22, 128, 106, 221, 168, 240, 107, 177, 248, 128, 108, 198, 197, 112, 109, 145, 218, 128, 110, 166, 167, 112, 111, 113, 188, 128, 112, 134, 137, 112, 113, 90, 217, 0, 114, 102, 107, 112, 115, 58, 187, 0, 116, 70, 77, 112, 117, 26, 157, 0, 118, 47, 105, 240, 118, 250, 127, 0, 120, 15, 75, 240, 120, 218, 97, 0, 121, 239, 45, 240, 122, 186, 67, 0, 123, 207, 15, 240, 124, 163, 95, 128, 125, 174, 241, 240, 126, 131, 65, 128, 127, 142, 211, 240, 0, 1, 2, 1, 2, 1, 2, 3, 2, 3, 2, 4, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 255, 255, 163, 12, 0, 0, 255, 255, 157, 144, 0, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 76, 77, 84, 0, 77, 83, 84, 0, 67, 83, 84, 0, 67, 68, 84, 0, 67, 87, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 52, 46, 49, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/NZ": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, 0, 7, 0, 0, 0, 19, 128, 0, 0, 0, 176, 180, 178, 232, 177, 81, 135, 88, 178, 120, 229, 104, 179, 67, 229, 96, 180, 88, 199, 104, 181, 35, 199, 96, 182, 56, 169, 104, 183, 3, 169, 96, 184, 24, 139, 104, 184, 236, 197, 224, 185, 248, 109, 104, 186, 204, 167, 224, 187, 216, 79, 104, 188, 227, 232, 224, 189, 174, 246, 232, 190, 195, 202, 224, 191, 142, 216, 232, 192, 163, 172, 224, 193, 110, 186, 232, 194, 131, 142, 224, 195, 78, 156, 232, 196, 99, 112, 224, 197, 46, 126, 232, 198, 76, 141, 96, 199, 14, 96, 232, 200, 44, 111, 96, 200, 247, 125, 104, 210, 218, 154, 64, 9, 24, 253, 224, 9, 172, 165, 224, 10, 239, 165, 96, 11, 158, 252, 224, 12, 216, 193, 224, 13, 126, 222, 224, 14, 184, 163, 224, 15, 94, 192, 224, 16, 152, 133, 224, 17, 62, 162, 224, 18, 120, 103, 224, 19, 30, 132, 224, 20, 88, 73, 224, 20, 254, 102, 224, 22, 56, 43, 224, 22, 231, 131, 96, 24, 33, 72, 96, 24, 199, 101, 96, 26, 1, 42, 96, 26, 167, 71, 96, 27, 225, 12, 96, 28, 135, 41, 96, 29, 192, 238, 96, 30, 103, 11, 96, 31, 160, 208, 96, 32, 70, 237, 96, 33, 128, 178, 96, 34, 48, 9, 224, 35, 105, 206, 224, 36, 15, 235, 224, 37, 46, 1, 96, 38, 2, 66, 224, 39, 13, 227, 96, 39, 226, 36, 224, 40, 237, 197, 96, 41, 194, 6, 224, 42, 205, 167, 96, 43, 171, 35, 96, 44, 173, 137, 96, 45, 139, 5, 96, 46, 141, 107, 96, 47, 106, 231, 96, 48, 109, 77, 96, 49, 74, 201, 96, 50, 86, 105, 224, 51, 42, 171, 96, 52, 54, 75, 224, 53, 10, 141, 96, 54, 22, 45, 224, 54, 243, 169, 224, 55, 246, 15, 224, 56, 211, 139, 224, 57, 213, 241, 224, 58, 179, 109, 224, 59, 191, 14, 96, 60, 147, 79, 224, 61, 158, 240, 96, 62, 115, 49, 224, 63, 126, 210, 96, 64, 92, 78, 96, 65, 94, 180, 96, 66, 60, 48, 96, 67, 62, 150, 96, 68, 28, 18, 96, 69, 30, 120, 96, 69, 251, 244, 96, 70, 254, 90, 96, 71, 247, 133, 224, 72, 222, 60, 96, 73, 215, 103, 224, 74, 190, 30, 96, 75, 183, 73, 224, 76, 158, 0, 96, 77, 151, 43, 224, 78, 125, 226, 96, 79, 119, 13, 224, 80, 102, 254, 224, 81, 96, 42, 96, 82, 70, 224, 224, 83, 64, 12, 96, 84, 38, 194, 224, 85, 31, 238, 96, 86, 6, 164, 224, 86, 255, 208, 96, 87, 230, 134, 224, 88, 223, 178, 96, 89, 198, 104, 224, 90, 191, 148, 96, 91, 175, 133, 96, 92, 168, 176, 224, 93, 143, 103, 96, 94, 136, 146, 224, 95, 111, 73, 96, 96, 104, 116, 224, 97, 79, 43, 96, 98, 72, 86, 224, 99, 47, 13, 96, 100, 40, 56, 224, 101, 14, 239, 96, 102, 17, 85, 96, 102, 248, 11, 224, 103, 241, 55, 96, 104, 215, 237, 224, 105, 209, 25, 96, 106, 183, 207, 224, 107, 176, 251, 96, 108, 151, 177, 224, 109, 144, 221, 96, 110, 119, 147, 224, 111, 112, 191, 96, 112, 96, 176, 96, 113, 89, 219, 224, 114, 64, 146, 96, 115, 57, 189, 224, 116, 32, 116, 96, 117, 25, 159, 224, 118, 0, 86, 96, 118, 249, 129, 224, 119, 224, 56, 96, 120, 217, 99, 224, 121, 192, 26, 96, 122, 185, 69, 224, 123, 169, 54, 224, 124, 162, 98, 96, 125, 137, 24, 224, 126, 130, 68, 96, 127, 104, 250, 224, 2, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 6, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 0, 0, 163, 216, 0, 0, 0, 0, 175, 200, 1, 4, 0, 0, 161, 184, 0, 9, 0, 0, 168, 192, 1, 4, 0, 0, 182, 208, 1, 14, 0, 0, 168, 192, 0, 4, 0, 0, 168, 192, 0, 4, 76, 77, 84, 0, 78, 90, 83, 84, 0, 78, 90, 77, 84, 0, 78, 90, 68, 84, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 10, 78, 90, 83, 84, 45, 49, 50, 78, 90, 68, 84, 44, 77, 57, 46, 53, 46, 48, 44, 77, 52, 46, 49, 46, 48, 47, 51, 10}, - - "zoneinfo/NZ-CHAT": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 130, 0, 0, 0, 5, 0, 0, 0, 22, 128, 0, 0, 0, 210, 218, 150, 188, 9, 24, 253, 224, 9, 172, 165, 224, 10, 239, 165, 96, 11, 158, 252, 224, 12, 216, 193, 224, 13, 126, 222, 224, 14, 184, 163, 224, 15, 94, 192, 224, 16, 152, 133, 224, 17, 62, 162, 224, 18, 120, 103, 224, 19, 30, 132, 224, 20, 88, 73, 224, 20, 254, 102, 224, 22, 56, 43, 224, 22, 231, 131, 96, 24, 33, 72, 96, 24, 199, 101, 96, 26, 1, 42, 96, 26, 167, 71, 96, 27, 225, 12, 96, 28, 135, 41, 96, 29, 192, 238, 96, 30, 103, 11, 96, 31, 160, 208, 96, 32, 70, 237, 96, 33, 128, 178, 96, 34, 48, 9, 224, 35, 105, 206, 224, 36, 15, 235, 224, 37, 46, 1, 96, 38, 2, 66, 224, 39, 13, 227, 96, 39, 226, 36, 224, 40, 237, 197, 96, 41, 194, 6, 224, 42, 205, 167, 96, 43, 171, 35, 96, 44, 173, 137, 96, 45, 139, 5, 96, 46, 141, 107, 96, 47, 106, 231, 96, 48, 109, 77, 96, 49, 74, 201, 96, 50, 86, 105, 224, 51, 42, 171, 96, 52, 54, 75, 224, 53, 10, 141, 96, 54, 22, 45, 224, 54, 243, 169, 224, 55, 246, 15, 224, 56, 211, 139, 224, 57, 213, 241, 224, 58, 179, 109, 224, 59, 191, 14, 96, 60, 147, 79, 224, 61, 158, 240, 96, 62, 115, 49, 224, 63, 126, 210, 96, 64, 92, 78, 96, 65, 94, 180, 96, 66, 60, 48, 96, 67, 62, 150, 96, 68, 28, 18, 96, 69, 30, 120, 96, 69, 251, 244, 96, 70, 254, 90, 96, 71, 247, 133, 224, 72, 222, 60, 96, 73, 215, 103, 224, 74, 190, 30, 96, 75, 183, 73, 224, 76, 158, 0, 96, 77, 151, 43, 224, 78, 125, 226, 96, 79, 119, 13, 224, 80, 102, 254, 224, 81, 96, 42, 96, 82, 70, 224, 224, 83, 64, 12, 96, 84, 38, 194, 224, 85, 31, 238, 96, 86, 6, 164, 224, 86, 255, 208, 96, 87, 230, 134, 224, 88, 223, 178, 96, 89, 198, 104, 224, 90, 191, 148, 96, 91, 175, 133, 96, 92, 168, 176, 224, 93, 143, 103, 96, 94, 136, 146, 224, 95, 111, 73, 96, 96, 104, 116, 224, 97, 79, 43, 96, 98, 72, 86, 224, 99, 47, 13, 96, 100, 40, 56, 224, 101, 14, 239, 96, 102, 17, 85, 96, 102, 248, 11, 224, 103, 241, 55, 96, 104, 215, 237, 224, 105, 209, 25, 96, 106, 183, 207, 224, 107, 176, 251, 96, 108, 151, 177, 224, 109, 144, 221, 96, 110, 119, 147, 224, 111, 112, 191, 96, 112, 96, 176, 96, 113, 89, 219, 224, 114, 64, 146, 96, 115, 57, 189, 224, 116, 32, 116, 96, 117, 25, 159, 224, 118, 0, 86, 96, 118, 249, 129, 224, 119, 224, 56, 96, 120, 217, 99, 224, 121, 192, 26, 96, 122, 185, 69, 224, 123, 169, 54, 224, 124, 162, 98, 96, 125, 137, 24, 224, 126, 130, 68, 96, 127, 104, 250, 224, 127, 255, 255, 255, 1, 4, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 2, 0, 0, 171, 252, 0, 0, 0, 0, 172, 68, 0, 4, 0, 0, 193, 92, 1, 10, 0, 0, 179, 76, 0, 16, 0, 0, 179, 76, 0, 16, 76, 77, 84, 0, 43, 49, 50, 49, 53, 0, 43, 49, 51, 52, 53, 0, 43, 49, 50, 52, 53, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 50, 52, 53, 62, 45, 49, 50, 58, 52, 53, 60, 43, 49, 51, 52, 53, 62, 44, 77, 57, 46, 53, 46, 48, 47, 50, 58, 52, 53, 44, 77, 52, 46, 49, 46, 48, 47, 51, 58, 52, 53, 10}, - - "zoneinfo/Navajo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 158, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 158, 166, 58, 144, 159, 187, 7, 128, 160, 134, 28, 144, 161, 154, 233, 128, 162, 101, 254, 144, 163, 132, 6, 0, 164, 69, 224, 144, 164, 143, 166, 128, 203, 137, 12, 144, 210, 35, 244, 112, 210, 97, 24, 0, 247, 47, 118, 144, 248, 40, 148, 0, 249, 15, 88, 144, 250, 8, 118, 0, 250, 248, 117, 16, 251, 232, 88, 0, 252, 216, 87, 16, 253, 200, 58, 0, 254, 184, 57, 16, 255, 168, 28, 0, 0, 152, 27, 16, 1, 135, 254, 0, 2, 119, 253, 16, 3, 113, 26, 128, 4, 97, 25, 144, 5, 80, 252, 128, 6, 64, 251, 144, 7, 48, 222, 128, 7, 141, 53, 144, 9, 16, 192, 128, 9, 173, 177, 16, 10, 240, 162, 128, 11, 224, 161, 144, 12, 217, 191, 0, 13, 192, 131, 144, 14, 185, 161, 0, 15, 169, 160, 16, 16, 153, 131, 0, 17, 137, 130, 16, 18, 121, 101, 0, 19, 105, 100, 16, 20, 89, 71, 0, 21, 73, 70, 16, 22, 57, 41, 0, 23, 41, 40, 16, 24, 34, 69, 128, 25, 9, 10, 16, 26, 2, 39, 128, 26, 242, 38, 144, 27, 226, 9, 128, 28, 210, 8, 144, 29, 193, 235, 128, 30, 177, 234, 144, 31, 161, 205, 128, 32, 118, 29, 16, 33, 129, 175, 128, 34, 85, 255, 16, 35, 106, 204, 0, 36, 53, 225, 16, 37, 74, 174, 0, 38, 21, 195, 16, 39, 42, 144, 0, 39, 254, 223, 144, 41, 10, 114, 0, 41, 222, 193, 144, 42, 234, 84, 0, 43, 190, 163, 144, 44, 211, 112, 128, 45, 158, 133, 144, 46, 179, 82, 128, 47, 126, 103, 144, 48, 147, 52, 128, 49, 103, 132, 16, 50, 115, 22, 128, 51, 71, 102, 16, 52, 82, 248, 128, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 231, 12, 16, 57, 251, 217, 0, 58, 198, 238, 16, 59, 219, 187, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 206, 144, 65, 132, 155, 128, 66, 79, 176, 144, 67, 100, 125, 128, 68, 47, 146, 144, 69, 68, 95, 128, 69, 243, 197, 16, 71, 45, 124, 0, 71, 211, 167, 16, 73, 13, 94, 0, 73, 179, 137, 16, 74, 237, 64, 0, 75, 156, 165, 144, 76, 214, 92, 128, 77, 124, 135, 144, 78, 182, 62, 128, 79, 92, 105, 144, 80, 150, 32, 128, 81, 60, 75, 144, 82, 118, 2, 128, 83, 28, 45, 144, 84, 85, 228, 128, 84, 252, 15, 144, 86, 53, 198, 128, 86, 229, 44, 16, 88, 30, 227, 0, 88, 197, 14, 16, 89, 254, 197, 0, 90, 164, 240, 16, 91, 222, 167, 0, 92, 132, 210, 16, 93, 190, 137, 0, 94, 100, 180, 16, 95, 158, 107, 0, 96, 77, 208, 144, 97, 135, 135, 128, 98, 45, 178, 144, 99, 103, 105, 128, 100, 13, 148, 144, 101, 71, 75, 128, 101, 237, 118, 144, 103, 39, 45, 128, 103, 205, 88, 144, 105, 7, 15, 128, 105, 173, 58, 144, 106, 230, 241, 128, 107, 150, 87, 16, 108, 208, 14, 0, 109, 118, 57, 16, 110, 175, 240, 0, 111, 86, 27, 16, 112, 143, 210, 0, 113, 53, 253, 16, 114, 111, 180, 0, 115, 21, 223, 16, 116, 79, 150, 0, 116, 254, 251, 144, 118, 56, 178, 128, 118, 222, 221, 144, 120, 24, 148, 128, 120, 190, 191, 144, 121, 248, 118, 128, 122, 158, 161, 144, 123, 216, 88, 128, 124, 126, 131, 144, 125, 184, 58, 128, 126, 94, 101, 144, 127, 152, 28, 128, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 157, 148, 0, 0, 255, 255, 171, 160, 1, 4, 255, 255, 157, 144, 0, 8, 255, 255, 171, 160, 1, 12, 255, 255, 171, 160, 1, 16, 76, 77, 84, 0, 77, 68, 84, 0, 77, 83, 84, 0, 77, 87, 84, 0, 77, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 77, 83, 84, 55, 77, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/PRC": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 200, 92, 1, 128, 200, 250, 39, 112, 201, 213, 14, 128, 202, 219, 90, 240, 30, 186, 54, 0, 31, 105, 127, 112, 32, 126, 104, 128, 33, 73, 97, 112, 34, 94, 74, 128, 35, 41, 67, 112, 36, 71, 103, 0, 37, 18, 95, 240, 38, 39, 73, 0, 38, 242, 65, 240, 40, 7, 43, 0, 40, 210, 35, 240, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 0, 0, 113, 215, 0, 0, 0, 0, 126, 144, 1, 4, 0, 0, 112, 128, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 45, 56, 10}, - - "zoneinfo/PST8PDT": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 149, 0, 0, 0, 4, 0, 0, 0, 16, 158, 166, 72, 160, 159, 187, 21, 144, 160, 134, 42, 160, 161, 154, 247, 144, 203, 137, 26, 160, 210, 35, 244, 112, 210, 97, 38, 16, 250, 248, 131, 32, 251, 232, 102, 16, 252, 216, 101, 32, 253, 200, 72, 16, 254, 184, 71, 32, 255, 168, 42, 16, 0, 152, 41, 32, 1, 136, 12, 16, 2, 120, 11, 32, 3, 113, 40, 144, 4, 97, 39, 160, 5, 81, 10, 144, 6, 65, 9, 160, 7, 48, 236, 144, 7, 141, 67, 160, 9, 16, 206, 144, 9, 173, 191, 32, 10, 240, 176, 144, 11, 224, 175, 160, 12, 217, 205, 16, 13, 192, 145, 160, 14, 185, 175, 16, 15, 169, 174, 32, 16, 153, 145, 16, 17, 137, 144, 32, 18, 121, 115, 16, 19, 105, 114, 32, 20, 89, 85, 16, 21, 73, 84, 32, 22, 57, 55, 16, 23, 41, 54, 32, 24, 34, 83, 144, 25, 9, 24, 32, 26, 2, 53, 144, 26, 242, 52, 160, 27, 226, 23, 144, 28, 210, 22, 160, 29, 193, 249, 144, 30, 177, 248, 160, 31, 161, 219, 144, 32, 118, 43, 32, 33, 129, 189, 144, 34, 86, 13, 32, 35, 106, 218, 16, 36, 53, 239, 32, 37, 74, 188, 16, 38, 21, 209, 32, 39, 42, 158, 16, 39, 254, 237, 160, 41, 10, 128, 16, 41, 222, 207, 160, 42, 234, 98, 16, 43, 190, 177, 160, 44, 211, 126, 144, 45, 158, 147, 160, 46, 179, 96, 144, 47, 126, 117, 160, 48, 147, 66, 144, 49, 103, 146, 32, 50, 115, 36, 144, 51, 71, 116, 32, 52, 83, 6, 144, 53, 39, 86, 32, 54, 50, 232, 144, 55, 7, 56, 32, 56, 28, 5, 16, 56, 231, 26, 32, 57, 251, 231, 16, 58, 198, 252, 32, 59, 219, 201, 16, 60, 176, 24, 160, 61, 187, 171, 16, 62, 143, 250, 160, 63, 155, 141, 16, 64, 111, 220, 160, 65, 132, 169, 144, 66, 79, 190, 160, 67, 100, 139, 144, 68, 47, 160, 160, 69, 68, 109, 144, 69, 243, 211, 32, 71, 45, 138, 16, 71, 211, 181, 32, 73, 13, 108, 16, 73, 179, 151, 32, 74, 237, 78, 16, 75, 156, 179, 160, 76, 214, 106, 144, 77, 124, 149, 160, 78, 182, 76, 144, 79, 92, 119, 160, 80, 150, 46, 144, 81, 60, 89, 160, 82, 118, 16, 144, 83, 28, 59, 160, 84, 85, 242, 144, 84, 252, 29, 160, 86, 53, 212, 144, 86, 229, 58, 32, 88, 30, 241, 16, 88, 197, 28, 32, 89, 254, 211, 16, 90, 164, 254, 32, 91, 222, 181, 16, 92, 132, 224, 32, 93, 190, 151, 16, 94, 100, 194, 32, 95, 158, 121, 16, 96, 77, 222, 160, 97, 135, 149, 144, 98, 45, 192, 160, 99, 103, 119, 144, 100, 13, 162, 160, 101, 71, 89, 144, 101, 237, 132, 160, 103, 39, 59, 144, 103, 205, 102, 160, 105, 7, 29, 144, 105, 173, 72, 160, 106, 230, 255, 144, 107, 150, 101, 32, 108, 208, 28, 16, 109, 118, 71, 32, 110, 175, 254, 16, 111, 86, 41, 32, 112, 143, 224, 16, 113, 54, 11, 32, 114, 111, 194, 16, 115, 21, 237, 32, 116, 79, 164, 16, 116, 255, 9, 160, 118, 56, 192, 144, 118, 222, 235, 160, 120, 24, 162, 144, 120, 190, 205, 160, 121, 248, 132, 144, 122, 158, 175, 160, 123, 216, 102, 144, 124, 126, 145, 160, 125, 184, 72, 144, 126, 94, 115, 160, 127, 152, 42, 144, 0, 1, 0, 1, 2, 3, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 255, 255, 157, 144, 1, 0, 255, 255, 143, 128, 0, 4, 255, 255, 157, 144, 1, 8, 255, 255, 157, 144, 1, 12, 80, 68, 84, 0, 80, 83, 84, 0, 80, 87, 84, 0, 80, 80, 84, 0, 0, 0, 0, 1, 0, 0, 0, 1, 10, 80, 83, 84, 56, 80, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/Pacific/Apia": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 60, 0, 0, 0, 7, 0, 0, 0, 26, 128, 0, 0, 0, 145, 5, 252, 0, 218, 98, 4, 56, 76, 159, 39, 176, 77, 151, 43, 224, 78, 125, 226, 96, 78, 253, 139, 160, 79, 119, 13, 224, 80, 102, 254, 224, 81, 96, 42, 96, 82, 70, 224, 224, 83, 64, 12, 96, 84, 38, 194, 224, 85, 31, 238, 96, 86, 6, 164, 224, 86, 255, 208, 96, 87, 230, 134, 224, 88, 223, 178, 96, 89, 198, 104, 224, 90, 191, 148, 96, 91, 175, 133, 96, 92, 168, 176, 224, 93, 143, 103, 96, 94, 136, 146, 224, 95, 111, 73, 96, 96, 104, 116, 224, 97, 79, 43, 96, 98, 72, 86, 224, 99, 47, 13, 96, 100, 40, 56, 224, 101, 14, 239, 96, 102, 17, 85, 96, 102, 248, 11, 224, 103, 241, 55, 96, 104, 215, 237, 224, 105, 209, 25, 96, 106, 183, 207, 224, 107, 176, 251, 96, 108, 151, 177, 224, 109, 144, 221, 96, 110, 119, 147, 224, 111, 112, 191, 96, 112, 96, 176, 96, 113, 89, 219, 224, 114, 64, 146, 96, 115, 57, 189, 224, 116, 32, 116, 96, 117, 25, 159, 224, 118, 0, 86, 96, 118, 249, 129, 224, 119, 224, 56, 96, 120, 217, 99, 224, 121, 192, 26, 96, 122, 185, 69, 224, 123, 169, 54, 224, 124, 162, 98, 96, 125, 137, 24, 224, 126, 130, 68, 96, 127, 104, 250, 224, 127, 255, 255, 255, 1, 2, 4, 3, 4, 3, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 6, 0, 0, 176, 128, 0, 0, 255, 255, 95, 0, 0, 0, 255, 255, 94, 72, 0, 4, 255, 255, 115, 96, 1, 10, 255, 255, 101, 80, 0, 14, 0, 0, 182, 208, 0, 18, 0, 0, 196, 224, 1, 22, 76, 77, 84, 0, 45, 49, 49, 51, 48, 0, 45, 49, 48, 0, 45, 49, 49, 0, 43, 49, 51, 0, 43, 49, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 51, 62, 45, 49, 51, 60, 43, 49, 52, 62, 44, 77, 57, 46, 53, 46, 48, 47, 51, 44, 77, 52, 46, 49, 46, 48, 47, 52, 10}, - - "zoneinfo/Pacific/Auckland": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 156, 0, 0, 0, 7, 0, 0, 0, 19, 128, 0, 0, 0, 176, 180, 178, 232, 177, 81, 135, 88, 178, 120, 229, 104, 179, 67, 229, 96, 180, 88, 199, 104, 181, 35, 199, 96, 182, 56, 169, 104, 183, 3, 169, 96, 184, 24, 139, 104, 184, 236, 197, 224, 185, 248, 109, 104, 186, 204, 167, 224, 187, 216, 79, 104, 188, 227, 232, 224, 189, 174, 246, 232, 190, 195, 202, 224, 191, 142, 216, 232, 192, 163, 172, 224, 193, 110, 186, 232, 194, 131, 142, 224, 195, 78, 156, 232, 196, 99, 112, 224, 197, 46, 126, 232, 198, 76, 141, 96, 199, 14, 96, 232, 200, 44, 111, 96, 200, 247, 125, 104, 210, 218, 154, 64, 9, 24, 253, 224, 9, 172, 165, 224, 10, 239, 165, 96, 11, 158, 252, 224, 12, 216, 193, 224, 13, 126, 222, 224, 14, 184, 163, 224, 15, 94, 192, 224, 16, 152, 133, 224, 17, 62, 162, 224, 18, 120, 103, 224, 19, 30, 132, 224, 20, 88, 73, 224, 20, 254, 102, 224, 22, 56, 43, 224, 22, 231, 131, 96, 24, 33, 72, 96, 24, 199, 101, 96, 26, 1, 42, 96, 26, 167, 71, 96, 27, 225, 12, 96, 28, 135, 41, 96, 29, 192, 238, 96, 30, 103, 11, 96, 31, 160, 208, 96, 32, 70, 237, 96, 33, 128, 178, 96, 34, 48, 9, 224, 35, 105, 206, 224, 36, 15, 235, 224, 37, 46, 1, 96, 38, 2, 66, 224, 39, 13, 227, 96, 39, 226, 36, 224, 40, 237, 197, 96, 41, 194, 6, 224, 42, 205, 167, 96, 43, 171, 35, 96, 44, 173, 137, 96, 45, 139, 5, 96, 46, 141, 107, 96, 47, 106, 231, 96, 48, 109, 77, 96, 49, 74, 201, 96, 50, 86, 105, 224, 51, 42, 171, 96, 52, 54, 75, 224, 53, 10, 141, 96, 54, 22, 45, 224, 54, 243, 169, 224, 55, 246, 15, 224, 56, 211, 139, 224, 57, 213, 241, 224, 58, 179, 109, 224, 59, 191, 14, 96, 60, 147, 79, 224, 61, 158, 240, 96, 62, 115, 49, 224, 63, 126, 210, 96, 64, 92, 78, 96, 65, 94, 180, 96, 66, 60, 48, 96, 67, 62, 150, 96, 68, 28, 18, 96, 69, 30, 120, 96, 69, 251, 244, 96, 70, 254, 90, 96, 71, 247, 133, 224, 72, 222, 60, 96, 73, 215, 103, 224, 74, 190, 30, 96, 75, 183, 73, 224, 76, 158, 0, 96, 77, 151, 43, 224, 78, 125, 226, 96, 79, 119, 13, 224, 80, 102, 254, 224, 81, 96, 42, 96, 82, 70, 224, 224, 83, 64, 12, 96, 84, 38, 194, 224, 85, 31, 238, 96, 86, 6, 164, 224, 86, 255, 208, 96, 87, 230, 134, 224, 88, 223, 178, 96, 89, 198, 104, 224, 90, 191, 148, 96, 91, 175, 133, 96, 92, 168, 176, 224, 93, 143, 103, 96, 94, 136, 146, 224, 95, 111, 73, 96, 96, 104, 116, 224, 97, 79, 43, 96, 98, 72, 86, 224, 99, 47, 13, 96, 100, 40, 56, 224, 101, 14, 239, 96, 102, 17, 85, 96, 102, 248, 11, 224, 103, 241, 55, 96, 104, 215, 237, 224, 105, 209, 25, 96, 106, 183, 207, 224, 107, 176, 251, 96, 108, 151, 177, 224, 109, 144, 221, 96, 110, 119, 147, 224, 111, 112, 191, 96, 112, 96, 176, 96, 113, 89, 219, 224, 114, 64, 146, 96, 115, 57, 189, 224, 116, 32, 116, 96, 117, 25, 159, 224, 118, 0, 86, 96, 118, 249, 129, 224, 119, 224, 56, 96, 120, 217, 99, 224, 121, 192, 26, 96, 122, 185, 69, 224, 123, 169, 54, 224, 124, 162, 98, 96, 125, 137, 24, 224, 126, 130, 68, 96, 127, 104, 250, 224, 2, 1, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 6, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 0, 0, 163, 216, 0, 0, 0, 0, 175, 200, 1, 4, 0, 0, 161, 184, 0, 9, 0, 0, 168, 192, 1, 4, 0, 0, 182, 208, 1, 14, 0, 0, 168, 192, 0, 4, 0, 0, 168, 192, 0, 4, 76, 77, 84, 0, 78, 90, 83, 84, 0, 78, 90, 77, 84, 0, 78, 90, 68, 84, 0, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 10, 78, 90, 83, 84, 45, 49, 50, 78, 90, 68, 84, 44, 77, 57, 46, 53, 46, 48, 44, 77, 52, 46, 49, 46, 48, 47, 51, 10}, - - "zoneinfo/Pacific/Bougainville": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 4, 0, 0, 0, 17, 128, 0, 0, 0, 204, 67, 54, 96, 210, 43, 108, 240, 84, 158, 215, 128, 127, 255, 255, 255, 1, 2, 1, 3, 3, 0, 0, 137, 240, 0, 0, 0, 0, 140, 160, 0, 5, 0, 0, 126, 144, 0, 9, 0, 0, 154, 176, 0, 13, 80, 77, 77, 84, 0, 43, 49, 48, 0, 43, 48, 57, 0, 43, 49, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 49, 62, 45, 49, 49, 10}, - - "zoneinfo/Pacific/Chatham": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 130, 0, 0, 0, 5, 0, 0, 0, 22, 128, 0, 0, 0, 210, 218, 150, 188, 9, 24, 253, 224, 9, 172, 165, 224, 10, 239, 165, 96, 11, 158, 252, 224, 12, 216, 193, 224, 13, 126, 222, 224, 14, 184, 163, 224, 15, 94, 192, 224, 16, 152, 133, 224, 17, 62, 162, 224, 18, 120, 103, 224, 19, 30, 132, 224, 20, 88, 73, 224, 20, 254, 102, 224, 22, 56, 43, 224, 22, 231, 131, 96, 24, 33, 72, 96, 24, 199, 101, 96, 26, 1, 42, 96, 26, 167, 71, 96, 27, 225, 12, 96, 28, 135, 41, 96, 29, 192, 238, 96, 30, 103, 11, 96, 31, 160, 208, 96, 32, 70, 237, 96, 33, 128, 178, 96, 34, 48, 9, 224, 35, 105, 206, 224, 36, 15, 235, 224, 37, 46, 1, 96, 38, 2, 66, 224, 39, 13, 227, 96, 39, 226, 36, 224, 40, 237, 197, 96, 41, 194, 6, 224, 42, 205, 167, 96, 43, 171, 35, 96, 44, 173, 137, 96, 45, 139, 5, 96, 46, 141, 107, 96, 47, 106, 231, 96, 48, 109, 77, 96, 49, 74, 201, 96, 50, 86, 105, 224, 51, 42, 171, 96, 52, 54, 75, 224, 53, 10, 141, 96, 54, 22, 45, 224, 54, 243, 169, 224, 55, 246, 15, 224, 56, 211, 139, 224, 57, 213, 241, 224, 58, 179, 109, 224, 59, 191, 14, 96, 60, 147, 79, 224, 61, 158, 240, 96, 62, 115, 49, 224, 63, 126, 210, 96, 64, 92, 78, 96, 65, 94, 180, 96, 66, 60, 48, 96, 67, 62, 150, 96, 68, 28, 18, 96, 69, 30, 120, 96, 69, 251, 244, 96, 70, 254, 90, 96, 71, 247, 133, 224, 72, 222, 60, 96, 73, 215, 103, 224, 74, 190, 30, 96, 75, 183, 73, 224, 76, 158, 0, 96, 77, 151, 43, 224, 78, 125, 226, 96, 79, 119, 13, 224, 80, 102, 254, 224, 81, 96, 42, 96, 82, 70, 224, 224, 83, 64, 12, 96, 84, 38, 194, 224, 85, 31, 238, 96, 86, 6, 164, 224, 86, 255, 208, 96, 87, 230, 134, 224, 88, 223, 178, 96, 89, 198, 104, 224, 90, 191, 148, 96, 91, 175, 133, 96, 92, 168, 176, 224, 93, 143, 103, 96, 94, 136, 146, 224, 95, 111, 73, 96, 96, 104, 116, 224, 97, 79, 43, 96, 98, 72, 86, 224, 99, 47, 13, 96, 100, 40, 56, 224, 101, 14, 239, 96, 102, 17, 85, 96, 102, 248, 11, 224, 103, 241, 55, 96, 104, 215, 237, 224, 105, 209, 25, 96, 106, 183, 207, 224, 107, 176, 251, 96, 108, 151, 177, 224, 109, 144, 221, 96, 110, 119, 147, 224, 111, 112, 191, 96, 112, 96, 176, 96, 113, 89, 219, 224, 114, 64, 146, 96, 115, 57, 189, 224, 116, 32, 116, 96, 117, 25, 159, 224, 118, 0, 86, 96, 118, 249, 129, 224, 119, 224, 56, 96, 120, 217, 99, 224, 121, 192, 26, 96, 122, 185, 69, 224, 123, 169, 54, 224, 124, 162, 98, 96, 125, 137, 24, 224, 126, 130, 68, 96, 127, 104, 250, 224, 127, 255, 255, 255, 1, 4, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 2, 0, 0, 171, 252, 0, 0, 0, 0, 172, 68, 0, 4, 0, 0, 193, 92, 1, 10, 0, 0, 179, 76, 0, 16, 0, 0, 179, 76, 0, 16, 76, 77, 84, 0, 43, 49, 50, 49, 53, 0, 43, 49, 51, 52, 53, 0, 43, 49, 50, 52, 53, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 50, 52, 53, 62, 45, 49, 50, 58, 52, 53, 60, 43, 49, 51, 52, 53, 62, 44, 77, 57, 46, 53, 46, 48, 47, 50, 58, 52, 53, 44, 77, 52, 46, 49, 46, 48, 47, 51, 58, 52, 53, 10}, - - "zoneinfo/Pacific/Chuuk": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 127, 255, 255, 255, 1, 1, 0, 0, 142, 76, 0, 0, 0, 0, 140, 160, 0, 4, 76, 77, 84, 0, 43, 49, 48, 0, 0, 0, 0, 0, 10, 60, 43, 49, 48, 62, 45, 49, 48, 10}, - - "zoneinfo/Pacific/Easter": []byte{84, 90, 105, 102, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 140, 0, 0, 0, 7, 0, 0, 0, 20, 128, 0, 0, 0, 185, 199, 64, 136, 253, 209, 60, 64, 254, 146, 250, 176, 255, 204, 205, 192, 0, 114, 220, 176, 1, 117, 80, 192, 2, 64, 73, 176, 3, 85, 50, 192, 4, 32, 43, 176, 5, 62, 79, 64, 6, 0, 13, 176, 7, 11, 188, 64, 7, 223, 239, 176, 8, 254, 19, 64, 9, 191, 209, 176, 10, 221, 245, 64, 11, 168, 238, 48, 12, 189, 215, 64, 13, 136, 208, 48, 14, 157, 185, 64, 15, 104, 178, 48, 16, 134, 213, 192, 17, 72, 148, 48, 18, 102, 183, 192, 19, 40, 118, 48, 20, 70, 153, 192, 21, 17, 146, 176, 22, 38, 123, 192, 22, 241, 116, 176, 24, 6, 93, 192, 24, 209, 86, 176, 25, 230, 63, 192, 26, 177, 56, 176, 27, 207, 92, 64, 28, 145, 26, 176, 29, 175, 62, 64, 30, 112, 252, 176, 31, 143, 32, 64, 32, 127, 3, 48, 33, 111, 2, 64, 34, 57, 251, 48, 35, 78, 228, 64, 36, 25, 221, 48, 37, 56, 0, 192, 37, 249, 191, 48, 38, 242, 248, 192, 39, 217, 161, 48, 40, 247, 196, 192, 41, 194, 189, 176, 42, 215, 166, 192, 43, 162, 159, 176, 44, 183, 136, 192, 45, 130, 129, 176, 46, 151, 106, 192, 47, 98, 99, 176, 48, 128, 135, 64, 49, 66, 69, 176, 50, 96, 105, 64, 51, 61, 215, 48, 52, 64, 75, 64, 53, 11, 68, 48, 54, 13, 184, 64, 55, 6, 213, 176, 56, 0, 15, 64, 56, 203, 8, 48, 57, 233, 43, 192, 58, 170, 234, 48, 59, 201, 13, 192, 60, 138, 204, 48, 61, 168, 239, 192, 62, 106, 174, 48, 63, 136, 209, 192, 64, 83, 202, 176, 65, 104, 179, 192, 66, 51, 172, 176, 67, 72, 149, 192, 68, 19, 142, 176, 69, 49, 178, 64, 69, 243, 112, 176, 71, 17, 148, 64, 71, 239, 2, 48, 72, 241, 118, 64, 73, 188, 111, 48, 74, 209, 88, 64, 75, 184, 0, 176, 76, 177, 58, 64, 77, 198, 7, 48, 78, 80, 130, 192, 79, 156, 174, 176, 80, 66, 217, 192, 81, 124, 144, 176, 82, 43, 246, 64, 83, 92, 114, 176, 84, 11, 216, 64, 87, 55, 230, 48, 87, 175, 236, 192, 89, 23, 200, 48, 89, 143, 206, 192, 90, 247, 170, 48, 91, 111, 176, 192, 92, 215, 140, 48, 93, 79, 146, 192, 94, 183, 110, 48, 95, 47, 116, 192, 96, 151, 80, 48, 97, 24, 145, 64, 98, 128, 108, 176, 98, 248, 115, 64, 100, 96, 78, 176, 100, 216, 85, 64, 102, 64, 48, 176, 102, 184, 55, 64, 104, 32, 18, 176, 104, 152, 25, 64, 105, 255, 244, 176, 106, 119, 251, 64, 107, 223, 214, 176, 108, 97, 23, 192, 109, 200, 243, 48, 110, 64, 249, 192, 111, 168, 213, 48, 112, 32, 219, 192, 113, 136, 183, 48, 114, 0, 189, 192, 115, 104, 153, 48, 115, 224, 159, 192, 117, 72, 123, 48, 117, 201, 188, 64, 119, 49, 151, 176, 119, 169, 158, 64, 121, 17, 121, 176, 121, 137, 128, 64, 122, 241, 91, 176, 123, 105, 98, 64, 124, 209, 61, 176, 125, 73, 68, 64, 126, 177, 31, 176, 127, 41, 38, 64, 127, 255, 255, 255, 1, 4, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 6, 255, 255, 153, 120, 0, 0, 255, 255, 153, 120, 0, 4, 255, 255, 171, 160, 1, 8, 255, 255, 157, 144, 0, 12, 255, 255, 157, 144, 0, 12, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 16, 76, 77, 84, 0, 69, 77, 84, 0, 45, 48, 54, 0, 45, 48, 55, 0, 45, 48, 53, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 1, 1, 0, 1, 1, 10, 60, 45, 48, 54, 62, 54, 60, 45, 48, 53, 62, 44, 77, 56, 46, 50, 46, 54, 47, 50, 50, 44, 77, 53, 46, 50, 46, 54, 47, 50, 50, 10}, - - "zoneinfo/Pacific/Efate": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 23, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 146, 245, 194, 180, 25, 210, 247, 208, 26, 194, 218, 192, 27, 218, 102, 208, 28, 162, 188, 192, 29, 155, 246, 80, 30, 130, 158, 192, 31, 123, 216, 80, 32, 107, 187, 64, 33, 91, 186, 80, 34, 75, 157, 64, 35, 59, 156, 80, 36, 43, 127, 64, 37, 27, 126, 80, 38, 11, 97, 64, 38, 251, 96, 80, 39, 235, 67, 64, 40, 228, 124, 208, 41, 129, 81, 64, 42, 233, 72, 208, 43, 97, 51, 64, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 0, 0, 157, 204, 0, 0, 0, 0, 168, 192, 1, 4, 0, 0, 154, 176, 0, 8, 76, 77, 84, 0, 43, 49, 50, 0, 43, 49, 49, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 49, 62, 45, 49, 49, 10}, - - "zoneinfo/Pacific/Enderbury": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 16, 128, 0, 0, 0, 18, 86, 4, 192, 47, 6, 139, 48, 127, 255, 255, 255, 1, 2, 3, 3, 255, 255, 95, 156, 0, 0, 255, 255, 87, 64, 0, 4, 255, 255, 101, 80, 0, 8, 0, 0, 182, 208, 0, 12, 76, 77, 84, 0, 45, 49, 50, 0, 45, 49, 49, 0, 43, 49, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 51, 62, 45, 49, 51, 10}, - - "zoneinfo/Pacific/Fakaofo": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 78, 253, 153, 176, 127, 255, 255, 255, 1, 2, 2, 255, 255, 95, 120, 0, 0, 255, 255, 101, 80, 0, 4, 0, 0, 182, 208, 0, 8, 76, 77, 84, 0, 45, 49, 49, 0, 43, 49, 51, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 51, 62, 45, 49, 51, 10}, - - "zoneinfo/Pacific/Fiji": []byte{84, 90, 105, 102, 51, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 65, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 154, 19, 177, 192, 54, 59, 23, 224, 54, 215, 250, 96, 56, 36, 52, 96, 56, 183, 220, 96, 75, 17, 44, 224, 75, 174, 15, 96, 76, 194, 234, 96, 77, 114, 65, 224, 78, 162, 204, 96, 79, 26, 196, 224, 80, 130, 174, 96, 80, 250, 166, 224, 82, 107, 202, 224, 82, 218, 122, 208, 84, 84, 231, 96, 84, 186, 106, 224, 86, 52, 201, 96, 86, 154, 76, 224, 88, 29, 229, 224, 88, 122, 46, 224, 89, 253, 199, 224, 90, 90, 16, 224, 91, 221, 169, 224, 92, 67, 45, 96, 93, 189, 139, 224, 94, 35, 15, 96, 95, 157, 109, 224, 96, 2, 241, 96, 97, 134, 138, 96, 97, 226, 211, 96, 99, 102, 108, 96, 99, 194, 181, 96, 101, 70, 78, 96, 101, 162, 151, 96, 103, 38, 48, 96, 103, 139, 179, 224, 105, 6, 18, 96, 105, 107, 149, 224, 106, 229, 244, 96, 107, 75, 119, 224, 108, 207, 16, 224, 109, 43, 89, 224, 110, 174, 242, 224, 111, 11, 59, 224, 112, 142, 212, 224, 112, 244, 88, 96, 114, 110, 182, 224, 114, 212, 58, 96, 116, 78, 152, 224, 116, 180, 28, 96, 118, 55, 181, 96, 118, 147, 254, 96, 120, 23, 151, 96, 120, 115, 224, 96, 121, 247, 121, 96, 122, 83, 194, 96, 123, 215, 91, 96, 124, 60, 222, 224, 125, 183, 61, 96, 126, 28, 192, 224, 127, 151, 31, 96, 127, 252, 162, 224, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 2, 0, 0, 167, 192, 0, 0, 0, 0, 182, 208, 1, 4, 0, 0, 168, 192, 0, 8, 76, 77, 84, 0, 43, 49, 51, 0, 43, 49, 50, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 50, 62, 45, 49, 50, 60, 43, 49, 51, 62, 44, 77, 49, 49, 46, 49, 46, 48, 44, 77, 49, 46, 50, 46, 49, 47, 49, 52, 55, 10}, - - "zoneinfo/Pacific/Funafuti": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 127, 255, 255, 255, 1, 1, 0, 0, 168, 4, 0, 0, 0, 0, 168, 192, 0, 4, 76, 77, 84, 0, 43, 49, 50, 0, 0, 0, 0, 0, 10, 60, 43, 49, 50, 62, 45, 49, 50, 10}, - - "zoneinfo/Pacific/Galapagos": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 12, 128, 0, 0, 0, 182, 164, 76, 128, 30, 24, 196, 80, 43, 23, 10, 224, 43, 113, 244, 80, 127, 255, 255, 255, 0, 1, 3, 2, 3, 3, 255, 255, 172, 0, 0, 0, 255, 255, 185, 176, 0, 4, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 76, 77, 84, 0, 45, 48, 53, 0, 45, 48, 54, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 54, 62, 54, 10}, - - "zoneinfo/Pacific/Gambier": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 148, 80, 72, 4, 127, 255, 255, 255, 0, 1, 1, 255, 255, 129, 124, 0, 0, 255, 255, 129, 112, 0, 4, 76, 77, 84, 0, 45, 48, 57, 0, 0, 0, 0, 0, 10, 60, 45, 48, 57, 62, 57, 10}, - - "zoneinfo/Pacific/Guadalcanal": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 148, 79, 51, 140, 127, 255, 255, 255, 0, 1, 1, 0, 0, 149, 244, 0, 0, 0, 0, 154, 176, 0, 4, 76, 77, 84, 0, 43, 49, 49, 0, 0, 0, 0, 0, 10, 60, 43, 49, 49, 62, 45, 49, 49, 10}, - - "zoneinfo/Pacific/Guam": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 13, 128, 0, 0, 0, 58, 67, 94, 96, 1, 2, 0, 0, 135, 180, 0, 0, 0, 0, 140, 160, 0, 4, 0, 0, 140, 160, 0, 8, 76, 77, 84, 0, 71, 83, 84, 0, 67, 104, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 67, 104, 83, 84, 45, 49, 48, 10}, - - "zoneinfo/Pacific/Honolulu": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 12, 128, 0, 0, 0, 187, 5, 67, 72, 187, 33, 113, 88, 203, 137, 61, 200, 210, 97, 73, 56, 213, 141, 115, 72, 1, 2, 1, 2, 1, 3, 255, 255, 108, 2, 0, 0, 255, 255, 108, 88, 0, 4, 255, 255, 122, 104, 1, 8, 255, 255, 115, 96, 0, 4, 76, 77, 84, 0, 72, 83, 84, 0, 72, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 72, 83, 84, 49, 48, 10}, - - "zoneinfo/Pacific/Johnston": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 12, 128, 0, 0, 0, 187, 5, 67, 72, 187, 33, 113, 88, 203, 137, 61, 200, 210, 97, 73, 56, 213, 141, 115, 72, 1, 2, 1, 2, 1, 3, 255, 255, 108, 2, 0, 0, 255, 255, 108, 88, 0, 4, 255, 255, 122, 104, 1, 8, 255, 255, 115, 96, 0, 4, 76, 77, 84, 0, 72, 83, 84, 0, 72, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 72, 83, 84, 49, 48, 10}, - - "zoneinfo/Pacific/Kiritimati": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 18, 128, 0, 0, 0, 18, 85, 242, 0, 47, 6, 125, 32, 127, 255, 255, 255, 1, 2, 3, 3, 255, 255, 108, 128, 0, 0, 255, 255, 106, 0, 0, 4, 255, 255, 115, 96, 0, 10, 0, 0, 196, 224, 0, 14, 76, 77, 84, 0, 45, 49, 48, 52, 48, 0, 45, 49, 48, 0, 43, 49, 52, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 52, 62, 45, 49, 52, 10}, - - "zoneinfo/Pacific/Kosrae": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 12, 128, 0, 0, 0, 255, 134, 27, 80, 54, 139, 103, 64, 127, 255, 255, 255, 1, 2, 1, 1, 0, 0, 152, 204, 0, 0, 0, 0, 154, 176, 0, 4, 0, 0, 168, 192, 0, 8, 0, 0, 154, 176, 0, 4, 76, 77, 84, 0, 43, 49, 49, 0, 43, 49, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 49, 62, 45, 49, 49, 10}, - - "zoneinfo/Pacific/Kwajalein": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 16, 128, 0, 0, 0, 255, 134, 27, 80, 44, 116, 188, 192, 127, 255, 255, 255, 1, 2, 3, 3, 0, 0, 156, 224, 0, 0, 0, 0, 154, 176, 0, 4, 255, 255, 87, 64, 0, 8, 0, 0, 168, 192, 0, 12, 76, 77, 84, 0, 43, 49, 49, 0, 45, 49, 50, 0, 43, 49, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 50, 62, 45, 49, 50, 10}, - - "zoneinfo/Pacific/Majuro": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 12, 128, 0, 0, 0, 255, 134, 27, 80, 127, 255, 255, 255, 1, 2, 2, 0, 0, 160, 128, 0, 0, 0, 0, 154, 176, 0, 4, 0, 0, 168, 192, 0, 8, 76, 77, 84, 0, 43, 49, 49, 0, 43, 49, 50, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 50, 62, 45, 49, 50, 10}, - - "zoneinfo/Pacific/Marquesas": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 10, 128, 0, 0, 0, 148, 80, 76, 72, 127, 255, 255, 255, 0, 1, 1, 255, 255, 125, 56, 0, 0, 255, 255, 122, 104, 0, 4, 76, 77, 84, 0, 45, 48, 57, 51, 48, 0, 0, 0, 0, 0, 10, 60, 45, 48, 57, 51, 48, 62, 57, 58, 51, 48, 10}, - - "zoneinfo/Pacific/Midway": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 8, 128, 0, 0, 0, 145, 5, 251, 8, 1, 2, 0, 0, 177, 120, 0, 0, 255, 255, 95, 248, 0, 0, 255, 255, 101, 80, 0, 4, 76, 77, 84, 0, 83, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 83, 83, 84, 49, 49, 10}, - - "zoneinfo/Pacific/Nauru": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 18, 128, 0, 0, 0, 163, 231, 43, 4, 203, 180, 191, 72, 208, 66, 80, 112, 17, 139, 4, 200, 127, 255, 255, 255, 0, 1, 2, 1, 3, 3, 0, 0, 156, 124, 0, 0, 0, 0, 161, 184, 0, 4, 0, 0, 126, 144, 0, 10, 0, 0, 168, 192, 0, 14, 76, 77, 84, 0, 43, 49, 49, 51, 48, 0, 43, 48, 57, 0, 43, 49, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 50, 62, 45, 49, 50, 10}, - - "zoneinfo/Pacific/Niue": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 20, 128, 0, 0, 0, 220, 67, 53, 96, 16, 116, 202, 56, 127, 255, 255, 255, 1, 2, 3, 3, 255, 255, 96, 180, 0, 0, 255, 255, 96, 160, 0, 4, 255, 255, 94, 72, 0, 10, 255, 255, 101, 80, 0, 16, 76, 77, 84, 0, 45, 49, 49, 50, 48, 0, 45, 49, 49, 51, 48, 0, 45, 49, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 49, 49, 62, 49, 49, 10}, - - "zoneinfo/Pacific/Norfolk": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 5, 0, 0, 0, 26, 128, 0, 0, 0, 220, 65, 248, 128, 9, 15, 202, 104, 9, 181, 217, 88, 86, 15, 230, 104, 127, 255, 255, 255, 1, 2, 3, 2, 4, 4, 0, 0, 157, 120, 0, 0, 0, 0, 157, 128, 0, 4, 0, 0, 161, 184, 0, 10, 0, 0, 175, 200, 1, 16, 0, 0, 154, 176, 0, 22, 76, 77, 84, 0, 43, 49, 49, 49, 50, 0, 43, 49, 49, 51, 48, 0, 43, 49, 50, 51, 48, 0, 43, 49, 49, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 49, 62, 45, 49, 49, 10}, - - "zoneinfo/Pacific/Noumea": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 5, 0, 0, 0, 12, 128, 0, 0, 0, 146, 245, 196, 116, 14, 230, 186, 80, 15, 86, 187, 192, 16, 198, 156, 80, 17, 55, 239, 64, 50, 160, 75, 240, 51, 24, 68, 112, 127, 255, 255, 255, 0, 2, 1, 2, 1, 2, 3, 4, 4, 0, 0, 156, 12, 0, 0, 0, 0, 168, 192, 1, 4, 0, 0, 154, 176, 0, 8, 0, 0, 168, 192, 1, 4, 0, 0, 154, 176, 0, 8, 76, 77, 84, 0, 43, 49, 50, 0, 43, 49, 49, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 10, 60, 43, 49, 49, 62, 45, 49, 49, 10}, - - "zoneinfo/Pacific/Pago_Pago": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 8, 128, 0, 0, 0, 145, 5, 251, 8, 1, 2, 0, 0, 177, 120, 0, 0, 255, 255, 95, 248, 0, 0, 255, 255, 101, 80, 0, 4, 76, 77, 84, 0, 83, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 83, 83, 84, 49, 49, 10}, - - "zoneinfo/Pacific/Palau": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 127, 255, 255, 255, 1, 1, 0, 0, 126, 20, 0, 0, 0, 0, 126, 144, 0, 4, 76, 77, 84, 0, 43, 48, 57, 0, 0, 0, 0, 0, 10, 60, 43, 48, 57, 62, 45, 57, 10}, - - "zoneinfo/Pacific/Pitcairn": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 14, 128, 0, 0, 0, 53, 68, 66, 8, 127, 255, 255, 255, 1, 2, 2, 255, 255, 134, 12, 0, 0, 255, 255, 136, 120, 0, 4, 255, 255, 143, 128, 0, 10, 76, 77, 84, 0, 45, 48, 56, 51, 48, 0, 45, 48, 56, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 48, 56, 62, 56, 10}, - - "zoneinfo/Pacific/Pohnpei": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 127, 255, 255, 255, 1, 1, 0, 0, 148, 84, 0, 0, 0, 0, 154, 176, 0, 4, 76, 77, 84, 0, 43, 49, 49, 0, 0, 0, 0, 0, 10, 60, 43, 49, 49, 62, 45, 49, 49, 10}, - - "zoneinfo/Pacific/Ponape": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 127, 255, 255, 255, 1, 1, 0, 0, 148, 84, 0, 0, 0, 0, 154, 176, 0, 4, 76, 77, 84, 0, 43, 49, 49, 0, 0, 0, 0, 0, 10, 60, 43, 49, 49, 62, 45, 49, 49, 10}, - - "zoneinfo/Pacific/Port_Moresby": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 9, 128, 0, 0, 0, 127, 255, 255, 255, 1, 1, 0, 0, 137, 240, 0, 0, 0, 0, 140, 160, 0, 5, 80, 77, 77, 84, 0, 43, 49, 48, 0, 0, 0, 0, 0, 10, 60, 43, 49, 48, 62, 45, 49, 48, 10}, - - "zoneinfo/Pacific/Rarotonga": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 28, 0, 0, 0, 4, 0, 0, 0, 20, 128, 0, 0, 0, 16, 172, 27, 40, 17, 63, 181, 24, 18, 121, 129, 32, 19, 31, 151, 24, 20, 89, 99, 32, 20, 255, 121, 24, 22, 57, 69, 32, 22, 232, 149, 152, 24, 34, 97, 160, 24, 200, 119, 152, 26, 2, 67, 160, 26, 168, 89, 152, 27, 226, 37, 160, 28, 136, 59, 152, 29, 194, 7, 160, 30, 104, 29, 152, 31, 161, 233, 160, 32, 71, 255, 152, 33, 129, 203, 160, 34, 49, 28, 24, 35, 106, 232, 32, 36, 16, 254, 24, 37, 74, 202, 32, 37, 240, 224, 24, 39, 42, 172, 32, 39, 208, 194, 24, 127, 255, 255, 255, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 2, 255, 255, 106, 56, 0, 0, 255, 255, 108, 88, 0, 4, 255, 255, 115, 96, 0, 10, 255, 255, 122, 104, 1, 14, 76, 77, 84, 0, 45, 49, 48, 51, 48, 0, 45, 49, 48, 0, 45, 48, 57, 51, 48, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 45, 49, 48, 62, 49, 48, 10}, - - "zoneinfo/Pacific/Saipan": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 13, 128, 0, 0, 0, 58, 67, 94, 96, 1, 2, 0, 0, 135, 180, 0, 0, 0, 0, 140, 160, 0, 4, 0, 0, 140, 160, 0, 8, 76, 77, 84, 0, 71, 83, 84, 0, 67, 104, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 67, 104, 83, 84, 45, 49, 48, 10}, - - "zoneinfo/Pacific/Samoa": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 8, 128, 0, 0, 0, 145, 5, 251, 8, 1, 2, 0, 0, 177, 120, 0, 0, 255, 255, 95, 248, 0, 0, 255, 255, 101, 80, 0, 4, 76, 77, 84, 0, 83, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 83, 83, 84, 49, 49, 10}, - - "zoneinfo/Pacific/Tahiti": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 148, 80, 85, 184, 127, 255, 255, 255, 0, 1, 1, 255, 255, 115, 200, 0, 0, 255, 255, 115, 96, 0, 4, 76, 77, 84, 0, 45, 49, 48, 0, 0, 0, 0, 0, 10, 60, 45, 49, 48, 62, 49, 48, 10}, - - "zoneinfo/Pacific/Tarawa": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 127, 255, 255, 255, 1, 1, 0, 0, 162, 52, 0, 0, 0, 0, 168, 192, 0, 4, 76, 77, 84, 0, 43, 49, 50, 0, 0, 0, 0, 0, 10, 60, 43, 49, 50, 62, 45, 49, 50, 10}, - - "zoneinfo/Pacific/Tongatapu": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 6, 0, 0, 0, 18, 128, 0, 0, 0, 201, 115, 66, 144, 55, 251, 71, 208, 56, 211, 125, 208, 58, 4, 8, 80, 58, 114, 184, 64, 59, 227, 234, 80, 60, 82, 154, 64, 88, 29, 215, 208, 88, 122, 32, 208, 127, 255, 255, 255, 1, 2, 3, 4, 5, 2, 5, 2, 5, 2, 2, 0, 0, 173, 72, 0, 0, 0, 0, 173, 112, 0, 4, 0, 0, 182, 208, 0, 10, 0, 0, 196, 224, 1, 14, 0, 0, 182, 208, 0, 10, 0, 0, 196, 224, 1, 14, 76, 77, 84, 0, 43, 49, 50, 50, 48, 0, 43, 49, 51, 0, 43, 49, 52, 0, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 49, 51, 62, 45, 49, 51, 10}, - - "zoneinfo/Pacific/Truk": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 127, 255, 255, 255, 1, 1, 0, 0, 142, 76, 0, 0, 0, 0, 140, 160, 0, 4, 76, 77, 84, 0, 43, 49, 48, 0, 0, 0, 0, 0, 10, 60, 43, 49, 48, 62, 45, 49, 48, 10}, - - "zoneinfo/Pacific/Wake": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 127, 255, 255, 255, 1, 1, 0, 0, 156, 52, 0, 0, 0, 0, 168, 192, 0, 4, 76, 77, 84, 0, 43, 49, 50, 0, 0, 0, 0, 0, 10, 60, 43, 49, 50, 62, 45, 49, 50, 10}, - - "zoneinfo/Pacific/Wallis": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 127, 255, 255, 255, 1, 1, 0, 0, 172, 88, 0, 0, 0, 0, 168, 192, 0, 4, 76, 77, 84, 0, 43, 49, 50, 0, 0, 0, 0, 0, 10, 60, 43, 49, 50, 62, 45, 49, 50, 10}, - - "zoneinfo/Pacific/Yap": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 8, 128, 0, 0, 0, 127, 255, 255, 255, 1, 1, 0, 0, 142, 76, 0, 0, 0, 0, 140, 160, 0, 4, 76, 77, 84, 0, 43, 49, 48, 0, 0, 0, 0, 0, 10, 60, 43, 49, 48, 62, 45, 49, 48, 10}, - - "zoneinfo/Poland": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 168, 0, 0, 0, 11, 0, 0, 0, 26, 128, 0, 0, 0, 153, 168, 42, 208, 155, 12, 23, 96, 155, 213, 218, 240, 156, 217, 174, 144, 157, 164, 181, 144, 158, 185, 144, 144, 159, 132, 151, 144, 160, 154, 182, 0, 161, 101, 189, 0, 166, 125, 124, 96, 200, 118, 222, 16, 204, 231, 75, 16, 205, 169, 23, 144, 206, 162, 67, 16, 207, 146, 52, 16, 208, 128, 169, 96, 208, 132, 186, 0, 209, 149, 146, 112, 210, 138, 187, 96, 211, 98, 255, 112, 212, 75, 35, 144, 213, 94, 173, 16, 214, 41, 180, 16, 215, 44, 26, 16, 216, 9, 150, 16, 217, 2, 193, 144, 217, 233, 120, 16, 232, 84, 210, 0, 232, 241, 180, 128, 233, 225, 165, 128, 234, 209, 150, 128, 236, 20, 150, 0, 236, 186, 179, 0, 237, 170, 164, 0, 238, 154, 149, 0, 239, 212, 90, 0, 240, 122, 119, 0, 241, 180, 60, 0, 242, 90, 89, 0, 243, 148, 30, 0, 244, 58, 59, 0, 245, 125, 58, 128, 246, 26, 29, 0, 13, 42, 253, 112, 13, 164, 85, 128, 14, 139, 12, 0, 15, 132, 55, 128, 16, 116, 40, 128, 17, 100, 25, 128, 18, 84, 10, 128, 19, 77, 54, 0, 20, 51, 236, 128, 21, 35, 221, 128, 22, 19, 206, 128, 23, 3, 191, 128, 23, 243, 176, 128, 24, 227, 161, 128, 25, 211, 146, 128, 26, 195, 131, 128, 27, 188, 175, 0, 28, 172, 160, 0, 29, 156, 145, 0, 30, 140, 130, 0, 31, 124, 115, 0, 32, 108, 100, 0, 33, 92, 85, 0, 33, 218, 214, 240, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 1, 3, 2, 3, 4, 5, 4, 8, 6, 7, 3, 2, 5, 4, 5, 4, 2, 3, 2, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 3, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 3, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 0, 0, 19, 176, 0, 0, 0, 0, 19, 176, 0, 4, 0, 0, 28, 32, 1, 8, 0, 0, 14, 16, 0, 13, 0, 0, 28, 32, 1, 8, 0, 0, 14, 16, 0, 13, 0, 0, 42, 48, 1, 17, 0, 0, 28, 32, 0, 22, 0, 0, 28, 32, 0, 22, 0, 0, 28, 32, 1, 8, 0, 0, 14, 16, 0, 13, 76, 77, 84, 0, 87, 77, 84, 0, 67, 69, 83, 84, 0, 67, 69, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 10, 67, 69, 84, 45, 49, 67, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 44, 77, 49, 48, 46, 53, 46, 48, 47, 51, 10}, - - "zoneinfo/Portugal": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 222, 0, 0, 0, 11, 0, 0, 0, 27, 128, 0, 0, 0, 146, 230, 151, 29, 155, 75, 109, 112, 155, 254, 199, 128, 156, 156, 237, 112, 157, 201, 131, 112, 158, 127, 114, 112, 159, 170, 182, 240, 160, 95, 84, 112, 161, 139, 234, 112, 162, 65, 217, 112, 163, 110, 111, 112, 164, 35, 12, 240, 165, 79, 162, 240, 170, 5, 239, 112, 170, 244, 142, 240, 173, 201, 167, 240, 174, 167, 35, 240, 175, 160, 79, 112, 176, 135, 5, 240, 177, 137, 107, 240, 178, 112, 34, 112, 179, 114, 136, 112, 180, 80, 4, 112, 183, 50, 76, 112, 184, 15, 200, 112, 184, 255, 185, 112, 185, 239, 170, 112, 188, 200, 183, 240, 189, 184, 168, 240, 190, 159, 95, 112, 191, 152, 138, 240, 192, 154, 240, 240, 193, 120, 108, 240, 194, 104, 93, 240, 195, 88, 78, 240, 196, 63, 5, 112, 197, 56, 48, 240, 198, 58, 150, 240, 199, 88, 172, 112, 199, 217, 223, 112, 201, 1, 47, 112, 201, 241, 32, 112, 202, 226, 98, 240, 203, 181, 82, 240, 203, 236, 163, 224, 204, 128, 75, 224, 204, 220, 162, 240, 205, 149, 52, 240, 205, 195, 75, 96, 206, 114, 162, 224, 206, 197, 191, 112, 207, 117, 22, 240, 207, 172, 103, 224, 208, 82, 132, 224, 208, 165, 161, 112, 209, 84, 248, 240, 209, 140, 73, 224, 210, 50, 102, 224, 210, 133, 131, 112, 211, 89, 196, 240, 212, 73, 181, 240, 213, 57, 209, 32, 214, 41, 194, 32, 215, 25, 179, 32, 216, 9, 164, 32, 216, 249, 149, 32, 217, 233, 134, 32, 220, 185, 89, 32, 221, 178, 132, 160, 222, 162, 117, 160, 223, 146, 102, 160, 224, 130, 87, 160, 225, 114, 72, 160, 226, 98, 57, 160, 227, 82, 42, 160, 228, 66, 27, 160, 229, 50, 12, 160, 230, 33, 253, 160, 231, 27, 41, 32, 232, 11, 26, 32, 232, 251, 11, 32, 233, 234, 252, 32, 234, 218, 237, 32, 235, 202, 222, 32, 236, 186, 207, 32, 237, 170, 192, 32, 238, 154, 177, 32, 239, 138, 162, 32, 240, 122, 147, 32, 241, 106, 132, 32, 242, 99, 175, 160, 243, 83, 160, 160, 244, 67, 145, 160, 245, 51, 130, 160, 246, 35, 115, 160, 247, 19, 100, 160, 248, 3, 85, 160, 248, 243, 70, 160, 12, 171, 42, 0, 13, 155, 27, 0, 14, 139, 12, 0, 15, 132, 55, 128, 16, 116, 40, 128, 17, 100, 25, 128, 18, 84, 24, 144, 19, 67, 251, 128, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 189, 160, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 0, 2, 1, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 5, 3, 4, 3, 5, 3, 4, 3, 5, 3, 4, 3, 5, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 6, 2, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 4, 3, 7, 8, 7, 8, 7, 8, 7, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 9, 10, 255, 255, 247, 99, 0, 0, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 9, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 9, 0, 0, 28, 32, 1, 13, 0, 0, 14, 16, 0, 18, 0, 0, 14, 16, 0, 18, 0, 0, 28, 32, 1, 22, 0, 0, 14, 16, 1, 4, 0, 0, 0, 0, 0, 9, 76, 77, 84, 0, 87, 69, 83, 84, 0, 87, 69, 84, 0, 87, 69, 77, 84, 0, 67, 69, 84, 0, 67, 69, 83, 84, 0, 0, 0, 0, 1, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 10, 87, 69, 84, 48, 87, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 49, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/ROC": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 41, 0, 0, 0, 5, 0, 0, 0, 16, 128, 0, 0, 0, 195, 85, 73, 128, 210, 84, 89, 128, 211, 139, 123, 128, 212, 66, 173, 240, 213, 69, 34, 0, 214, 76, 191, 240, 215, 60, 191, 0, 216, 6, 102, 112, 217, 29, 242, 128, 217, 231, 153, 240, 218, 255, 38, 0, 219, 200, 205, 112, 220, 224, 89, 128, 221, 170, 0, 240, 222, 114, 115, 0, 223, 181, 100, 112, 224, 124, 133, 0, 225, 150, 151, 240, 226, 93, 184, 128, 227, 119, 203, 112, 228, 62, 236, 0, 229, 48, 32, 112, 230, 33, 113, 0, 231, 18, 165, 112, 232, 2, 164, 128, 232, 243, 216, 240, 233, 227, 216, 0, 234, 213, 12, 112, 235, 197, 11, 128, 236, 182, 63, 240, 237, 247, 252, 0, 238, 152, 196, 240, 239, 217, 47, 128, 240, 121, 248, 112, 7, 252, 86, 0, 8, 237, 138, 112, 9, 221, 137, 128, 10, 206, 189, 240, 17, 219, 161, 128, 18, 84, 221, 112, 1, 2, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 3, 1, 0, 0, 113, 232, 0, 0, 0, 0, 112, 128, 0, 4, 0, 0, 126, 144, 0, 8, 0, 0, 126, 144, 1, 12, 0, 0, 112, 128, 0, 4, 76, 77, 84, 0, 67, 83, 84, 0, 74, 83, 84, 0, 67, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 67, 83, 84, 45, 56, 10}, - - "zoneinfo/ROK": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 22, 0, 0, 0, 6, 0, 0, 0, 16, 128, 0, 0, 0, 139, 215, 240, 120, 146, 230, 22, 248, 210, 67, 39, 240, 226, 79, 41, 240, 228, 107, 183, 248, 229, 19, 24, 104, 230, 98, 3, 120, 231, 17, 76, 232, 232, 47, 112, 120, 232, 231, 244, 104, 234, 15, 82, 120, 234, 199, 214, 104, 235, 239, 52, 120, 236, 167, 184, 104, 237, 207, 22, 120, 238, 135, 154, 104, 240, 53, 113, 120, 32, 163, 96, 144, 33, 110, 103, 144, 34, 131, 66, 144, 35, 78, 73, 144, 0, 1, 2, 3, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 4, 1, 3, 5, 3, 5, 3, 0, 0, 119, 8, 0, 0, 0, 0, 119, 136, 0, 4, 0, 0, 126, 144, 0, 8, 0, 0, 126, 144, 0, 4, 0, 0, 133, 152, 1, 12, 0, 0, 140, 160, 1, 12, 76, 77, 84, 0, 75, 83, 84, 0, 74, 83, 84, 0, 75, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 75, 83, 84, 45, 57, 10}, - - "zoneinfo/Singapore": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 8, 0, 0, 0, 32, 128, 0, 0, 0, 134, 131, 133, 163, 186, 103, 78, 144, 192, 10, 228, 96, 202, 179, 229, 96, 203, 145, 95, 8, 210, 72, 109, 240, 22, 145, 245, 8, 127, 255, 255, 255, 1, 2, 3, 4, 5, 6, 5, 7, 7, 0, 0, 97, 93, 0, 0, 0, 0, 97, 93, 0, 4, 0, 0, 98, 112, 0, 8, 0, 0, 103, 32, 1, 12, 0, 0, 103, 32, 0, 12, 0, 0, 105, 120, 0, 18, 0, 0, 126, 144, 0, 24, 0, 0, 112, 128, 0, 28, 76, 77, 84, 0, 83, 77, 84, 0, 43, 48, 55, 0, 43, 48, 55, 50, 48, 0, 43, 48, 55, 51, 48, 0, 43, 48, 57, 0, 43, 48, 56, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 60, 43, 48, 56, 62, 45, 56, 10}, - - "zoneinfo/Turkey": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 11, 0, 0, 0, 0, 0, 0, 0, 131, 0, 0, 0, 11, 0, 0, 0, 25, 128, 0, 0, 0, 144, 139, 245, 152, 155, 12, 23, 96, 155, 213, 190, 208, 162, 101, 99, 224, 163, 123, 130, 80, 164, 78, 128, 96, 165, 63, 180, 208, 166, 37, 39, 224, 167, 39, 127, 208, 170, 40, 40, 96, 170, 225, 253, 208, 171, 249, 137, 224, 172, 195, 49, 80, 200, 127, 238, 96, 200, 255, 193, 208, 201, 74, 245, 96, 202, 206, 128, 80, 203, 203, 174, 96, 204, 229, 193, 80, 209, 113, 235, 224, 210, 107, 9, 80, 211, 162, 57, 96, 212, 67, 2, 80, 213, 76, 13, 224, 214, 41, 123, 208, 215, 43, 239, 224, 216, 9, 93, 208, 217, 2, 151, 96, 217, 233, 63, 208, 218, 239, 168, 96, 219, 210, 92, 80, 220, 212, 208, 96, 221, 179, 143, 208, 241, 244, 185, 96, 242, 100, 186, 208, 245, 104, 6, 96, 246, 31, 56, 208, 0, 160, 186, 224, 1, 107, 179, 208, 2, 128, 156, 224, 3, 75, 149, 208, 4, 105, 185, 96, 5, 52, 178, 80, 6, 110, 147, 112, 7, 57, 168, 128, 7, 251, 117, 0, 9, 25, 166, 160, 9, 219, 58, 224, 10, 240, 7, 208, 12, 16, 206, 96, 12, 217, 36, 80, 13, 164, 57, 96, 14, 166, 145, 80, 15, 132, 27, 96, 16, 134, 115, 80, 18, 103, 152, 192, 19, 77, 54, 0, 20, 71, 122, 192, 21, 35, 221, 128, 22, 39, 92, 192, 23, 3, 191, 128, 24, 7, 62, 192, 25, 137, 148, 80, 25, 220, 148, 192, 28, 198, 211, 208, 29, 155, 21, 80, 30, 140, 115, 240, 31, 124, 100, 240, 32, 108, 85, 240, 33, 92, 70, 240, 34, 76, 55, 240, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 10, 240, 38, 11, 251, 240, 39, 5, 39, 112, 39, 245, 24, 112, 40, 229, 9, 112, 41, 212, 250, 112, 42, 196, 235, 112, 43, 180, 220, 112, 44, 164, 205, 112, 45, 139, 131, 240, 46, 132, 175, 112, 47, 116, 160, 112, 48, 100, 145, 112, 49, 93, 188, 240, 50, 114, 151, 240, 51, 61, 158, 240, 52, 82, 121, 240, 53, 29, 128, 240, 54, 50, 91, 240, 54, 253, 98, 240, 56, 27, 120, 112, 56, 221, 68, 240, 57, 251, 90, 112, 58, 189, 38, 240, 59, 219, 60, 112, 60, 166, 67, 112, 61, 187, 30, 112, 62, 134, 37, 112, 63, 155, 0, 112, 64, 102, 7, 112, 65, 132, 28, 240, 66, 69, 233, 112, 67, 99, 254, 240, 68, 37, 203, 112, 69, 67, 224, 240, 69, 152, 50, 224, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 143, 221, 144, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 56, 190, 16, 84, 76, 71, 144, 85, 23, 78, 144, 86, 62, 158, 144, 86, 247, 48, 144, 87, 207, 46, 80, 127, 255, 255, 255, 1, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 3, 2, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 2, 3, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 6, 7, 3, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 9, 8, 5, 5, 0, 0, 27, 40, 0, 0, 0, 0, 27, 104, 0, 4, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 0, 0, 56, 64, 1, 17, 0, 0, 42, 48, 0, 21, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 0, 0, 42, 48, 1, 8, 0, 0, 28, 32, 0, 13, 0, 0, 42, 48, 0, 21, 76, 77, 84, 0, 73, 77, 84, 0, 69, 69, 83, 84, 0, 69, 69, 84, 0, 43, 48, 52, 0, 43, 48, 51, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 10, 60, 43, 48, 51, 62, 45, 51, 10}, - - "zoneinfo/UCT": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 85, 67, 84, 0, 0, 0, 10, 85, 67, 84, 48, 10}, - - "zoneinfo/US/Alaska": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 144, 0, 0, 0, 9, 0, 0, 0, 40, 128, 0, 0, 0, 203, 137, 54, 192, 210, 35, 244, 112, 210, 97, 66, 48, 250, 210, 71, 160, 254, 184, 99, 64, 255, 168, 70, 48, 0, 152, 69, 64, 1, 136, 40, 48, 2, 120, 39, 64, 3, 113, 68, 176, 4, 97, 67, 192, 5, 81, 38, 176, 6, 65, 37, 192, 7, 49, 8, 176, 7, 141, 95, 192, 9, 16, 234, 176, 9, 173, 219, 64, 10, 240, 204, 176, 11, 224, 203, 192, 12, 217, 233, 48, 13, 192, 173, 192, 14, 185, 203, 48, 15, 169, 202, 64, 16, 153, 173, 48, 17, 137, 172, 64, 18, 121, 143, 48, 19, 105, 142, 64, 20, 89, 113, 48, 21, 73, 112, 64, 22, 57, 83, 48, 23, 41, 82, 64, 24, 34, 111, 176, 25, 9, 52, 64, 26, 2, 81, 176, 26, 43, 20, 16, 26, 242, 66, 176, 27, 226, 37, 160, 28, 210, 36, 176, 29, 194, 7, 160, 30, 178, 6, 176, 31, 161, 233, 160, 32, 118, 57, 48, 33, 129, 203, 160, 34, 86, 27, 48, 35, 106, 232, 32, 36, 53, 253, 48, 37, 74, 202, 32, 38, 21, 223, 48, 39, 42, 172, 32, 39, 254, 251, 176, 41, 10, 142, 32, 41, 222, 221, 176, 42, 234, 112, 32, 43, 190, 191, 176, 44, 211, 140, 160, 45, 158, 161, 176, 46, 179, 110, 160, 47, 126, 131, 176, 48, 147, 80, 160, 49, 103, 160, 48, 50, 115, 50, 160, 51, 71, 130, 48, 52, 83, 20, 160, 53, 39, 100, 48, 54, 50, 246, 160, 55, 7, 70, 48, 56, 28, 19, 32, 56, 231, 40, 48, 57, 251, 245, 32, 58, 199, 10, 48, 59, 219, 215, 32, 60, 176, 38, 176, 61, 187, 185, 32, 62, 144, 8, 176, 63, 155, 155, 32, 64, 111, 234, 176, 65, 132, 183, 160, 66, 79, 204, 176, 67, 100, 153, 160, 68, 47, 174, 176, 69, 68, 123, 160, 69, 243, 225, 48, 71, 45, 152, 32, 71, 211, 195, 48, 73, 13, 122, 32, 73, 179, 165, 48, 74, 237, 92, 32, 75, 156, 193, 176, 76, 214, 120, 160, 77, 124, 163, 176, 78, 182, 90, 160, 79, 92, 133, 176, 80, 150, 60, 160, 81, 60, 103, 176, 82, 118, 30, 160, 83, 28, 73, 176, 84, 86, 0, 160, 84, 252, 43, 176, 86, 53, 226, 160, 86, 229, 72, 48, 88, 30, 255, 32, 88, 197, 42, 48, 89, 254, 225, 32, 90, 165, 12, 48, 91, 222, 195, 32, 92, 132, 238, 48, 93, 190, 165, 32, 94, 100, 208, 48, 95, 158, 135, 32, 96, 77, 236, 176, 97, 135, 163, 160, 98, 45, 206, 176, 99, 103, 133, 160, 100, 13, 176, 176, 101, 71, 103, 160, 101, 237, 146, 176, 103, 39, 73, 160, 103, 205, 116, 176, 105, 7, 43, 160, 105, 173, 86, 176, 106, 231, 13, 160, 107, 150, 115, 48, 108, 208, 42, 32, 109, 118, 85, 48, 110, 176, 12, 32, 111, 86, 55, 48, 112, 143, 238, 32, 113, 54, 25, 48, 114, 111, 208, 32, 115, 21, 251, 48, 116, 79, 178, 32, 116, 255, 23, 176, 118, 56, 206, 160, 118, 222, 249, 176, 120, 24, 176, 160, 120, 190, 219, 176, 121, 248, 146, 160, 122, 158, 189, 176, 123, 216, 116, 160, 124, 126, 159, 176, 125, 184, 86, 160, 126, 94, 129, 176, 127, 152, 56, 160, 1, 2, 3, 1, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 6, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 255, 255, 115, 120, 0, 0, 255, 255, 115, 96, 0, 4, 255, 255, 129, 112, 1, 8, 255, 255, 129, 112, 1, 12, 255, 255, 115, 96, 0, 16, 255, 255, 129, 112, 1, 21, 255, 255, 129, 112, 0, 26, 255, 255, 143, 128, 1, 30, 255, 255, 129, 112, 0, 35, 76, 77, 84, 0, 65, 83, 84, 0, 65, 87, 84, 0, 65, 80, 84, 0, 65, 72, 83, 84, 0, 65, 72, 68, 84, 0, 89, 83, 84, 0, 65, 75, 68, 84, 0, 65, 75, 83, 84, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 10, 65, 75, 83, 84, 57, 65, 75, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/US/Aleutian": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 144, 0, 0, 0, 9, 0, 0, 0, 33, 128, 0, 0, 0, 203, 137, 68, 208, 210, 35, 244, 112, 210, 97, 80, 64, 250, 210, 85, 176, 254, 184, 113, 80, 255, 168, 84, 64, 0, 152, 83, 80, 1, 136, 54, 64, 2, 120, 53, 80, 3, 113, 82, 192, 4, 97, 81, 208, 5, 81, 52, 192, 6, 65, 51, 208, 7, 49, 22, 192, 7, 141, 109, 208, 9, 16, 248, 192, 9, 173, 233, 80, 10, 240, 218, 192, 11, 224, 217, 208, 12, 217, 247, 64, 13, 192, 187, 208, 14, 185, 217, 64, 15, 169, 216, 80, 16, 153, 187, 64, 17, 137, 186, 80, 18, 121, 157, 64, 19, 105, 156, 80, 20, 89, 127, 64, 21, 73, 126, 80, 22, 57, 97, 64, 23, 41, 96, 80, 24, 34, 125, 192, 25, 9, 66, 80, 26, 2, 95, 192, 26, 43, 34, 32, 26, 242, 80, 192, 27, 226, 51, 176, 28, 210, 50, 192, 29, 194, 21, 176, 30, 178, 20, 192, 31, 161, 247, 176, 32, 118, 71, 64, 33, 129, 217, 176, 34, 86, 41, 64, 35, 106, 246, 48, 36, 54, 11, 64, 37, 74, 216, 48, 38, 21, 237, 64, 39, 42, 186, 48, 39, 255, 9, 192, 41, 10, 156, 48, 41, 222, 235, 192, 42, 234, 126, 48, 43, 190, 205, 192, 44, 211, 154, 176, 45, 158, 175, 192, 46, 179, 124, 176, 47, 126, 145, 192, 48, 147, 94, 176, 49, 103, 174, 64, 50, 115, 64, 176, 51, 71, 144, 64, 52, 83, 34, 176, 53, 39, 114, 64, 54, 51, 4, 176, 55, 7, 84, 64, 56, 28, 33, 48, 56, 231, 54, 64, 57, 252, 3, 48, 58, 199, 24, 64, 59, 219, 229, 48, 60, 176, 52, 192, 61, 187, 199, 48, 62, 144, 22, 192, 63, 155, 169, 48, 64, 111, 248, 192, 65, 132, 197, 176, 66, 79, 218, 192, 67, 100, 167, 176, 68, 47, 188, 192, 69, 68, 137, 176, 69, 243, 239, 64, 71, 45, 166, 48, 71, 211, 209, 64, 73, 13, 136, 48, 73, 179, 179, 64, 74, 237, 106, 48, 75, 156, 207, 192, 76, 214, 134, 176, 77, 124, 177, 192, 78, 182, 104, 176, 79, 92, 147, 192, 80, 150, 74, 176, 81, 60, 117, 192, 82, 118, 44, 176, 83, 28, 87, 192, 84, 86, 14, 176, 84, 252, 57, 192, 86, 53, 240, 176, 86, 229, 86, 64, 88, 31, 13, 48, 88, 197, 56, 64, 89, 254, 239, 48, 90, 165, 26, 64, 91, 222, 209, 48, 92, 132, 252, 64, 93, 190, 179, 48, 94, 100, 222, 64, 95, 158, 149, 48, 96, 77, 250, 192, 97, 135, 177, 176, 98, 45, 220, 192, 99, 103, 147, 176, 100, 13, 190, 192, 101, 71, 117, 176, 101, 237, 160, 192, 103, 39, 87, 176, 103, 205, 130, 192, 105, 7, 57, 176, 105, 173, 100, 192, 106, 231, 27, 176, 107, 150, 129, 64, 108, 208, 56, 48, 109, 118, 99, 64, 110, 176, 26, 48, 111, 86, 69, 64, 112, 143, 252, 48, 113, 54, 39, 64, 114, 111, 222, 48, 115, 22, 9, 64, 116, 79, 192, 48, 116, 255, 37, 192, 118, 56, 220, 176, 118, 223, 7, 192, 120, 24, 190, 176, 120, 190, 233, 192, 121, 248, 160, 176, 122, 158, 203, 192, 123, 216, 130, 176, 124, 126, 173, 192, 125, 184, 100, 176, 126, 94, 143, 192, 127, 152, 70, 176, 1, 2, 3, 1, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 4, 5, 6, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 7, 8, 255, 255, 90, 98, 0, 0, 255, 255, 101, 80, 0, 4, 255, 255, 115, 96, 1, 8, 255, 255, 115, 96, 1, 12, 255, 255, 101, 80, 0, 16, 255, 255, 115, 96, 1, 20, 255, 255, 115, 96, 0, 24, 255, 255, 129, 112, 1, 29, 255, 255, 115, 96, 0, 25, 76, 77, 84, 0, 78, 83, 84, 0, 78, 87, 84, 0, 78, 80, 84, 0, 66, 83, 84, 0, 66, 68, 84, 0, 65, 72, 83, 84, 0, 72, 68, 84, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 10, 72, 83, 84, 49, 48, 72, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/US/Arizona": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 11, 0, 0, 0, 4, 0, 0, 0, 16, 128, 0, 0, 0, 158, 166, 58, 144, 159, 187, 7, 128, 160, 134, 28, 144, 161, 154, 233, 128, 203, 137, 12, 144, 207, 23, 223, 28, 207, 143, 229, 172, 208, 129, 26, 28, 250, 248, 117, 16, 251, 232, 88, 0, 2, 1, 2, 1, 2, 3, 2, 3, 2, 1, 2, 255, 255, 150, 238, 0, 0, 255, 255, 171, 160, 1, 4, 255, 255, 157, 144, 0, 8, 255, 255, 171, 160, 1, 12, 76, 77, 84, 0, 77, 68, 84, 0, 77, 83, 84, 0, 77, 87, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 77, 83, 84, 55, 10}, - - "zoneinfo/US/Central": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 236, 0, 0, 0, 7, 0, 0, 0, 24, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 162, 203, 116, 0, 163, 131, 247, 240, 164, 69, 210, 128, 165, 99, 217, 240, 166, 83, 217, 0, 167, 21, 151, 112, 168, 51, 187, 0, 168, 254, 179, 240, 170, 19, 157, 0, 170, 222, 149, 240, 171, 243, 127, 0, 172, 190, 119, 240, 173, 211, 97, 0, 174, 158, 89, 240, 175, 179, 67, 0, 176, 126, 59, 240, 177, 156, 95, 128, 178, 103, 88, 112, 179, 124, 65, 128, 180, 71, 58, 112, 181, 92, 35, 128, 182, 39, 28, 112, 183, 60, 5, 128, 184, 6, 254, 112, 185, 27, 231, 128, 185, 230, 224, 112, 187, 5, 4, 0, 187, 198, 194, 112, 188, 228, 230, 0, 189, 175, 222, 240, 190, 196, 200, 0, 191, 143, 192, 240, 192, 90, 214, 0, 193, 176, 60, 112, 194, 132, 140, 0, 195, 79, 132, 240, 196, 100, 110, 0, 197, 47, 102, 240, 198, 77, 138, 128, 199, 15, 72, 240, 200, 45, 108, 128, 200, 248, 101, 112, 202, 13, 78, 128, 202, 216, 71, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 211, 117, 243, 0, 212, 64, 235, 240, 213, 85, 213, 0, 214, 32, 205, 240, 215, 53, 183, 0, 216, 0, 175, 240, 217, 21, 153, 0, 217, 224, 145, 240, 218, 254, 181, 128, 219, 192, 115, 240, 220, 222, 151, 128, 221, 169, 144, 112, 222, 190, 121, 128, 223, 137, 114, 112, 224, 158, 91, 128, 225, 105, 84, 112, 226, 126, 61, 128, 227, 73, 54, 112, 228, 94, 31, 128, 229, 87, 60, 240, 230, 71, 60, 0, 231, 55, 30, 240, 232, 39, 30, 0, 233, 23, 0, 240, 234, 7, 0, 0, 234, 246, 226, 240, 235, 230, 226, 0, 236, 214, 196, 240, 237, 198, 196, 0, 238, 191, 225, 112, 239, 175, 224, 128, 240, 159, 195, 112, 241, 143, 194, 128, 242, 127, 165, 112, 243, 111, 164, 128, 244, 95, 135, 112, 245, 79, 134, 128, 246, 63, 105, 112, 247, 47, 104, 128, 248, 40, 133, 240, 249, 15, 74, 128, 250, 8, 103, 240, 250, 248, 103, 0, 251, 232, 73, 240, 252, 216, 73, 0, 253, 200, 43, 240, 254, 184, 43, 0, 255, 168, 13, 240, 0, 152, 13, 0, 1, 135, 239, 240, 2, 119, 239, 0, 3, 113, 12, 112, 4, 97, 11, 128, 5, 80, 238, 112, 6, 64, 237, 128, 7, 48, 208, 112, 7, 141, 39, 128, 9, 16, 178, 112, 9, 173, 163, 0, 10, 240, 148, 112, 11, 224, 147, 128, 12, 217, 176, 240, 13, 192, 117, 128, 14, 185, 146, 240, 15, 169, 146, 0, 16, 153, 116, 240, 17, 137, 116, 0, 18, 121, 86, 240, 19, 105, 86, 0, 20, 89, 56, 240, 21, 73, 56, 0, 22, 57, 26, 240, 23, 41, 26, 0, 24, 34, 55, 112, 25, 8, 252, 0, 26, 2, 25, 112, 26, 242, 24, 128, 27, 225, 251, 112, 28, 209, 250, 128, 29, 193, 221, 112, 30, 177, 220, 128, 31, 161, 191, 112, 32, 118, 15, 0, 33, 129, 161, 112, 34, 85, 241, 0, 35, 106, 189, 240, 36, 53, 211, 0, 37, 74, 159, 240, 38, 21, 181, 0, 39, 42, 129, 240, 39, 254, 209, 128, 41, 10, 99, 240, 41, 222, 179, 128, 42, 234, 69, 240, 43, 190, 149, 128, 44, 211, 98, 112, 45, 158, 119, 128, 46, 179, 68, 112, 47, 126, 89, 128, 48, 147, 38, 112, 49, 103, 118, 0, 50, 115, 8, 112, 51, 71, 88, 0, 52, 82, 234, 112, 53, 39, 58, 0, 54, 50, 204, 112, 55, 7, 28, 0, 56, 27, 232, 240, 56, 230, 254, 0, 57, 251, 202, 240, 58, 198, 224, 0, 59, 219, 172, 240, 60, 175, 252, 128, 61, 187, 142, 240, 62, 143, 222, 128, 63, 155, 112, 240, 64, 111, 192, 128, 65, 132, 141, 112, 66, 79, 162, 128, 67, 100, 111, 112, 68, 47, 132, 128, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 109, 240, 71, 211, 153, 0, 73, 13, 79, 240, 73, 179, 123, 0, 74, 237, 49, 240, 75, 156, 151, 128, 76, 214, 78, 112, 77, 124, 121, 128, 78, 182, 48, 112, 79, 92, 91, 128, 80, 150, 18, 112, 81, 60, 61, 128, 82, 117, 244, 112, 83, 28, 31, 128, 84, 85, 214, 112, 84, 252, 1, 128, 86, 53, 184, 112, 86, 229, 30, 0, 88, 30, 212, 240, 88, 197, 0, 0, 89, 254, 182, 240, 90, 164, 226, 0, 91, 222, 152, 240, 92, 132, 196, 0, 93, 190, 122, 240, 94, 100, 166, 0, 95, 158, 92, 240, 96, 77, 194, 128, 97, 135, 121, 112, 98, 45, 164, 128, 99, 103, 91, 112, 100, 13, 134, 128, 101, 71, 61, 112, 101, 237, 104, 128, 103, 39, 31, 112, 103, 205, 74, 128, 105, 7, 1, 112, 105, 173, 44, 128, 106, 230, 227, 112, 107, 150, 73, 0, 108, 207, 255, 240, 109, 118, 43, 0, 110, 175, 225, 240, 111, 86, 13, 0, 112, 143, 195, 240, 113, 53, 239, 0, 114, 111, 165, 240, 115, 21, 209, 0, 116, 79, 135, 240, 116, 254, 237, 128, 118, 56, 164, 112, 118, 222, 207, 128, 120, 24, 134, 112, 120, 190, 177, 128, 121, 248, 104, 112, 122, 158, 147, 128, 123, 216, 74, 112, 124, 126, 117, 128, 125, 184, 44, 112, 126, 94, 87, 128, 127, 152, 14, 112, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 4, 5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 173, 212, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 0, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 1, 20, 255, 255, 171, 160, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 69, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/US/East-Indiana": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 99, 0, 0, 0, 7, 0, 0, 0, 28, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 202, 87, 34, 128, 202, 216, 71, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 211, 117, 243, 0, 212, 64, 235, 240, 213, 85, 213, 0, 214, 32, 205, 240, 215, 53, 183, 0, 216, 0, 175, 240, 217, 21, 153, 0, 217, 224, 145, 240, 218, 254, 181, 128, 219, 192, 115, 240, 220, 222, 151, 128, 221, 169, 144, 112, 222, 190, 121, 128, 223, 137, 114, 112, 224, 158, 91, 128, 225, 105, 84, 112, 226, 126, 61, 128, 227, 73, 54, 112, 228, 94, 31, 128, 232, 242, 22, 240, 234, 7, 0, 0, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 6, 5, 255, 255, 175, 58, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 255, 255, 199, 192, 1, 24, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 69, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/US/Eastern": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 236, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 158, 166, 30, 112, 159, 186, 235, 96, 160, 134, 0, 112, 161, 154, 205, 96, 162, 101, 226, 112, 163, 131, 233, 224, 164, 106, 174, 112, 165, 53, 167, 96, 166, 83, 202, 240, 167, 21, 137, 96, 168, 51, 172, 240, 168, 254, 165, 224, 170, 19, 142, 240, 170, 222, 135, 224, 171, 243, 112, 240, 172, 190, 105, 224, 173, 211, 82, 240, 174, 158, 75, 224, 175, 179, 52, 240, 176, 126, 45, 224, 177, 156, 81, 112, 178, 103, 74, 96, 179, 124, 51, 112, 180, 71, 44, 96, 181, 92, 21, 112, 182, 39, 14, 96, 183, 59, 247, 112, 184, 6, 240, 96, 185, 27, 217, 112, 185, 230, 210, 96, 187, 4, 245, 240, 187, 198, 180, 96, 188, 228, 215, 240, 189, 175, 208, 224, 190, 196, 185, 240, 191, 143, 178, 224, 192, 164, 155, 240, 193, 111, 148, 224, 194, 132, 125, 240, 195, 79, 118, 224, 196, 100, 95, 240, 197, 47, 88, 224, 198, 77, 124, 112, 199, 15, 58, 224, 200, 45, 94, 112, 200, 248, 87, 96, 202, 13, 64, 112, 202, 216, 57, 96, 203, 136, 240, 112, 210, 35, 244, 112, 210, 96, 251, 224, 211, 117, 228, 240, 212, 64, 221, 224, 213, 85, 198, 240, 214, 32, 191, 224, 215, 53, 168, 240, 216, 0, 161, 224, 217, 21, 138, 240, 217, 224, 131, 224, 218, 254, 167, 112, 219, 192, 101, 224, 220, 222, 137, 112, 221, 169, 130, 96, 222, 190, 107, 112, 223, 137, 100, 96, 224, 158, 77, 112, 225, 105, 70, 96, 226, 126, 47, 112, 227, 73, 40, 96, 228, 94, 17, 112, 229, 87, 46, 224, 230, 71, 45, 240, 231, 55, 16, 224, 232, 39, 15, 240, 233, 22, 242, 224, 234, 6, 241, 240, 234, 246, 212, 224, 235, 230, 211, 240, 236, 214, 182, 224, 237, 198, 181, 240, 238, 191, 211, 96, 239, 175, 210, 112, 240, 159, 181, 96, 241, 143, 180, 112, 242, 127, 151, 96, 243, 111, 150, 112, 244, 95, 121, 96, 245, 79, 120, 112, 246, 63, 91, 96, 247, 47, 90, 112, 248, 40, 119, 224, 249, 15, 60, 112, 250, 8, 89, 224, 250, 248, 88, 240, 251, 232, 59, 224, 252, 216, 58, 240, 253, 200, 29, 224, 254, 184, 28, 240, 255, 167, 255, 224, 0, 151, 254, 240, 1, 135, 225, 224, 2, 119, 224, 240, 3, 112, 254, 96, 4, 96, 253, 112, 5, 80, 224, 96, 6, 64, 223, 112, 7, 48, 194, 96, 7, 141, 25, 112, 9, 16, 164, 96, 9, 173, 148, 240, 10, 240, 134, 96, 11, 224, 133, 112, 12, 217, 162, 224, 13, 192, 103, 112, 14, 185, 132, 224, 15, 169, 131, 240, 16, 153, 102, 224, 17, 137, 101, 240, 18, 121, 72, 224, 19, 105, 71, 240, 20, 89, 42, 224, 21, 73, 41, 240, 22, 57, 12, 224, 23, 41, 11, 240, 24, 34, 41, 96, 25, 8, 237, 240, 26, 2, 11, 96, 26, 242, 10, 112, 27, 225, 237, 96, 28, 209, 236, 112, 29, 193, 207, 96, 30, 177, 206, 112, 31, 161, 177, 96, 32, 118, 0, 240, 33, 129, 147, 96, 34, 85, 226, 240, 35, 106, 175, 224, 36, 53, 196, 240, 37, 74, 145, 224, 38, 21, 166, 240, 39, 42, 115, 224, 39, 254, 195, 112, 41, 10, 85, 224, 41, 222, 165, 112, 42, 234, 55, 224, 43, 190, 135, 112, 44, 211, 84, 96, 45, 158, 105, 112, 46, 179, 54, 96, 47, 126, 75, 112, 48, 147, 24, 96, 49, 103, 103, 240, 50, 114, 250, 96, 51, 71, 73, 240, 52, 82, 220, 96, 53, 39, 43, 240, 54, 50, 190, 96, 55, 7, 13, 240, 56, 27, 218, 224, 56, 230, 239, 240, 57, 251, 188, 224, 58, 198, 209, 240, 59, 219, 158, 224, 60, 175, 238, 112, 61, 187, 128, 224, 62, 143, 208, 112, 63, 155, 98, 224, 64, 111, 178, 112, 65, 132, 127, 96, 66, 79, 148, 112, 67, 100, 97, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 186, 158, 0, 0, 255, 255, 199, 192, 1, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 1, 12, 255, 255, 199, 192, 1, 16, 76, 77, 84, 0, 69, 68, 84, 0, 69, 83, 84, 0, 69, 87, 84, 0, 69, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/US/Hawaii": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 4, 0, 0, 0, 12, 128, 0, 0, 0, 187, 5, 67, 72, 187, 33, 113, 88, 203, 137, 61, 200, 210, 97, 73, 56, 213, 141, 115, 72, 1, 2, 1, 2, 1, 3, 255, 255, 108, 2, 0, 0, 255, 255, 108, 88, 0, 4, 255, 255, 122, 104, 1, 8, 255, 255, 115, 96, 0, 4, 76, 77, 84, 0, 72, 83, 84, 0, 72, 68, 84, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 72, 83, 84, 49, 48, 10}, - - "zoneinfo/US/Indiana-Starke": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 154, 0, 0, 0, 7, 0, 0, 0, 24, 128, 0, 0, 0, 158, 166, 44, 128, 159, 186, 249, 112, 160, 134, 14, 128, 161, 154, 219, 112, 203, 136, 254, 128, 210, 35, 244, 112, 210, 97, 9, 240, 213, 85, 213, 0, 214, 32, 205, 240, 215, 53, 183, 0, 216, 0, 175, 240, 217, 21, 153, 0, 217, 224, 145, 240, 218, 254, 181, 128, 219, 192, 115, 240, 220, 222, 151, 128, 221, 169, 144, 112, 222, 190, 121, 128, 223, 137, 114, 112, 224, 158, 91, 128, 225, 105, 84, 112, 226, 126, 61, 128, 227, 73, 54, 112, 228, 94, 31, 128, 229, 87, 60, 240, 230, 71, 60, 0, 231, 55, 30, 240, 232, 39, 30, 0, 232, 242, 22, 240, 234, 7, 0, 0, 234, 209, 248, 240, 235, 230, 226, 0, 236, 214, 196, 240, 237, 198, 196, 0, 238, 191, 225, 112, 239, 175, 224, 128, 240, 159, 195, 112, 241, 143, 194, 128, 244, 95, 135, 112, 250, 248, 103, 0, 251, 232, 73, 240, 252, 216, 73, 0, 253, 200, 43, 240, 254, 184, 43, 0, 255, 168, 13, 240, 0, 152, 13, 0, 1, 135, 239, 240, 2, 119, 239, 0, 3, 113, 12, 112, 4, 97, 11, 128, 5, 80, 238, 112, 6, 64, 237, 128, 7, 48, 208, 112, 7, 141, 39, 128, 9, 16, 178, 112, 9, 173, 163, 0, 10, 240, 148, 112, 11, 224, 147, 128, 12, 217, 176, 240, 13, 192, 117, 128, 14, 185, 146, 240, 15, 169, 146, 0, 16, 153, 116, 240, 17, 137, 116, 0, 18, 121, 86, 240, 19, 105, 86, 0, 20, 89, 56, 240, 21, 73, 56, 0, 22, 57, 26, 240, 23, 41, 26, 0, 24, 34, 55, 112, 25, 8, 252, 0, 26, 2, 25, 112, 26, 242, 24, 128, 27, 225, 251, 112, 28, 209, 250, 128, 29, 193, 221, 112, 30, 177, 220, 128, 31, 161, 191, 112, 32, 118, 15, 0, 33, 129, 161, 112, 34, 85, 241, 0, 35, 106, 189, 240, 36, 53, 211, 0, 37, 74, 159, 240, 38, 21, 181, 0, 39, 42, 129, 240, 39, 254, 209, 128, 41, 10, 99, 240, 68, 47, 118, 112, 69, 68, 81, 112, 69, 243, 183, 0, 71, 45, 109, 240, 71, 211, 153, 0, 73, 13, 79, 240, 73, 179, 123, 0, 74, 237, 49, 240, 75, 156, 151, 128, 76, 214, 78, 112, 77, 124, 121, 128, 78, 182, 48, 112, 79, 92, 91, 128, 80, 150, 18, 112, 81, 60, 61, 128, 82, 117, 244, 112, 83, 28, 31, 128, 84, 85, 214, 112, 84, 252, 1, 128, 86, 53, 184, 112, 86, 229, 30, 0, 88, 30, 212, 240, 88, 197, 0, 0, 89, 254, 182, 240, 90, 164, 226, 0, 91, 222, 152, 240, 92, 132, 196, 0, 93, 190, 122, 240, 94, 100, 166, 0, 95, 158, 92, 240, 96, 77, 194, 128, 97, 135, 121, 112, 98, 45, 164, 128, 99, 103, 91, 112, 100, 13, 134, 128, 101, 71, 61, 112, 101, 237, 104, 128, 103, 39, 31, 112, 103, 205, 74, 128, 105, 7, 1, 112, 105, 173, 44, 128, 106, 230, 227, 112, 107, 150, 73, 0, 108, 207, 255, 240, 109, 118, 43, 0, 110, 175, 225, 240, 111, 86, 13, 0, 112, 143, 195, 240, 113, 53, 239, 0, 114, 111, 165, 240, 115, 21, 209, 0, 116, 79, 135, 240, 116, 254, 237, 128, 118, 56, 164, 112, 118, 222, 207, 128, 120, 24, 134, 112, 120, 190, 177, 128, 121, 248, 104, 112, 122, 158, 147, 128, 123, 216, 74, 112, 124, 126, 117, 128, 125, 184, 44, 112, 126, 94, 87, 128, 127, 152, 14, 112, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 5, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 5, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 174, 202, 0, 0, 255, 255, 185, 176, 1, 4, 255, 255, 171, 160, 0, 8, 255, 255, 185, 176, 1, 12, 255, 255, 185, 176, 1, 16, 255, 255, 185, 176, 0, 20, 255, 255, 171, 160, 0, 8, 76, 77, 84, 0, 67, 68, 84, 0, 67, 83, 84, 0, 67, 87, 84, 0, 67, 80, 84, 0, 69, 83, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 10, 67, 83, 84, 54, 67, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/US/Michigan": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 138, 0, 0, 0, 6, 0, 0, 0, 24, 128, 0, 0, 0, 133, 189, 34, 91, 153, 60, 148, 0, 203, 136, 240, 112, 210, 35, 244, 112, 210, 96, 251, 224, 215, 53, 168, 240, 216, 0, 161, 224, 6, 64, 223, 112, 7, 48, 194, 96, 7, 141, 25, 112, 9, 16, 164, 96, 10, 0, 163, 112, 10, 240, 134, 96, 11, 224, 133, 112, 12, 217, 162, 224, 13, 192, 103, 112, 14, 185, 132, 224, 15, 169, 131, 240, 16, 153, 102, 224, 17, 137, 101, 240, 18, 121, 72, 224, 19, 105, 71, 240, 20, 89, 42, 224, 21, 73, 41, 240, 22, 57, 12, 224, 23, 41, 11, 240, 24, 34, 41, 96, 25, 8, 237, 240, 26, 2, 11, 96, 26, 242, 10, 112, 27, 225, 237, 96, 28, 209, 236, 112, 29, 193, 207, 96, 30, 177, 206, 112, 31, 161, 177, 96, 32, 118, 0, 240, 33, 129, 147, 96, 34, 85, 226, 240, 35, 106, 175, 224, 36, 53, 196, 240, 37, 74, 145, 224, 38, 21, 166, 240, 39, 42, 115, 224, 39, 254, 195, 112, 41, 10, 85, 224, 41, 222, 165, 112, 42, 234, 55, 224, 43, 190, 135, 112, 44, 211, 84, 96, 45, 158, 105, 112, 46, 179, 54, 96, 47, 126, 75, 112, 48, 147, 24, 96, 49, 103, 103, 240, 50, 114, 250, 96, 51, 71, 73, 240, 52, 82, 220, 96, 53, 39, 43, 240, 54, 50, 190, 96, 55, 7, 13, 240, 56, 27, 218, 224, 56, 230, 239, 240, 57, 251, 188, 224, 58, 198, 209, 240, 59, 219, 158, 224, 60, 175, 238, 112, 61, 187, 128, 224, 62, 143, 208, 112, 63, 155, 98, 224, 64, 111, 178, 112, 65, 132, 127, 96, 66, 79, 148, 112, 67, 100, 97, 96, 68, 47, 118, 112, 69, 68, 67, 96, 69, 243, 168, 240, 71, 45, 95, 224, 71, 211, 138, 240, 73, 13, 65, 224, 73, 179, 108, 240, 74, 237, 35, 224, 75, 156, 137, 112, 76, 214, 64, 96, 77, 124, 107, 112, 78, 182, 34, 96, 79, 92, 77, 112, 80, 150, 4, 96, 81, 60, 47, 112, 82, 117, 230, 96, 83, 28, 17, 112, 84, 85, 200, 96, 84, 251, 243, 112, 86, 53, 170, 96, 86, 229, 15, 240, 88, 30, 198, 224, 88, 196, 241, 240, 89, 254, 168, 224, 90, 164, 211, 240, 91, 222, 138, 224, 92, 132, 181, 240, 93, 190, 108, 224, 94, 100, 151, 240, 95, 158, 78, 224, 96, 77, 180, 112, 97, 135, 107, 96, 98, 45, 150, 112, 99, 103, 77, 96, 100, 13, 120, 112, 101, 71, 47, 96, 101, 237, 90, 112, 103, 39, 17, 96, 103, 205, 60, 112, 105, 6, 243, 96, 105, 173, 30, 112, 106, 230, 213, 96, 107, 150, 58, 240, 108, 207, 241, 224, 109, 118, 28, 240, 110, 175, 211, 224, 111, 85, 254, 240, 112, 143, 181, 224, 113, 53, 224, 240, 114, 111, 151, 224, 115, 21, 194, 240, 116, 79, 121, 224, 116, 254, 223, 112, 118, 56, 150, 96, 118, 222, 193, 112, 120, 24, 120, 96, 120, 190, 163, 112, 121, 248, 90, 96, 122, 158, 133, 112, 123, 216, 60, 96, 124, 126, 103, 112, 125, 184, 30, 96, 126, 94, 73, 112, 127, 152, 0, 96, 0, 1, 2, 3, 4, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 5, 2, 255, 255, 178, 37, 0, 0, 255, 255, 171, 160, 0, 4, 255, 255, 185, 176, 0, 8, 255, 255, 199, 192, 1, 12, 255, 255, 199, 192, 1, 16, 255, 255, 199, 192, 1, 20, 76, 77, 84, 0, 67, 83, 84, 0, 69, 83, 84, 0, 69, 87, 84, 0, 69, 80, 84, 0, 69, 68, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 10, 69, 83, 84, 53, 69, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/US/Mountain": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 158, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 158, 166, 58, 144, 159, 187, 7, 128, 160, 134, 28, 144, 161, 154, 233, 128, 162, 101, 254, 144, 163, 132, 6, 0, 164, 69, 224, 144, 164, 143, 166, 128, 203, 137, 12, 144, 210, 35, 244, 112, 210, 97, 24, 0, 247, 47, 118, 144, 248, 40, 148, 0, 249, 15, 88, 144, 250, 8, 118, 0, 250, 248, 117, 16, 251, 232, 88, 0, 252, 216, 87, 16, 253, 200, 58, 0, 254, 184, 57, 16, 255, 168, 28, 0, 0, 152, 27, 16, 1, 135, 254, 0, 2, 119, 253, 16, 3, 113, 26, 128, 4, 97, 25, 144, 5, 80, 252, 128, 6, 64, 251, 144, 7, 48, 222, 128, 7, 141, 53, 144, 9, 16, 192, 128, 9, 173, 177, 16, 10, 240, 162, 128, 11, 224, 161, 144, 12, 217, 191, 0, 13, 192, 131, 144, 14, 185, 161, 0, 15, 169, 160, 16, 16, 153, 131, 0, 17, 137, 130, 16, 18, 121, 101, 0, 19, 105, 100, 16, 20, 89, 71, 0, 21, 73, 70, 16, 22, 57, 41, 0, 23, 41, 40, 16, 24, 34, 69, 128, 25, 9, 10, 16, 26, 2, 39, 128, 26, 242, 38, 144, 27, 226, 9, 128, 28, 210, 8, 144, 29, 193, 235, 128, 30, 177, 234, 144, 31, 161, 205, 128, 32, 118, 29, 16, 33, 129, 175, 128, 34, 85, 255, 16, 35, 106, 204, 0, 36, 53, 225, 16, 37, 74, 174, 0, 38, 21, 195, 16, 39, 42, 144, 0, 39, 254, 223, 144, 41, 10, 114, 0, 41, 222, 193, 144, 42, 234, 84, 0, 43, 190, 163, 144, 44, 211, 112, 128, 45, 158, 133, 144, 46, 179, 82, 128, 47, 126, 103, 144, 48, 147, 52, 128, 49, 103, 132, 16, 50, 115, 22, 128, 51, 71, 102, 16, 52, 82, 248, 128, 53, 39, 72, 16, 54, 50, 218, 128, 55, 7, 42, 16, 56, 27, 247, 0, 56, 231, 12, 16, 57, 251, 217, 0, 58, 198, 238, 16, 59, 219, 187, 0, 60, 176, 10, 144, 61, 187, 157, 0, 62, 143, 236, 144, 63, 155, 127, 0, 64, 111, 206, 144, 65, 132, 155, 128, 66, 79, 176, 144, 67, 100, 125, 128, 68, 47, 146, 144, 69, 68, 95, 128, 69, 243, 197, 16, 71, 45, 124, 0, 71, 211, 167, 16, 73, 13, 94, 0, 73, 179, 137, 16, 74, 237, 64, 0, 75, 156, 165, 144, 76, 214, 92, 128, 77, 124, 135, 144, 78, 182, 62, 128, 79, 92, 105, 144, 80, 150, 32, 128, 81, 60, 75, 144, 82, 118, 2, 128, 83, 28, 45, 144, 84, 85, 228, 128, 84, 252, 15, 144, 86, 53, 198, 128, 86, 229, 44, 16, 88, 30, 227, 0, 88, 197, 14, 16, 89, 254, 197, 0, 90, 164, 240, 16, 91, 222, 167, 0, 92, 132, 210, 16, 93, 190, 137, 0, 94, 100, 180, 16, 95, 158, 107, 0, 96, 77, 208, 144, 97, 135, 135, 128, 98, 45, 178, 144, 99, 103, 105, 128, 100, 13, 148, 144, 101, 71, 75, 128, 101, 237, 118, 144, 103, 39, 45, 128, 103, 205, 88, 144, 105, 7, 15, 128, 105, 173, 58, 144, 106, 230, 241, 128, 107, 150, 87, 16, 108, 208, 14, 0, 109, 118, 57, 16, 110, 175, 240, 0, 111, 86, 27, 16, 112, 143, 210, 0, 113, 53, 253, 16, 114, 111, 180, 0, 115, 21, 223, 16, 116, 79, 150, 0, 116, 254, 251, 144, 118, 56, 178, 128, 118, 222, 221, 144, 120, 24, 148, 128, 120, 190, 191, 144, 121, 248, 118, 128, 122, 158, 161, 144, 123, 216, 88, 128, 124, 126, 131, 144, 125, 184, 58, 128, 126, 94, 101, 144, 127, 152, 28, 128, 2, 1, 2, 1, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 157, 148, 0, 0, 255, 255, 171, 160, 1, 4, 255, 255, 157, 144, 0, 8, 255, 255, 171, 160, 1, 12, 255, 255, 171, 160, 1, 16, 76, 77, 84, 0, 77, 68, 84, 0, 77, 83, 84, 0, 77, 87, 84, 0, 77, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 77, 83, 84, 55, 77, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/US/Pacific": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 186, 0, 0, 0, 5, 0, 0, 0, 20, 128, 0, 0, 0, 158, 166, 72, 160, 159, 187, 21, 144, 160, 134, 42, 160, 161, 154, 247, 144, 203, 137, 26, 160, 210, 35, 244, 112, 210, 97, 38, 16, 214, 254, 116, 92, 216, 128, 173, 144, 218, 254, 195, 144, 219, 192, 144, 16, 220, 222, 165, 144, 221, 169, 172, 144, 222, 190, 135, 144, 223, 137, 142, 144, 224, 158, 105, 144, 225, 105, 112, 144, 226, 126, 75, 144, 227, 73, 82, 144, 228, 94, 45, 144, 229, 41, 52, 144, 230, 71, 74, 16, 231, 18, 81, 16, 232, 39, 44, 16, 232, 242, 51, 16, 234, 7, 14, 16, 234, 210, 21, 16, 235, 230, 240, 16, 236, 177, 247, 16, 237, 198, 210, 16, 238, 145, 217, 16, 239, 175, 238, 144, 240, 113, 187, 16, 241, 143, 208, 144, 242, 127, 193, 144, 243, 111, 178, 144, 244, 95, 163, 144, 245, 79, 148, 144, 246, 63, 133, 144, 247, 47, 118, 144, 248, 40, 162, 16, 249, 15, 88, 144, 250, 8, 132, 16, 250, 248, 131, 32, 251, 232, 102, 16, 252, 216, 101, 32, 253, 200, 72, 16, 254, 184, 71, 32, 255, 168, 42, 16, 0, 152, 41, 32, 1, 136, 12, 16, 2, 120, 11, 32, 3, 113, 40, 144, 4, 97, 39, 160, 5, 81, 10, 144, 6, 65, 9, 160, 7, 48, 236, 144, 7, 141, 67, 160, 9, 16, 206, 144, 9, 173, 191, 32, 10, 240, 176, 144, 11, 224, 175, 160, 12, 217, 205, 16, 13, 192, 145, 160, 14, 185, 175, 16, 15, 169, 174, 32, 16, 153, 145, 16, 17, 137, 144, 32, 18, 121, 115, 16, 19, 105, 114, 32, 20, 89, 85, 16, 21, 73, 84, 32, 22, 57, 55, 16, 23, 41, 54, 32, 24, 34, 83, 144, 25, 9, 24, 32, 26, 2, 53, 144, 26, 242, 52, 160, 27, 226, 23, 144, 28, 210, 22, 160, 29, 193, 249, 144, 30, 177, 248, 160, 31, 161, 219, 144, 32, 118, 43, 32, 33, 129, 189, 144, 34, 86, 13, 32, 35, 106, 218, 16, 36, 53, 239, 32, 37, 74, 188, 16, 38, 21, 209, 32, 39, 42, 158, 16, 39, 254, 237, 160, 41, 10, 128, 16, 41, 222, 207, 160, 42, 234, 98, 16, 43, 190, 177, 160, 44, 211, 126, 144, 45, 158, 147, 160, 46, 179, 96, 144, 47, 126, 117, 160, 48, 147, 66, 144, 49, 103, 146, 32, 50, 115, 36, 144, 51, 71, 116, 32, 52, 83, 6, 144, 53, 39, 86, 32, 54, 50, 232, 144, 55, 7, 56, 32, 56, 28, 5, 16, 56, 231, 26, 32, 57, 251, 231, 16, 58, 198, 252, 32, 59, 219, 201, 16, 60, 176, 24, 160, 61, 187, 171, 16, 62, 143, 250, 160, 63, 155, 141, 16, 64, 111, 220, 160, 65, 132, 169, 144, 66, 79, 190, 160, 67, 100, 139, 144, 68, 47, 160, 160, 69, 68, 109, 144, 69, 243, 211, 32, 71, 45, 138, 16, 71, 211, 181, 32, 73, 13, 108, 16, 73, 179, 151, 32, 74, 237, 78, 16, 75, 156, 179, 160, 76, 214, 106, 144, 77, 124, 149, 160, 78, 182, 76, 144, 79, 92, 119, 160, 80, 150, 46, 144, 81, 60, 89, 160, 82, 118, 16, 144, 83, 28, 59, 160, 84, 85, 242, 144, 84, 252, 29, 160, 86, 53, 212, 144, 86, 229, 58, 32, 88, 30, 241, 16, 88, 197, 28, 32, 89, 254, 211, 16, 90, 164, 254, 32, 91, 222, 181, 16, 92, 132, 224, 32, 93, 190, 151, 16, 94, 100, 194, 32, 95, 158, 121, 16, 96, 77, 222, 160, 97, 135, 149, 144, 98, 45, 192, 160, 99, 103, 119, 144, 100, 13, 162, 160, 101, 71, 89, 144, 101, 237, 132, 160, 103, 39, 59, 144, 103, 205, 102, 160, 105, 7, 29, 144, 105, 173, 72, 160, 106, 230, 255, 144, 107, 150, 101, 32, 108, 208, 28, 16, 109, 118, 71, 32, 110, 175, 254, 16, 111, 86, 41, 32, 112, 143, 224, 16, 113, 54, 11, 32, 114, 111, 194, 16, 115, 21, 237, 32, 116, 79, 164, 16, 116, 255, 9, 160, 118, 56, 192, 144, 118, 222, 235, 160, 120, 24, 162, 144, 120, 190, 205, 160, 121, 248, 132, 144, 122, 158, 175, 160, 123, 216, 102, 144, 124, 126, 145, 160, 125, 184, 72, 144, 126, 94, 115, 160, 127, 152, 42, 144, 2, 1, 2, 1, 2, 3, 4, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 1, 2, 255, 255, 145, 38, 0, 0, 255, 255, 157, 144, 1, 4, 255, 255, 143, 128, 0, 8, 255, 255, 157, 144, 1, 12, 255, 255, 157, 144, 1, 16, 76, 77, 84, 0, 80, 68, 84, 0, 80, 83, 84, 0, 80, 87, 84, 0, 80, 80, 84, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 10, 80, 83, 84, 56, 80, 68, 84, 44, 77, 51, 46, 50, 46, 48, 44, 77, 49, 49, 46, 49, 46, 48, 10}, - - "zoneinfo/US/Samoa": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 3, 0, 0, 0, 8, 128, 0, 0, 0, 145, 5, 251, 8, 1, 2, 0, 0, 177, 120, 0, 0, 255, 255, 95, 248, 0, 0, 255, 255, 101, 80, 0, 4, 76, 77, 84, 0, 83, 83, 84, 0, 0, 0, 0, 0, 0, 0, 10, 83, 83, 84, 49, 49, 10}, - - "zoneinfo/UTC": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 85, 84, 67, 0, 0, 0, 10, 85, 84, 67, 48, 10}, - - "zoneinfo/Universal": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 85, 84, 67, 0, 0, 0, 10, 85, 84, 67, 48, 10}, - - "zoneinfo/W-SU": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 17, 0, 0, 0, 17, 0, 0, 0, 0, 0, 0, 0, 78, 0, 0, 0, 17, 0, 0, 0, 38, 128, 0, 0, 0, 155, 95, 30, 199, 157, 62, 242, 121, 158, 42, 238, 249, 158, 247, 57, 105, 159, 132, 87, 249, 160, 216, 108, 233, 161, 0, 57, 128, 161, 60, 166, 64, 164, 16, 109, 192, 164, 61, 50, 176, 165, 21, 104, 176, 165, 61, 3, 192, 167, 30, 69, 80, 181, 164, 25, 96, 21, 39, 167, 208, 22, 24, 220, 64, 23, 8, 219, 80, 23, 250, 15, 192, 24, 234, 14, 208, 25, 219, 67, 64, 26, 204, 147, 208, 27, 188, 160, 240, 28, 172, 145, 240, 29, 156, 130, 240, 30, 140, 115, 240, 31, 124, 100, 240, 32, 108, 85, 240, 33, 92, 70, 240, 34, 76, 55, 240, 35, 60, 40, 240, 36, 44, 25, 240, 37, 28, 10, 240, 38, 11, 251, 240, 39, 5, 39, 112, 39, 245, 24, 112, 40, 229, 23, 128, 41, 120, 191, 128, 41, 212, 250, 112, 42, 196, 235, 112, 43, 180, 220, 112, 44, 164, 205, 112, 45, 148, 190, 112, 46, 132, 175, 112, 47, 116, 160, 112, 48, 100, 145, 112, 49, 93, 188, 240, 50, 114, 151, 240, 51, 61, 158, 240, 52, 82, 121, 240, 53, 29, 128, 240, 54, 50, 91, 240, 54, 253, 98, 240, 56, 27, 120, 112, 56, 221, 68, 240, 57, 251, 90, 112, 58, 189, 38, 240, 59, 219, 60, 112, 60, 166, 67, 112, 61, 187, 30, 112, 62, 134, 37, 112, 63, 155, 0, 112, 64, 102, 7, 112, 65, 132, 28, 240, 66, 69, 233, 112, 67, 99, 254, 240, 68, 37, 203, 112, 69, 67, 224, 240, 70, 5, 173, 112, 71, 35, 194, 240, 71, 238, 201, 240, 73, 3, 164, 240, 73, 206, 171, 240, 74, 227, 134, 240, 75, 174, 141, 240, 76, 204, 163, 112, 77, 142, 111, 240, 84, 76, 29, 96, 1, 3, 2, 3, 4, 2, 4, 5, 6, 7, 8, 7, 6, 9, 6, 7, 6, 7, 6, 7, 6, 7, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 12, 13, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 11, 10, 14, 10, 0, 0, 35, 57, 0, 0, 0, 0, 35, 57, 0, 4, 0, 0, 49, 135, 1, 8, 0, 0, 35, 119, 0, 4, 0, 0, 63, 151, 1, 12, 0, 0, 56, 64, 1, 17, 0, 0, 42, 48, 0, 21, 0, 0, 56, 64, 1, 17, 0, 0, 70, 80, 1, 25, 0, 0, 28, 32, 0, 29, 0, 0, 42, 48, 0, 21, 0, 0, 56, 64, 1, 17, 0, 0, 42, 48, 1, 33, 0, 0, 28, 32, 0, 29, 0, 0, 56, 64, 0, 21, 0, 0, 56, 64, 1, 17, 0, 0, 42, 48, 0, 21, 76, 77, 84, 0, 77, 77, 84, 0, 77, 83, 84, 0, 77, 68, 83, 84, 0, 77, 83, 68, 0, 77, 83, 75, 0, 43, 48, 53, 0, 69, 69, 84, 0, 69, 69, 83, 84, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 77, 83, 75, 45, 51, 10}, - - "zoneinfo/WET": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 122, 0, 0, 0, 2, 0, 0, 0, 9, 13, 164, 99, 144, 14, 139, 26, 16, 15, 132, 69, 144, 16, 116, 54, 144, 17, 100, 39, 144, 18, 84, 24, 144, 19, 77, 68, 16, 20, 51, 250, 144, 21, 35, 235, 144, 22, 19, 220, 144, 23, 3, 205, 144, 23, 243, 190, 144, 24, 227, 175, 144, 25, 211, 160, 144, 26, 195, 145, 144, 27, 188, 189, 16, 28, 172, 174, 16, 29, 156, 159, 16, 30, 140, 144, 16, 31, 124, 129, 16, 32, 108, 114, 16, 33, 92, 99, 16, 34, 76, 84, 16, 35, 60, 69, 16, 36, 44, 54, 16, 37, 28, 39, 16, 38, 12, 24, 16, 39, 5, 67, 144, 39, 245, 52, 144, 40, 229, 37, 144, 41, 213, 22, 144, 42, 197, 7, 144, 43, 180, 248, 144, 44, 164, 233, 144, 45, 148, 218, 144, 46, 132, 203, 144, 47, 116, 188, 144, 48, 100, 173, 144, 49, 93, 217, 16, 50, 114, 180, 16, 51, 61, 187, 16, 52, 82, 150, 16, 53, 29, 157, 16, 54, 50, 120, 16, 54, 253, 127, 16, 56, 27, 148, 144, 56, 221, 97, 16, 57, 251, 118, 144, 58, 189, 67, 16, 59, 219, 88, 144, 60, 166, 95, 144, 61, 187, 58, 144, 62, 134, 65, 144, 63, 155, 28, 144, 64, 102, 35, 144, 65, 132, 57, 16, 66, 70, 5, 144, 67, 100, 27, 16, 68, 37, 231, 144, 69, 67, 253, 16, 70, 5, 201, 144, 71, 35, 223, 16, 71, 238, 230, 16, 73, 3, 193, 16, 73, 206, 200, 16, 74, 227, 163, 16, 75, 174, 170, 16, 76, 204, 191, 144, 77, 142, 140, 16, 78, 172, 161, 144, 79, 110, 110, 16, 80, 140, 131, 144, 81, 87, 138, 144, 82, 108, 101, 144, 83, 55, 108, 144, 84, 76, 71, 144, 85, 23, 78, 144, 86, 44, 41, 144, 86, 247, 48, 144, 88, 21, 70, 16, 88, 215, 18, 144, 89, 245, 40, 16, 90, 182, 244, 144, 91, 213, 10, 16, 92, 160, 17, 16, 93, 180, 236, 16, 94, 127, 243, 16, 95, 148, 206, 16, 96, 95, 213, 16, 97, 125, 234, 144, 98, 63, 183, 16, 99, 93, 204, 144, 100, 31, 153, 16, 101, 61, 174, 144, 102, 8, 181, 144, 103, 29, 144, 144, 103, 232, 151, 144, 104, 253, 114, 144, 105, 200, 121, 144, 106, 221, 84, 144, 107, 168, 91, 144, 108, 198, 113, 16, 109, 136, 61, 144, 110, 166, 83, 16, 111, 104, 31, 144, 112, 134, 53, 16, 113, 81, 60, 16, 114, 102, 23, 16, 115, 49, 30, 16, 116, 69, 249, 16, 117, 17, 0, 16, 118, 47, 21, 144, 118, 240, 226, 16, 120, 14, 247, 144, 120, 208, 196, 16, 121, 238, 217, 144, 122, 176, 166, 16, 123, 206, 187, 144, 124, 153, 194, 144, 125, 174, 157, 144, 126, 121, 164, 144, 127, 142, 127, 144, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 14, 16, 1, 0, 0, 0, 0, 0, 0, 5, 87, 69, 83, 84, 0, 87, 69, 84, 0, 1, 1, 1, 1, 10, 87, 69, 84, 48, 87, 69, 83, 84, 44, 77, 51, 46, 53, 46, 48, 47, 49, 44, 77, 49, 48, 46, 53, 46, 48, 10}, - - "zoneinfo/Zulu": []byte{84, 90, 105, 102, 50, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 85, 84, 67, 0, 0, 0, 10, 85, 84, 67, 48, 10}, -} diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses/json_parser.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses/json_parser.go index 8ed3e9fa5ecf..4c9570198150 100644 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses/json_parser.go +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses/json_parser.go @@ -9,7 +9,7 @@ import ( "sync" "unsafe" - "github.com/json-iterator/go" + jsoniter "github.com/json-iterator/go" ) const maxUint = ^uint(0) @@ -22,7 +22,12 @@ var initJson = &sync.Once{} func initJsonParserOnce() { initJson.Do(func() { registerBetterFuzzyDecoder() - jsonParser = jsoniter.ConfigCompatibleWithStandardLibrary + jsonParser = jsoniter.Config{ + EscapeHTML: true, + SortMapKeys: true, + ValidateJsonRawMessage: true, + CaseSensitive: true, + }.Froze() }) } diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses/response.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses/response.go index 72514d56a56b..dd6ae5b4c308 100644 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses/response.go +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses/response.go @@ -23,6 +23,7 @@ import ( "strings" "github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors" + "github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils" ) type AcsResponse interface { @@ -35,6 +36,11 @@ type AcsResponse interface { parseFromHttpResponse(httpResponse *http.Response) error } +var debug utils.Debug + +func init() { + debug = utils.Init("sdk") +} // Unmarshal object from http response body to target Response func Unmarshal(response AcsResponse, httpResponse *http.Response, format string) (err error) { err = response.parseFromHttpResponse(httpResponse) @@ -109,6 +115,7 @@ func (baseResponse *BaseResponse) parseFromHttpResponse(httpResponse *http.Respo if err != nil { return } + debug("%s", string(body)) baseResponse.httpStatus = httpResponse.StatusCode baseResponse.httpHeaders = httpResponse.Header baseResponse.httpContentBytes = body diff --git a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils/utils.go b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils/utils.go index 068757d172d8..378e5010640a 100644 --- a/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils/utils.go +++ b/vendor/github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils/utils.go @@ -26,10 +26,6 @@ import ( "github.com/satori/go.uuid" ) -// if you use go 1.10 or higher, you can hack this util by these to avoid "TimeZone.zip not found" on Windows -var LoadLocationFromTZData func(name string, data []byte) (*time.Location, error) = nil -var TZData []byte = nil - func GetUUIDV4() (uuidHex string) { uuidV4 := uuid.NewV4() uuidHex = hex.EncodeToString(uuidV4.Bytes()) @@ -44,29 +40,15 @@ func GetMD5Base64(bytes []byte) (base64Value string) { return } -func GetGMTLocation() (*time.Location, error) { - if LoadLocationFromTZData != nil && TZData != nil { - return LoadLocationFromTZData("GMT", TZData) - } else { - return time.LoadLocation("GMT") - } -} - func GetTimeInFormatISO8601() (timeStr string) { - gmt, err := GetGMTLocation() + gmt := time.FixedZone("GMT", 0) - if err != nil { - panic(err) - } return time.Now().In(gmt).Format("2006-01-02T15:04:05Z") } func GetTimeInFormatRFC2616() (timeStr string) { - gmt, err := GetGMTLocation() + gmt := time.FixedZone("GMT", 0) - if err != nil { - panic(err) - } return time.Now().In(gmt).Format("Mon, 02 Jan 2006 15:04:05 GMT") } diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/LICENSE b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/LICENSE new file mode 100644 index 000000000000..b463b2914cd9 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "{}" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright 1999-2017 Alibaba Group Holding Ltd. + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/api.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/api.go new file mode 100644 index 000000000000..e807e3072a02 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/api.go @@ -0,0 +1,1240 @@ +package tablestore + +import ( + "bytes" + "crypto/md5" + "encoding/base64" + "fmt" + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" + "math/rand" + "net" + "net/http" + "time" + "io" + "strings" +) + +const ( + userAgent = "aliyun-tablestore-sdk-golang/4.0.2" + + createTableUri = "/CreateTable" + listTableUri = "/ListTable" + deleteTableUri = "/DeleteTable" + describeTableUri = "/DescribeTable" + updateTableUri = "/UpdateTable" + putRowUri = "/PutRow" + deleteRowUri = "/DeleteRow" + getRowUri = "/GetRow" + updateRowUri = "/UpdateRow" + batchGetRowUri = "/BatchGetRow" + batchWriteRowUri = "/BatchWriteRow" + getRangeUri = "/GetRange" + listStreamUri = "/ListStream" + describeStreamUri = "/DescribeStream" + getShardIteratorUri = "/GetShardIterator" + getStreamRecordUri = "/GetStreamRecord" + computeSplitPointsBySizeRequestUri = "/ComputeSplitPointsBySize" + searchUri = "/Search" + createSearchIndexUri = "/CreateSearchIndex" + listSearchIndexUri = "/ListSearchIndex" + deleteSearchIndexUri = "/DeleteSearchIndex" + describeSearchIndexUri = "/DescribeSearchIndex" + + createIndexUri = "/CreateIndex" + dropIndexUri = "/DropIndex" + + createlocaltransactionuri = "/StartLocalTransaction" + committransactionuri = "/CommitTransaction" + aborttransactionuri = "/AbortTransaction" +) + +// Constructor: to create the client of TableStore service. +// 构造函数：创建表格存储服务的客户端。 +// +// @param endPoint The address of TableStore service. 表格存储服务地址。 +// @param instanceName +// @param accessId The Access ID. 用于标示用户的ID。 +// @param accessKey The Access Key. 用于签名和验证的密钥。 +// @param options set client config +func NewClient(endPoint, instanceName, accessKeyId, accessKeySecret string, options ...ClientOption) *TableStoreClient { + client := NewClientWithConfig(endPoint, instanceName, accessKeyId, accessKeySecret, "", nil) + // client options parse + for _, option := range options { + option(client) + } + + return client +} + +type GetHttpClient func() IHttpClient + +var currentGetHttpClientFunc GetHttpClient = func() IHttpClient { + return &TableStoreHttpClient{} +} + +// Constructor: to create the client of OTS service. 传入config +// 构造函数：创建OTS服务的客户端。 +func NewClientWithConfig(endPoint, instanceName, accessKeyId, accessKeySecret string, securityToken string, config *TableStoreConfig) *TableStoreClient { + tableStoreClient := new(TableStoreClient) + tableStoreClient.endPoint = endPoint + tableStoreClient.instanceName = instanceName + tableStoreClient.accessKeyId = accessKeyId + tableStoreClient.accessKeySecret = accessKeySecret + tableStoreClient.securityToken = securityToken + if config == nil { + config = NewDefaultTableStoreConfig() + } + tableStoreClient.config = config + tableStoreTransportProxy := &http.Transport{ + MaxIdleConnsPerHost: config.MaxIdleConnections, + Dial: (&net.Dialer{ + Timeout: config.HTTPTimeout.ConnectionTimeout, + }).Dial, + } + + tableStoreClient.httpClient = currentGetHttpClientFunc() + + httpClient := &http.Client{ + Transport: tableStoreTransportProxy, + Timeout: tableStoreClient.config.HTTPTimeout.RequestTimeout, + } + tableStoreClient.httpClient.New(httpClient) + + tableStoreClient.random = rand.New(rand.NewSource(time.Now().Unix())) + + return tableStoreClient +} + +// 请求服务端 +func (tableStoreClient *TableStoreClient) doRequestWithRetry(uri string, req, resp proto.Message, responseInfo *ResponseInfo) error { + end := time.Now().Add(tableStoreClient.config.MaxRetryTime) + url := fmt.Sprintf("%s%s", tableStoreClient.endPoint, uri) + /* request body */ + var body []byte + var err error + if req != nil { + body, err = proto.Marshal(req) + if err != nil { + return err + } + } else { + body = nil + } + + var value int64 + var i uint + var respBody []byte + var requestId string + for i = 0; ; i++ { + respBody, err, requestId = tableStoreClient.doRequest(url, uri, body, resp) + responseInfo.RequestId = requestId + + if err == nil { + break + } else { + value = getNextPause(tableStoreClient, err, i, end, value, uri) + + // fmt.Println("hit retry", uri, err, *e.Code, value) + if value <= 0 { + return err + } + + time.Sleep(time.Duration(value) * time.Millisecond) + } + } + + if respBody == nil || len(respBody) == 0 { + return nil + } + + err = proto.Unmarshal(respBody, resp) + if err != nil { + return fmt.Errorf("decode resp failed: %s", err) + } + + return nil +} + +func getNextPause(tableStoreClient *TableStoreClient, err error, count uint, end time.Time, lastInterval int64, action string) int64 { + if tableStoreClient.config.RetryTimes <= count || time.Now().After(end) { + return 0 + } + var retry bool + if otsErr, ok := err.(*OtsError); ok { + retry = shouldRetry(otsErr.Code, otsErr.Message, action) + } else { + if err == io.EOF || err == io.ErrUnexpectedEOF || //retry on special net error contains EOF or reset + strings.Contains(err.Error(), io.EOF.Error()) || + strings.Contains(err.Error(), "Connection reset by peer") || + strings.Contains(err.Error(), "connection reset by peer") { + retry = true + } else if nErr, ok := err.(net.Error); ok { + retry = nErr.Temporary() + } + } + + if retry { + value := lastInterval*2 + tableStoreClient.random.Int63n(DefaultRetryInterval-1) + 1 + if value > MaxRetryInterval { + value = MaxRetryInterval + } + + return value + } + return 0 +} + +func shouldRetry(errorCode string, errorMsg string, action string) bool { + if retryNotMatterActions(errorCode, errorMsg) == true { + return true + } + + if isIdempotent(action) && + (errorCode == STORAGE_TIMEOUT || errorCode == INTERNAL_SERVER_ERROR || errorCode == SERVER_UNAVAILABLE) { + return true + } + return false +} + +func retryNotMatterActions(errorCode string, errorMsg string) bool { + if errorCode == ROW_OPERATION_CONFLICT || errorCode == NOT_ENOUGH_CAPACITY_UNIT || + errorCode == TABLE_NOT_READY || errorCode == PARTITION_UNAVAILABLE || + errorCode == SERVER_BUSY || errorCode == STORAGE_SERVER_BUSY || (errorCode == QUOTA_EXHAUSTED && errorMsg == "Too frequent table operations.") { + return true + } else { + return false + } +} + +func isIdempotent(action string) bool { + if action == batchGetRowUri || action == describeTableUri || + action == getRangeUri || action == getRowUri || + action == listTableUri || action == listStreamUri || + action == getStreamRecordUri || action == describeStreamUri { + return true + } else { + return false + } +} + +func (tableStoreClient *TableStoreClient) doRequest(url string, uri string, body []byte, resp proto.Message) ([]byte, error, string) { + hreq, err := http.NewRequest("POST", url, bytes.NewBuffer(body)) + if err != nil { + return nil, err, "" + } + /* set headers */ + hreq.Header.Set("User-Agent", userAgent) + + date := time.Now().UTC().Format(xOtsDateFormat) + + hreq.Header.Set(xOtsDate, date) + hreq.Header.Set(xOtsApiversion, ApiVersion) + hreq.Header.Set(xOtsAccesskeyid, tableStoreClient.accessKeyId) + hreq.Header.Set(xOtsInstanceName, tableStoreClient.instanceName) + + md5Byte := md5.Sum(body) + md5Base64 := base64.StdEncoding.EncodeToString(md5Byte[:16]) + hreq.Header.Set(xOtsContentmd5, md5Base64) + + otshead := createOtsHeaders(tableStoreClient.accessKeySecret) + otshead.set(xOtsDate, date) + otshead.set(xOtsApiversion, ApiVersion) + otshead.set(xOtsAccesskeyid, tableStoreClient.accessKeyId) + if tableStoreClient.securityToken != "" { + hreq.Header.Set(xOtsHeaderStsToken, tableStoreClient.securityToken) + otshead.set(xOtsHeaderStsToken, tableStoreClient.securityToken) + } + otshead.set(xOtsContentmd5, md5Base64) + otshead.set(xOtsInstanceName, tableStoreClient.instanceName) + sign, err := otshead.signature(uri, "POST", tableStoreClient.accessKeySecret) + + if err != nil { + return nil, err, "" + } + hreq.Header.Set(xOtsSignature, sign) + + /* end set headers */ + return tableStoreClient.postReq(hreq, url) +} + +// table API +// Create a table with the CreateTableRequest, in which the table name and +// primary keys are required. +// 根据CreateTableRequest创建一个表，其中表名和主健列是必选项 +// +// @param request of CreateTableRequest. +// @return Void. 无返回值。 +func (tableStoreClient *TableStoreClient) CreateTable(request *CreateTableRequest) (*CreateTableResponse, error) { + if len(request.TableMeta.TableName) > maxTableNameLength { + return nil, errTableNameTooLong(request.TableMeta.TableName) + } + + if len(request.TableMeta.SchemaEntry) > maxPrimaryKeyNum { + return nil, errPrimaryKeyTooMuch + } + + if len(request.TableMeta.SchemaEntry) == 0 { + return nil, errCreateTableNoPrimaryKey + } + + req := new(otsprotocol.CreateTableRequest) + req.TableMeta = new(otsprotocol.TableMeta) + req.TableMeta.TableName = proto.String(request.TableMeta.TableName) + + if len(request.TableMeta.DefinedColumns) > 0 { + for _, value := range request.TableMeta.DefinedColumns { + req.TableMeta.DefinedColumn = append(req.TableMeta.DefinedColumn, &otsprotocol.DefinedColumnSchema{Name: &value.Name, Type: value.ColumnType.ConvertToPbDefinedColumnType().Enum() }) + } + } + + if len(request.IndexMetas) > 0 { + for _, value := range request.IndexMetas { + req.IndexMetas = append(req.IndexMetas, value.ConvertToPbIndexMeta()) + } + } + + for _, key := range request.TableMeta.SchemaEntry { + keyType := otsprotocol.PrimaryKeyType(*key.Type) + if key.Option != nil { + keyOption := otsprotocol.PrimaryKeyOption(*key.Option) + req.TableMeta.PrimaryKey = append(req.TableMeta.PrimaryKey, &otsprotocol.PrimaryKeySchema{Name: key.Name, Type: &keyType, Option: &keyOption}) + } else { + req.TableMeta.PrimaryKey = append(req.TableMeta.PrimaryKey, &otsprotocol.PrimaryKeySchema{Name: key.Name, Type: &keyType}) + } + } + + req.ReservedThroughput = new(otsprotocol.ReservedThroughput) + req.ReservedThroughput.CapacityUnit = new(otsprotocol.CapacityUnit) + req.ReservedThroughput.CapacityUnit.Read = proto.Int32(int32(request.ReservedThroughput.Readcap)) + req.ReservedThroughput.CapacityUnit.Write = proto.Int32(int32(request.ReservedThroughput.Writecap)) + + req.TableOptions = new(otsprotocol.TableOptions) + req.TableOptions.TimeToLive = proto.Int32(int32(request.TableOption.TimeToAlive)) + req.TableOptions.MaxVersions = proto.Int32(int32(request.TableOption.MaxVersion)) + + if request.StreamSpec != nil { + var ss otsprotocol.StreamSpecification + if request.StreamSpec.EnableStream { + ss = otsprotocol.StreamSpecification{ + EnableStream: &request.StreamSpec.EnableStream, + ExpirationTime: &request.StreamSpec.ExpirationTime} + } else { + ss = otsprotocol.StreamSpecification{ + EnableStream: &request.StreamSpec.EnableStream} + } + + req.StreamSpec = &ss + } + + resp := new(otsprotocol.CreateTableResponse) + response := &CreateTableResponse{} + if err := tableStoreClient.doRequestWithRetry(createTableUri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + + return response, nil +} + +func (tableStoreClient *TableStoreClient) CreateIndex(request *CreateIndexRequest) (*CreateIndexResponse, error) { + if len(request.MainTableName) > maxTableNameLength { + return nil, errTableNameTooLong(request.MainTableName) + } + + req := new(otsprotocol.CreateIndexRequest) + req.IndexMeta = request.IndexMeta.ConvertToPbIndexMeta() + req.IncludeBaseData = proto.Bool(request.IncludeBaseData) + req.MainTableName = proto.String(request.MainTableName) + + resp := new(otsprotocol.CreateIndexResponse) + response := &CreateIndexResponse{} + if err := tableStoreClient.doRequestWithRetry(createIndexUri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + + return response, nil +} + +func (tableStoreClient *TableStoreClient) DeleteIndex(request *DeleteIndexRequest) (*DeleteIndexResponse, error) { + if len(request.MainTableName) > maxTableNameLength { + return nil, errTableNameTooLong(request.MainTableName) + } + + req := new(otsprotocol.DropIndexRequest) + req.IndexName = proto.String(request.IndexName) + req.MainTableName = proto.String(request.MainTableName) + + resp := new(otsprotocol.DropIndexResponse) + response := &DeleteIndexResponse{} + if err := tableStoreClient.doRequestWithRetry(dropIndexUri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + + return response, nil +} + +// List all tables. If done, all table names will be returned. +// 列出所有的表，如果操作成功，将返回所有表的名称。 +// +// @param tableNames The returned table names. 返回的表名集合。 +// @return Void. 无返回值。 +func (tableStoreClient *TableStoreClient) ListTable() (*ListTableResponse, error) { + resp := new(otsprotocol.ListTableResponse) + response := &ListTableResponse{} + if err := tableStoreClient.doRequestWithRetry(listTableUri, nil, resp, &response.ResponseInfo); err != nil { + return response, err + } + + response.TableNames = resp.TableNames + return response, nil +} + +// Delete a table and all its views will be deleted. +// 删除一个表 +// +// @param tableName The table name. 表名。 +// @return Void. 无返回值。 +func (tableStoreClient *TableStoreClient) DeleteTable(request *DeleteTableRequest) (*DeleteTableResponse, error) { + req := new(otsprotocol.DeleteTableRequest) + req.TableName = proto.String(request.TableName) + + response := &DeleteTableResponse{} + if err := tableStoreClient.doRequestWithRetry(deleteTableUri, req, nil, &response.ResponseInfo); err != nil { + return nil, err + } + return response, nil +} + +// Query the tablemeta, tableoption and reservedthroughtputdetails +// @param DescribeTableRequest +// @param DescribeTableResponse +func (tableStoreClient *TableStoreClient) DescribeTable(request *DescribeTableRequest) (*DescribeTableResponse, error) { + req := new(otsprotocol.DescribeTableRequest) + req.TableName = proto.String(request.TableName) + + resp := new(otsprotocol.DescribeTableResponse) + response := new(DescribeTableResponse) + + if err := tableStoreClient.doRequestWithRetry(describeTableUri, req, resp, &response.ResponseInfo); err != nil { + return &DescribeTableResponse{}, err + } + + response.ReservedThroughput = &ReservedThroughput{Readcap: int(*(resp.ReservedThroughputDetails.CapacityUnit.Read)), Writecap: int(*(resp.ReservedThroughputDetails.CapacityUnit.Write))} + + responseTableMeta := new(TableMeta) + responseTableMeta.TableName = *resp.TableMeta.TableName + + for _, key := range resp.TableMeta.PrimaryKey { + keyType := PrimaryKeyType(*key.Type) + + // enable it when we support kep option in describe table + if key.Option != nil { + keyOption := PrimaryKeyOption(*key.Option) + responseTableMeta.SchemaEntry = append(responseTableMeta.SchemaEntry, &PrimaryKeySchema{Name: key.Name, Type: &keyType, Option: &keyOption}) + } else { + responseTableMeta.SchemaEntry = append(responseTableMeta.SchemaEntry, &PrimaryKeySchema{Name: key.Name, Type: &keyType}) + } + } + response.TableMeta = responseTableMeta + response.TableOption = &TableOption{TimeToAlive: int(*resp.TableOptions.TimeToLive), MaxVersion: int(*resp.TableOptions.MaxVersions)} + if resp.StreamDetails != nil && *resp.StreamDetails.EnableStream { + response.StreamDetails = &StreamDetails{ + EnableStream: *resp.StreamDetails.EnableStream, + StreamId: (*StreamId)(resp.StreamDetails.StreamId), + ExpirationTime: *resp.StreamDetails.ExpirationTime, + LastEnableTime: *resp.StreamDetails.LastEnableTime} + } else { + response.StreamDetails = &StreamDetails{ + EnableStream: false} + } + + for _, meta := range resp.IndexMetas { + response.IndexMetas = append(response.IndexMetas, ConvertPbIndexMetaToIndexMeta(meta)) + } + + return response, nil +} + +// Update the table info includes tableoptions and reservedthroughput +// @param UpdateTableRequest +// @param UpdateTableResponse +func (tableStoreClient *TableStoreClient) UpdateTable(request *UpdateTableRequest) (*UpdateTableResponse, error) { + req := new(otsprotocol.UpdateTableRequest) + req.TableName = proto.String(request.TableName) + + if request.ReservedThroughput != nil { + req.ReservedThroughput = new(otsprotocol.ReservedThroughput) + req.ReservedThroughput.CapacityUnit = new(otsprotocol.CapacityUnit) + req.ReservedThroughput.CapacityUnit.Read = proto.Int32(int32(request.ReservedThroughput.Readcap)) + req.ReservedThroughput.CapacityUnit.Write = proto.Int32(int32(request.ReservedThroughput.Writecap)) + } + + if request.TableOption != nil { + req.TableOptions = new(otsprotocol.TableOptions) + req.TableOptions.TimeToLive = proto.Int32(int32(request.TableOption.TimeToAlive)) + req.TableOptions.MaxVersions = proto.Int32(int32(request.TableOption.MaxVersion)) + } + + if request.StreamSpec != nil { + req.StreamSpec = &otsprotocol.StreamSpecification{ + EnableStream: &request.StreamSpec.EnableStream, + ExpirationTime: &request.StreamSpec.ExpirationTime} + } + + resp := new(otsprotocol.UpdateTableResponse) + response := new(UpdateTableResponse) + + if err := tableStoreClient.doRequestWithRetry(updateTableUri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + + response.ReservedThroughput = &ReservedThroughput{ + Readcap: int(*(resp.ReservedThroughputDetails.CapacityUnit.Read)), + Writecap: int(*(resp.ReservedThroughputDetails.CapacityUnit.Write))} + response.TableOption = &TableOption{ + TimeToAlive: int(*resp.TableOptions.TimeToLive), + MaxVersion: int(*resp.TableOptions.MaxVersions)} + if *resp.StreamDetails.EnableStream { + response.StreamDetails = &StreamDetails{ + EnableStream: *resp.StreamDetails.EnableStream, + StreamId: (*StreamId)(resp.StreamDetails.StreamId), + ExpirationTime: *resp.StreamDetails.ExpirationTime, + LastEnableTime: *resp.StreamDetails.LastEnableTime} + } else { + response.StreamDetails = &StreamDetails{ + EnableStream: false} + } + return response, nil +} + +// Put or update a row in a table. The operation is determined by CheckingType, +// which has three options: NO, UPDATE, INSERT. The transaction id is optional. +// 插入或更新行数据。操作针对数据的存在性包含三种检查类型：NO(不检查)，UPDATE +// （更新，数据必须存在）和INSERT（插入，数据必须不存在）。事务ID是可选项。 +// +// @param builder The builder for putting a row. 插入或更新数据的Builder。 +// @return Void. 无返回值。 +func (tableStoreClient *TableStoreClient) PutRow(request *PutRowRequest) (*PutRowResponse, error) { + if request == nil { + return nil, nil + } + + if request.PutRowChange == nil { + return nil, nil + } + + req := new(otsprotocol.PutRowRequest) + req.TableName = proto.String(request.PutRowChange.TableName) + req.Row = request.PutRowChange.Serialize() + + condition := new(otsprotocol.Condition) + condition.RowExistence = request.PutRowChange.Condition.buildCondition() + if request.PutRowChange.Condition.ColumnCondition != nil { + condition.ColumnCondition = request.PutRowChange.Condition.ColumnCondition.Serialize() + } + + if request.PutRowChange.ReturnType == ReturnType_RT_PK { + content := otsprotocol.ReturnContent{ReturnType: otsprotocol.ReturnType_RT_PK.Enum()} + req.ReturnContent = &content + } + + if request.PutRowChange.TransactionId != nil { + req.TransactionId = request.PutRowChange.TransactionId + } + + req.Condition = condition + + resp := new(otsprotocol.PutRowResponse) + response := &PutRowResponse{} + if err := tableStoreClient.doRequestWithRetry(putRowUri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + + response.ConsumedCapacityUnit = &ConsumedCapacityUnit{} + response.ConsumedCapacityUnit.Read = *resp.Consumed.CapacityUnit.Read + response.ConsumedCapacityUnit.Write = *resp.Consumed.CapacityUnit.Write + + if request.PutRowChange.ReturnType == ReturnType_RT_PK { + rows, err := readRowsWithHeader(bytes.NewReader(resp.Row)) + if err != nil { + return response, err + } + + for _, pk := range rows[0].primaryKey { + pkColumn := &PrimaryKeyColumn{ColumnName: string(pk.cellName), Value: pk.cellValue.Value} + response.PrimaryKey.PrimaryKeys = append(response.PrimaryKey.PrimaryKeys, pkColumn) + } + } + + return response, nil +} + +// Delete row with pk +// @param DeleteRowRequest +func (tableStoreClient *TableStoreClient) DeleteRow(request *DeleteRowRequest) (*DeleteRowResponse, error) { + req := new(otsprotocol.DeleteRowRequest) + req.TableName = proto.String(request.DeleteRowChange.TableName) + req.Condition = request.DeleteRowChange.getCondition() + req.PrimaryKey = request.DeleteRowChange.PrimaryKey.Build(true) + + if request.DeleteRowChange.TransactionId != nil { + req.TransactionId = request.DeleteRowChange.TransactionId + } + + resp := new(otsprotocol.DeleteRowResponse) + response := &DeleteRowResponse{} + if err := tableStoreClient.doRequestWithRetry(deleteRowUri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + + response.ConsumedCapacityUnit = &ConsumedCapacityUnit{} + response.ConsumedCapacityUnit.Read = *resp.Consumed.CapacityUnit.Read + response.ConsumedCapacityUnit.Write = *resp.Consumed.CapacityUnit.Write + return response, nil +} + +// row API +// Get the data of a row or some columns. +// +// @param getrowrequest +func (tableStoreClient *TableStoreClient) GetRow(request *GetRowRequest) (*GetRowResponse, error) { + req := new(otsprotocol.GetRowRequest) + resp := new(otsprotocol.GetRowResponse) + + req.TableName = proto.String(request.SingleRowQueryCriteria.TableName) + + if (request.SingleRowQueryCriteria.getColumnsToGet() != nil) && len(request.SingleRowQueryCriteria.getColumnsToGet()) > 0 { + req.ColumnsToGet = request.SingleRowQueryCriteria.getColumnsToGet() + } + + req.PrimaryKey = request.SingleRowQueryCriteria.PrimaryKey.Build(false) + + if request.SingleRowQueryCriteria.MaxVersion != 0 { + req.MaxVersions = proto.Int32(int32(request.SingleRowQueryCriteria.MaxVersion)) + } + + if request.SingleRowQueryCriteria.TransactionId != nil { + req.TransactionId = request.SingleRowQueryCriteria.TransactionId + } + + if request.SingleRowQueryCriteria.StartColumn != nil { + req.StartColumn = request.SingleRowQueryCriteria.StartColumn + } + + if request.SingleRowQueryCriteria.EndColumn != nil { + req.EndColumn = request.SingleRowQueryCriteria.EndColumn + } + + if request.SingleRowQueryCriteria.TimeRange != nil { + if request.SingleRowQueryCriteria.TimeRange.Specific != 0 { + req.TimeRange = &otsprotocol.TimeRange{SpecificTime: proto.Int64(request.SingleRowQueryCriteria.TimeRange.Specific)} + } else { + req.TimeRange = &otsprotocol.TimeRange{StartTime: proto.Int64(request.SingleRowQueryCriteria.TimeRange.Start), EndTime: proto.Int64(request.SingleRowQueryCriteria.TimeRange.End)} + } + } else if request.SingleRowQueryCriteria.MaxVersion == 0 { + return nil, errInvalidInput + } + + if request.SingleRowQueryCriteria.Filter != nil { + req.Filter = request.SingleRowQueryCriteria.Filter.Serialize() + } + + response := &GetRowResponse{ConsumedCapacityUnit: &ConsumedCapacityUnit{}} + if err := tableStoreClient.doRequestWithRetry(getRowUri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + + response.ConsumedCapacityUnit.Read = *resp.Consumed.CapacityUnit.Read + response.ConsumedCapacityUnit.Write = *resp.Consumed.CapacityUnit.Write + + if len(resp.Row) == 0 { + return response, nil + } + + rows, err := readRowsWithHeader(bytes.NewReader(resp.Row)) + if err != nil { + return nil, err + } + + for _, pk := range rows[0].primaryKey { + pkColumn := &PrimaryKeyColumn{ColumnName: string(pk.cellName), Value: pk.cellValue.Value} + response.PrimaryKey.PrimaryKeys = append(response.PrimaryKey.PrimaryKeys, pkColumn) + } + + for _, cell := range rows[0].cells { + dataColumn := &AttributeColumn{ColumnName: string(cell.cellName), Value: cell.cellValue.Value, Timestamp: cell.cellTimestamp} + response.Columns = append(response.Columns, dataColumn) + } + + return response, nil +} + +// Update row +// @param UpdateRowRequest +func (tableStoreClient *TableStoreClient) UpdateRow(request *UpdateRowRequest) (*UpdateRowResponse, error) { + req := new(otsprotocol.UpdateRowRequest) + resp := new(otsprotocol.UpdateRowResponse) + + req.TableName = proto.String(request.UpdateRowChange.TableName) + req.Condition = request.UpdateRowChange.getCondition() + req.RowChange = request.UpdateRowChange.Serialize() + if request.UpdateRowChange.TransactionId != nil { + req.TransactionId = request.UpdateRowChange.TransactionId + } + + response := &UpdateRowResponse{ConsumedCapacityUnit: &ConsumedCapacityUnit{}} + + if request.UpdateRowChange.ReturnType == ReturnType_RT_AFTER_MODIFY { + content := otsprotocol.ReturnContent{ReturnType: otsprotocol.ReturnType_RT_AFTER_MODIFY.Enum()} + for _, column := range request.UpdateRowChange.ColumnNamesToReturn { + content.ReturnColumnNames = append(content.ReturnColumnNames, column) + } + req.ReturnContent = &content + } + + if err := tableStoreClient.doRequestWithRetry(updateRowUri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + + if request.UpdateRowChange.ReturnType == ReturnType_RT_AFTER_MODIFY { + plainbufferRow, err := readRowsWithHeader(bytes.NewReader(resp.Row)) + if err != nil { + return response, err + } + for _, cell := range plainbufferRow[0].cells { + fmt.Println(cell.cellName) + attribute := &AttributeColumn{ColumnName: string(cell.cellName), Value: cell.cellValue.Value, Timestamp: cell.cellTimestamp} + response.Columns = append(response.Columns, attribute) + } + } + + response.ConsumedCapacityUnit.Read = *resp.Consumed.CapacityUnit.Read + response.ConsumedCapacityUnit.Write = *resp.Consumed.CapacityUnit.Write + return response, nil +} + +// Batch Get Row +// @param BatchGetRowRequest +func (tableStoreClient *TableStoreClient) BatchGetRow(request *BatchGetRowRequest) (*BatchGetRowResponse, error) { + req := new(otsprotocol.BatchGetRowRequest) + + var tablesInBatch []*otsprotocol.TableInBatchGetRowRequest + + for _, Criteria := range request.MultiRowQueryCriteria { + table := new(otsprotocol.TableInBatchGetRowRequest) + table.TableName = proto.String(Criteria.TableName) + table.ColumnsToGet = Criteria.ColumnsToGet + + if Criteria.StartColumn != nil { + table.StartColumn = Criteria.StartColumn + } + + if Criteria.EndColumn != nil { + table.EndColumn = Criteria.EndColumn + } + + if Criteria.Filter != nil { + table.Filter = Criteria.Filter.Serialize() + } + + if Criteria.MaxVersion != 0 { + table.MaxVersions = proto.Int32(int32(Criteria.MaxVersion)) + } + + if Criteria.TimeRange != nil { + if Criteria.TimeRange.Specific != 0 { + table.TimeRange = &otsprotocol.TimeRange{SpecificTime: proto.Int64(Criteria.TimeRange.Specific)} + } else { + table.TimeRange = &otsprotocol.TimeRange{StartTime: proto.Int64(Criteria.TimeRange.Start), EndTime: proto.Int64(Criteria.TimeRange.End)} + } + } else if Criteria.MaxVersion == 0 { + return nil, errInvalidInput + } + + for _, pk := range Criteria.PrimaryKey { + pkWithBytes := pk.Build(false) + table.PrimaryKey = append(table.PrimaryKey, pkWithBytes) + } + + tablesInBatch = append(tablesInBatch, table) + } + + req.Tables = tablesInBatch + resp := new(otsprotocol.BatchGetRowResponse) + + response := &BatchGetRowResponse{TableToRowsResult: make(map[string][]RowResult)} + if err := tableStoreClient.doRequestWithRetry(batchGetRowUri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + + for _, table := range resp.Tables { + index := int32(0) + for _, row := range table.Rows { + rowResult := &RowResult{TableName: *table.TableName, IsSucceed: *row.IsOk, ConsumedCapacityUnit: &ConsumedCapacityUnit{}, Index: index} + index++ + if *row.IsOk == false { + rowResult.Error = Error{Code: *row.Error.Code, Message: *row.Error.Message} + } else { + // len == 0 means row not exist + if len(row.Row) > 0 { + rows, err := readRowsWithHeader(bytes.NewReader(row.Row)) + if err != nil { + return nil, err + } + + for _, pk := range rows[0].primaryKey { + pkColumn := &PrimaryKeyColumn{ColumnName: string(pk.cellName), Value: pk.cellValue.Value} + rowResult.PrimaryKey.PrimaryKeys = append(rowResult.PrimaryKey.PrimaryKeys, pkColumn) + } + + for _, cell := range rows[0].cells { + dataColumn := &AttributeColumn{ColumnName: string(cell.cellName), Value: cell.cellValue.Value, Timestamp: cell.cellTimestamp} + rowResult.Columns = append(rowResult.Columns, dataColumn) + } + } + + rowResult.ConsumedCapacityUnit.Read = *row.Consumed.CapacityUnit.Read + rowResult.ConsumedCapacityUnit.Write = *row.Consumed.CapacityUnit.Write + } + + response.TableToRowsResult[*table.TableName] = append(response.TableToRowsResult[*table.TableName], *rowResult) + } + + } + return response, nil +} + +// Batch Write Row +// @param BatchWriteRowRequest +func (tableStoreClient *TableStoreClient) BatchWriteRow(request *BatchWriteRowRequest) (*BatchWriteRowResponse, error) { + req := new(otsprotocol.BatchWriteRowRequest) + + var tablesInBatch []*otsprotocol.TableInBatchWriteRowRequest + + for key, value := range request.RowChangesGroupByTable { + table := new(otsprotocol.TableInBatchWriteRowRequest) + table.TableName = proto.String(key) + + for _, row := range value { + rowInBatch := &otsprotocol.RowInBatchWriteRowRequest{} + rowInBatch.Condition = row.getCondition() + rowInBatch.RowChange = row.Serialize() + rowInBatch.Type = row.getOperationType().Enum() + table.Rows = append(table.Rows, rowInBatch) + } + + tablesInBatch = append(tablesInBatch, table) + } + + req.Tables = tablesInBatch + + resp := new(otsprotocol.BatchWriteRowResponse) + response := &BatchWriteRowResponse{TableToRowsResult: make(map[string][]RowResult)} + + if err := tableStoreClient.doRequestWithRetry(batchWriteRowUri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + + for _, table := range resp.Tables { + index := int32(0) + for _, row := range table.Rows { + rowResult := &RowResult{TableName: *table.TableName, IsSucceed: *row.IsOk, ConsumedCapacityUnit: &ConsumedCapacityUnit{}, Index: index} + index++ + if *row.IsOk == false { + rowResult.Error = Error{Code: *row.Error.Code, Message: *row.Error.Message} + } else { + rowResult.ConsumedCapacityUnit.Read = *row.Consumed.CapacityUnit.Read + rowResult.ConsumedCapacityUnit.Write = *row.Consumed.CapacityUnit.Write + } /*else { + rows, err := readRowsWithHeader(bytes.NewReader(row.Row)) + if err != nil { + return nil, err + } + + for _, pk := range (rows[0].primaryKey) { + pkColumn := &PrimaryKeyColumn{ColumnName: string(pk.cellName), Value: pk.cellValue.Value} + rowResult.PrimaryKey.PrimaryKeys = append(rowResult.PrimaryKey.PrimaryKeys, pkColumn) + } + + for _, cell := range (rows[0].cells) { + dataColumn := &DataColumn{ColumnName: string(cell.cellName), Value: cell.cellValue.Value} + rowResult.Columns = append(rowResult.Columns, dataColumn) + } + + rowResult.ConsumedCapacityUnit.Read = *row.Consumed.CapacityUnit.Read + rowResult.ConsumedCapacityUnit.Write = *row.Consumed.CapacityUnit.Write + }*/ + + response.TableToRowsResult[*table.TableName] = append(response.TableToRowsResult[*table.TableName], *rowResult) + } + } + return response, nil +} + +// Get Range +// @param GetRangeRequest +func (tableStoreClient *TableStoreClient) GetRange(request *GetRangeRequest) (*GetRangeResponse, error) { + req := new(otsprotocol.GetRangeRequest) + req.TableName = proto.String(request.RangeRowQueryCriteria.TableName) + req.Direction = request.RangeRowQueryCriteria.Direction.ToDirection().Enum() + + if request.RangeRowQueryCriteria.MaxVersion != 0 { + req.MaxVersions = proto.Int32(request.RangeRowQueryCriteria.MaxVersion) + } + + if request.RangeRowQueryCriteria.TransactionId != nil { + req.TransactionId = request.RangeRowQueryCriteria.TransactionId + } + + if request.RangeRowQueryCriteria.TimeRange != nil { + if request.RangeRowQueryCriteria.TimeRange.Specific != 0 { + req.TimeRange = &otsprotocol.TimeRange{SpecificTime: proto.Int64(request.RangeRowQueryCriteria.TimeRange.Specific)} + } else { + req.TimeRange = &otsprotocol.TimeRange{StartTime: proto.Int64(request.RangeRowQueryCriteria.TimeRange.Start), EndTime: proto.Int64(request.RangeRowQueryCriteria.TimeRange.End)} + } + } else if request.RangeRowQueryCriteria.MaxVersion == 0 { + return nil, errInvalidInput + } + + if request.RangeRowQueryCriteria.Limit != 0 { + req.Limit = proto.Int32(request.RangeRowQueryCriteria.Limit) + } + + if (request.RangeRowQueryCriteria.ColumnsToGet != nil) && len(request.RangeRowQueryCriteria.ColumnsToGet) > 0 { + req.ColumnsToGet = request.RangeRowQueryCriteria.ColumnsToGet + } + + if request.RangeRowQueryCriteria.Filter != nil { + req.Filter = request.RangeRowQueryCriteria.Filter.Serialize() + } + + if request.RangeRowQueryCriteria.StartColumn != nil { + req.StartColumn = request.RangeRowQueryCriteria.StartColumn + } + + if request.RangeRowQueryCriteria.EndColumn != nil { + req.EndColumn = request.RangeRowQueryCriteria.EndColumn + } + + req.InclusiveStartPrimaryKey = request.RangeRowQueryCriteria.StartPrimaryKey.Build(false) + req.ExclusiveEndPrimaryKey = request.RangeRowQueryCriteria.EndPrimaryKey.Build(false) + + resp := new(otsprotocol.GetRangeResponse) + response := &GetRangeResponse{ConsumedCapacityUnit: &ConsumedCapacityUnit{}} + if err := tableStoreClient.doRequestWithRetry(getRangeUri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + + response.ConsumedCapacityUnit.Read = *resp.Consumed.CapacityUnit.Read + response.ConsumedCapacityUnit.Write = *resp.Consumed.CapacityUnit.Write + if len(resp.NextStartPrimaryKey) != 0 { + currentRows, err := readRowsWithHeader(bytes.NewReader(resp.NextStartPrimaryKey)) + if err != nil { + return nil, err + } + + response.NextStartPrimaryKey = &PrimaryKey{} + for _, pk := range currentRows[0].primaryKey { + pkColumn := &PrimaryKeyColumn{ColumnName: string(pk.cellName), Value: pk.cellValue.Value} + response.NextStartPrimaryKey.PrimaryKeys = append(response.NextStartPrimaryKey.PrimaryKeys, pkColumn) + } + } + + if len(resp.Rows) == 0 { + return response, nil + } + + rows, err := readRowsWithHeader(bytes.NewReader(resp.Rows)) + if err != nil { + return response, err + } + + for _, row := range rows { + currentRow := &Row{} + currentpk := new(PrimaryKey) + for _, pk := range row.primaryKey { + pkColumn := &PrimaryKeyColumn{ColumnName: string(pk.cellName), Value: pk.cellValue.Value} + currentpk.PrimaryKeys = append(currentpk.PrimaryKeys, pkColumn) + } + + currentRow.PrimaryKey = currentpk + + for _, cell := range row.cells { + dataColumn := &AttributeColumn{ColumnName: string(cell.cellName), Value: cell.cellValue.Value, Timestamp: cell.cellTimestamp} + currentRow.Columns = append(currentRow.Columns, dataColumn) + } + + response.Rows = append(response.Rows, currentRow) + } + + return response, nil + +} + +func (client *TableStoreClient) ListStream(req *ListStreamRequest) (*ListStreamResponse, error) { + pbReq := &otsprotocol.ListStreamRequest{} + pbReq.TableName = req.TableName + + pbResp := otsprotocol.ListStreamResponse{} + resp := ListStreamResponse{} + if err := client.doRequestWithRetry(listStreamUri, pbReq, &pbResp, &resp.ResponseInfo); err != nil { + return nil, err + } + + streams := make([]Stream, len(pbResp.Streams)) + for i, pbStream := range pbResp.Streams { + streams[i] = Stream{ + Id: (*StreamId)(pbStream.StreamId), + TableName: pbStream.TableName, + CreationTime: *pbStream.CreationTime} + } + resp.Streams = streams[:] + return &resp, nil +} + +func (client *TableStoreClient) DescribeStream(req *DescribeStreamRequest) (*DescribeStreamResponse, error) { + pbReq := &otsprotocol.DescribeStreamRequest{} + { + pbReq.StreamId = (*string)(req.StreamId) + pbReq.InclusiveStartShardId = (*string)(req.InclusiveStartShardId) + pbReq.ShardLimit = req.ShardLimit + } + pbResp := otsprotocol.DescribeStreamResponse{} + resp := DescribeStreamResponse{} + if err := client.doRequestWithRetry(describeStreamUri, pbReq, &pbResp, &resp.ResponseInfo); err != nil { + return nil, err + } + + resp.StreamId = (*StreamId)(pbResp.StreamId) + resp.ExpirationTime = *pbResp.ExpirationTime + resp.TableName = pbResp.TableName + resp.CreationTime = *pbResp.CreationTime + Assert(pbResp.StreamStatus != nil, "StreamStatus in DescribeStreamResponse is required.") + switch *pbResp.StreamStatus { + case otsprotocol.StreamStatus_STREAM_ENABLING: + resp.Status = SS_Enabling + case otsprotocol.StreamStatus_STREAM_ACTIVE: + resp.Status = SS_Active + } + resp.NextShardId = (*ShardId)(pbResp.NextShardId) + shards := make([]*StreamShard, len(pbResp.Shards)) + for i, pbShard := range pbResp.Shards { + shards[i] = &StreamShard{ + SelfShard: (*ShardId)(pbShard.ShardId), + FatherShard: (*ShardId)(pbShard.ParentId), + MotherShard: (*ShardId)(pbShard.ParentSiblingId)} + } + resp.Shards = shards[:] + return &resp, nil +} + +func (client *TableStoreClient) GetShardIterator(req *GetShardIteratorRequest) (*GetShardIteratorResponse, error) { + pbReq := &otsprotocol.GetShardIteratorRequest{ + StreamId: (*string)(req.StreamId), + ShardId: (*string)(req.ShardId)} + + if req.Timestamp != nil { + pbReq.Timestamp = req.Timestamp + } + + if req.Token != nil { + pbReq.Token = req.Token + } + + pbResp := otsprotocol.GetShardIteratorResponse{} + resp := GetShardIteratorResponse{} + if err := client.doRequestWithRetry(getShardIteratorUri, pbReq, &pbResp, &resp.ResponseInfo); err != nil { + return nil, err + } + + resp.ShardIterator = (*ShardIterator)(pbResp.ShardIterator) + resp.Token = pbResp.NextToken + return &resp, nil +} + +func (client TableStoreClient) GetStreamRecord(req *GetStreamRecordRequest) (*GetStreamRecordResponse, error) { + pbReq := &otsprotocol.GetStreamRecordRequest{ + ShardIterator: (*string)(req.ShardIterator)} + if req.Limit != nil { + pbReq.Limit = req.Limit + } + + pbResp := otsprotocol.GetStreamRecordResponse{} + resp := GetStreamRecordResponse{} + if err := client.doRequestWithRetry(getStreamRecordUri, pbReq, &pbResp, &resp.ResponseInfo); err != nil { + return nil, err + } + + if pbResp.NextShardIterator != nil { + resp.NextShardIterator = (*ShardIterator)(pbResp.NextShardIterator) + } + records := make([]*StreamRecord, len(pbResp.StreamRecords)) + for i, pbRecord := range pbResp.StreamRecords { + record := StreamRecord{} + records[i] = &record + + switch *pbRecord.ActionType { + case otsprotocol.ActionType_PUT_ROW: + record.Type = AT_Put + case otsprotocol.ActionType_UPDATE_ROW: + record.Type = AT_Update + case otsprotocol.ActionType_DELETE_ROW: + record.Type = AT_Delete + } + + plainRows, err := readRowsWithHeader(bytes.NewReader(pbRecord.Record)) + if err != nil { + return nil, err + } + Assert(len(plainRows) == 1, + "There must be exactly one row in a StreamRecord.") + plainRow := plainRows[0] + pkey := PrimaryKey{} + record.PrimaryKey = &pkey + pkey.PrimaryKeys = make([]*PrimaryKeyColumn, len(plainRow.primaryKey)) + for i, pk := range plainRow.primaryKey { + pkc := PrimaryKeyColumn{ + ColumnName: string(pk.cellName), + Value: pk.cellValue.Value} + pkey.PrimaryKeys[i] = &pkc + } + Assert(plainRow.extension != nil, + "extension in a stream record is required.") + record.Info = plainRow.extension + record.Columns = make([]*RecordColumn, len(plainRow.cells)) + for i, plainCell := range plainRow.cells { + cell := RecordColumn{} + record.Columns[i] = &cell + + name := string(plainCell.cellName) + cell.Name = &name + if plainCell.cellValue != nil { + cell.Type = RCT_Put + } else { + if plainCell.cellTimestamp > 0 { + cell.Type = RCT_DeleteOneVersion + } else { + cell.Type = RCT_DeleteAllVersions + } + } + switch cell.Type { + case RCT_Put: + cell.Value = plainCell.cellValue.Value + fallthrough + case RCT_DeleteOneVersion: + cell.Timestamp = &plainCell.cellTimestamp + case RCT_DeleteAllVersions: + break + } + } + } + resp.Records = records + return &resp, nil +} + +func (client TableStoreClient) ComputeSplitPointsBySize(req *ComputeSplitPointsBySizeRequest) (*ComputeSplitPointsBySizeResponse, error) { + pbReq := &otsprotocol.ComputeSplitPointsBySizeRequest{ + TableName: &(req.TableName), + SplitSize: &(req.SplitSize), + } + + pbResp := otsprotocol.ComputeSplitPointsBySizeResponse{} + resp := ComputeSplitPointsBySizeResponse{} + if err := client.doRequestWithRetry(computeSplitPointsBySizeRequestUri, pbReq, &pbResp, &resp.ResponseInfo); err != nil { + return nil, err + } + + fmt.Println(len(pbResp.SplitPoints)) + fmt.Println(len(pbResp.Locations)) + + beginPk := &PrimaryKey{} + endPk := &PrimaryKey{} + for _, pkSchema := range pbResp.Schema { + beginPk.AddPrimaryKeyColumnWithMinValue(*pkSchema.Name) + endPk.AddPrimaryKeyColumnWithMaxValue(*pkSchema.Name) + } + lastPk := beginPk + nowPk := endPk + + for _, pbRecord := range pbResp.SplitPoints { + plainRows, err := readRowsWithHeader(bytes.NewReader(pbRecord)) + if err != nil { + return nil, err + } + + nowPk = &PrimaryKey{} + for _, pk := range plainRows[0].primaryKey { + nowPk.AddPrimaryKeyColumn(string(pk.cellName), pk.cellValue.Value) + } + + if len(pbResp.Schema) > 1 { + for i := 1; i < len(pbResp.Schema); i++ { + nowPk.AddPrimaryKeyColumnWithMinValue(*pbResp.Schema[i].Name) + } + } + + newSplit := &Split{LowerBound: lastPk, UpperBound: nowPk} + resp.Splits = append(resp.Splits, newSplit) + lastPk = nowPk + + } + + newSplit := &Split{LowerBound: lastPk, UpperBound: endPk} + resp.Splits = append(resp.Splits, newSplit) + + index := 0 + for _, pbLocation := range pbResp.Locations { + count := *pbLocation.Repeat + value := *pbLocation.Location + + for i := int64(0); i < count; i++ { + resp.Splits[index].Location = value + index++ + } + } + return &resp, nil +} + +func (client *TableStoreClient) StartLocalTransaction(request *StartLocalTransactionRequest) (*StartLocalTransactionResponse, error) { + req := new(otsprotocol.StartLocalTransactionRequest) + resp := new(otsprotocol.StartLocalTransactionResponse) + + req.TableName = proto.String(request.TableName) + req.Key = request.PrimaryKey.Build(false) + + response := &StartLocalTransactionResponse{} + if err := client.doRequestWithRetry(createlocaltransactionuri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + + response.TransactionId = resp.TransactionId + return response, nil +} + +func (client *TableStoreClient) CommitTransaction(request *CommitTransactionRequest) (*CommitTransactionResponse, error) { + req := new(otsprotocol.CommitTransactionRequest) + resp := new(otsprotocol.CommitTransactionResponse) + + req.TransactionId = request.TransactionId + + response := &CommitTransactionResponse{} + if err := client.doRequestWithRetry(committransactionuri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + + return response, nil +} + +func (client *TableStoreClient) AbortTransaction(request *AbortTransactionRequest) (*AbortTransactionResponse, error) { + req := new(otsprotocol.AbortTransactionRequest) + resp := new(otsprotocol.AbortTransactionResponse) + + req.TransactionId = request.TransactionId + + response := &AbortTransactionResponse{} + if err := client.doRequestWithRetry(aborttransactionuri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + + return response, nil +} \ No newline at end of file diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/error.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/error.go new file mode 100644 index 000000000000..9a107b740a4e --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/error.go @@ -0,0 +1,52 @@ +package tablestore + +import ( + "errors" + "fmt" +) + +var ( + errMissMustHeader = func(header string) error { + return errors.New("[tablestore] miss must header: " + header) + } + errTableNameTooLong = func(name string) error { + return errors.New("[tablestore] table name: \"" + name + "\" too long") + } + + errInvalidPartitionType = errors.New("[tablestore] invalid partition key") + errMissPrimaryKey = errors.New("[tablestore] missing primary key") + errPrimaryKeyTooMuch = errors.New("[tablestore] primary key too much") + errMultiDeleteRowsTooMuch = errors.New("[tablestore] multi delete rows too much") + errCreateTableNoPrimaryKey = errors.New("[tablestore] create table no primary key") + errUnexpectIoEnd = errors.New("[tablestore] unexpect io end") + errTag = errors.New("[tablestore] unexpect tag") + errNoChecksum = errors.New("[tablestore] expect checksum") + errChecksum = errors.New("[tablestore] checksum failed") + errInvalidInput = errors.New("[tablestore] invalid input") +) + +const ( + OTS_CLIENT_UNKNOWN = "OTSClientUnknownError" + + ROW_OPERATION_CONFLICT = "OTSRowOperationConflict" + NOT_ENOUGH_CAPACITY_UNIT = "OTSNotEnoughCapacityUnit" + TABLE_NOT_READY = "OTSTableNotReady" + PARTITION_UNAVAILABLE = "OTSPartitionUnavailable" + SERVER_BUSY = "OTSServerBusy" + STORAGE_SERVER_BUSY = "OTSStorageServerBusy" + QUOTA_EXHAUSTED = "OTSQuotaExhausted" + + STORAGE_TIMEOUT = "OTSTimeout" + SERVER_UNAVAILABLE = "OTSServerUnavailable" + INTERNAL_SERVER_ERROR = "OTSInternalServerError" +) + +type OtsError struct { + Code string + Message string + RequestId string +} + +func (e *OtsError) Error() string { + return fmt.Sprintf("%s %s %s", e.Code, e.Message, e.RequestId) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/interface.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/interface.go new file mode 100644 index 000000000000..7e0e3b269a98 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/interface.go @@ -0,0 +1,22 @@ +package tablestore + +type TableStoreApi interface { + CreateTable(request *CreateTableRequest) (*CreateTableResponse, error) + ListTable() (*ListTableResponse, error) + DeleteTable(request *DeleteTableRequest) (*DeleteTableResponse, error) + DescribeTable(request *DescribeTableRequest) (*DescribeTableResponse, error) + UpdateTable(request *UpdateTableRequest) (*UpdateTableResponse, error) + PutRow(request *PutRowRequest) (*PutRowResponse, error) + DeleteRow(request *DeleteRowRequest) (*DeleteRowResponse, error) + GetRow(request *GetRowRequest) (*GetRowResponse, error) + UpdateRow(request *UpdateRowRequest) (*UpdateRowResponse, error) + BatchGetRow(request *BatchGetRowRequest) (*BatchGetRowResponse, error) + BatchWriteRow(request *BatchWriteRowRequest) (*BatchWriteRowResponse, error) + GetRange(request *GetRangeRequest) (*GetRangeResponse, error) + + // stream related + ListStream(request *ListStreamRequest) (*ListStreamResponse, error) + DescribeStream(request *DescribeStreamRequest) (*DescribeStreamResponse, error) + GetShardIterator(request *GetShardIteratorRequest) (*GetShardIteratorResponse, error) + GetStreamRecord(request *GetStreamRecordRequest) (*GetStreamRecordResponse, error) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/model.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/model.go new file mode 100644 index 000000000000..4f7cdc84ce79 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/model.go @@ -0,0 +1,855 @@ +package tablestore + +import ( + "fmt" + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" + "math/rand" + "net/http" + "strconv" + "strings" + "time" + //"github.com/aliyun/aliyun-tablestore-go-sdk/tablestore" +) + +// @class TableStoreClient +// The TableStoreClient, which will connect OTS service for authorization, create/list/ +// delete tables/table groups, to get/put/delete a row. +// Note: TableStoreClient is thread-safe. +// TableStoreClient的功能包括连接OTS服务进行验证、创建/列出/删除表或表组、插入/获取/ +// 删除/更新行数据 +type TableStoreClient struct { + endPoint string + instanceName string + accessKeyId string + accessKeySecret string + securityToken string + + httpClient IHttpClient + config *TableStoreConfig + random *rand.Rand +} + +type ClientOption func(*TableStoreClient) + +type TableStoreHttpClient struct { + httpClient *http.Client +} + +// use this to mock http.client for testing +type IHttpClient interface { + Do(*http.Request) (*http.Response, error) + New(*http.Client) +} + +func (httpClient *TableStoreHttpClient) Do(req *http.Request) (*http.Response, error) { + return httpClient.httpClient.Do(req) +} + +func (httpClient *TableStoreHttpClient) New(client *http.Client) { + httpClient.httpClient = client +} + +type HTTPTimeout struct { + ConnectionTimeout time.Duration + RequestTimeout time.Duration +} + +type TableStoreConfig struct { + RetryTimes uint + MaxRetryTime time.Duration + HTTPTimeout HTTPTimeout + MaxIdleConnections int +} + +func NewDefaultTableStoreConfig() *TableStoreConfig { + httpTimeout := &HTTPTimeout{ + ConnectionTimeout: time.Second * 15, + RequestTimeout: time.Second * 30} + config := &TableStoreConfig{ + RetryTimes: 10, + HTTPTimeout: *httpTimeout, + MaxRetryTime: time.Second * 5, + MaxIdleConnections: 2000} + return config +} + +type CreateTableRequest struct { + TableMeta *TableMeta + TableOption *TableOption + ReservedThroughput *ReservedThroughput + StreamSpec *StreamSpecification + IndexMetas []*IndexMeta +} + +type CreateIndexRequest struct { + MainTableName string + IndexMeta *IndexMeta + IncludeBaseData bool +} + +type DeleteIndexRequest struct { + MainTableName string + IndexName string +} + +type ResponseInfo struct { + RequestId string +} + +type CreateTableResponse struct { + ResponseInfo +} + +type CreateIndexResponse struct { + ResponseInfo +} + +type DeleteIndexResponse struct { + ResponseInfo +} + +type DeleteTableResponse struct { + ResponseInfo +} + +type TableMeta struct { + TableName string + SchemaEntry []*PrimaryKeySchema + DefinedColumns []*DefinedColumnSchema +} + +type PrimaryKeySchema struct { + Name *string + Type *PrimaryKeyType + Option *PrimaryKeyOption +} + +type PrimaryKey struct { + PrimaryKeys []*PrimaryKeyColumn +} + +type TableOption struct { + TimeToAlive, MaxVersion int +} + +type ReservedThroughput struct { + Readcap, Writecap int +} + +type ListTableResponse struct { + TableNames []string + ResponseInfo +} + +type DeleteTableRequest struct { + TableName string +} + +type DescribeTableRequest struct { + TableName string +} + +type DescribeTableResponse struct { + TableMeta *TableMeta + TableOption *TableOption + ReservedThroughput *ReservedThroughput + StreamDetails *StreamDetails + IndexMetas []*IndexMeta + ResponseInfo +} + +type UpdateTableRequest struct { + TableName string + TableOption *TableOption + ReservedThroughput *ReservedThroughput + StreamSpec *StreamSpecification +} + +type UpdateTableResponse struct { + TableOption *TableOption + ReservedThroughput *ReservedThroughput + StreamDetails *StreamDetails + ResponseInfo +} + +type ConsumedCapacityUnit struct { + Read int32 + Write int32 +} + +type PutRowResponse struct { + ConsumedCapacityUnit *ConsumedCapacityUnit + PrimaryKey PrimaryKey + ResponseInfo +} + +type DeleteRowResponse struct { + ConsumedCapacityUnit *ConsumedCapacityUnit + ResponseInfo +} + +type UpdateRowResponse struct { + Columns []*AttributeColumn + ConsumedCapacityUnit *ConsumedCapacityUnit + ResponseInfo +} + +type PrimaryKeyType int32 + +const ( + PrimaryKeyType_INTEGER PrimaryKeyType = 1 + PrimaryKeyType_STRING PrimaryKeyType = 2 + PrimaryKeyType_BINARY PrimaryKeyType = 3 +) + +const ( + DefaultRetryInterval = 10 + MaxRetryInterval = 320 +) + +type PrimaryKeyOption int32 + +const ( + NONE PrimaryKeyOption = 0 + AUTO_INCREMENT PrimaryKeyOption = 1 + MIN PrimaryKeyOption = 2 + MAX PrimaryKeyOption = 3 +) + +type PrimaryKeyColumn struct { + ColumnName string + Value interface{} + PrimaryKeyOption PrimaryKeyOption +} + +func (this *PrimaryKeyColumn) String() string { + xs := make([]string, 0) + xs = append(xs, fmt.Sprintf("\"Name\": \"%s\"", this.ColumnName)) + switch this.PrimaryKeyOption { + case NONE: + xs = append(xs, fmt.Sprintf("\"Value\": \"%s\"", this.Value)) + case MIN: + xs = append(xs, "\"Value\": -inf") + case MAX: + xs = append(xs, "\"Value\": +inf") + case AUTO_INCREMENT: + xs = append(xs, "\"Value\": auto-incr") + } + return fmt.Sprintf("{%s}", strings.Join(xs, ", ")) +} + +type AttributeColumn struct { + ColumnName string + Value interface{} + Timestamp int64 +} + +type TimeRange struct { + Start int64 + End int64 + Specific int64 +} + +type ColumnToUpdate struct { + ColumnName string + Type byte + Timestamp int64 + HasType bool + HasTimestamp bool + IgnoreValue bool + Value interface{} +} + +type RowExistenceExpectation int + +const ( + RowExistenceExpectation_IGNORE RowExistenceExpectation = 0 + RowExistenceExpectation_EXPECT_EXIST RowExistenceExpectation = 1 + RowExistenceExpectation_EXPECT_NOT_EXIST RowExistenceExpectation = 2 +) + +type ComparatorType int32 + +const ( + CT_EQUAL ComparatorType = 1 + CT_NOT_EQUAL ComparatorType = 2 + CT_GREATER_THAN ComparatorType = 3 + CT_GREATER_EQUAL ComparatorType = 4 + CT_LESS_THAN ComparatorType = 5 + CT_LESS_EQUAL ComparatorType = 6 +) + +type LogicalOperator int32 + +const ( + LO_NOT LogicalOperator = 1 + LO_AND LogicalOperator = 2 + LO_OR LogicalOperator = 3 +) + +type FilterType int32 + +const ( + FT_SINGLE_COLUMN_VALUE FilterType = 1 + FT_COMPOSITE_COLUMN_VALUE FilterType = 2 + FT_COLUMN_PAGINATION FilterType = 3 +) + +type ColumnFilter interface { + Serialize() []byte + ToFilter() *otsprotocol.Filter +} + +type VariantType int32 + +const ( + Variant_INTEGER VariantType = 0; + Variant_DOUBLE VariantType = 1; + //VT_BOOLEAN = 2; + Variant_STRING VariantType = 3; +) + +type ValueTransferRule struct { + Regex string + Cast_type VariantType +} + +type SingleColumnCondition struct { + Comparator *ComparatorType + ColumnName *string + ColumnValue interface{} //[]byte + FilterIfMissing bool + LatestVersionOnly bool + TransferRule *ValueTransferRule +} + +type ReturnType int32 + +const ( + ReturnType_RT_NONE ReturnType = 0 + ReturnType_RT_PK ReturnType = 1 + ReturnType_RT_AFTER_MODIFY ReturnType = 2 +) + +type PaginationFilter struct { + Offset int32 + Limit int32 +} + +type CompositeColumnValueFilter struct { + Operator LogicalOperator + Filters []ColumnFilter +} + +func (ccvfilter *CompositeColumnValueFilter) Serialize() []byte { + result, _ := proto.Marshal(ccvfilter.ToFilter()) + return result +} + +func (ccvfilter *CompositeColumnValueFilter) ToFilter() *otsprotocol.Filter { + compositefilter := NewCompositeFilter(ccvfilter.Filters, ccvfilter.Operator) + compositeFilterToBytes, _ := proto.Marshal(compositefilter) + filter := new(otsprotocol.Filter) + filter.Type = otsprotocol.FilterType_FT_COMPOSITE_COLUMN_VALUE.Enum() + filter.Filter = compositeFilterToBytes + return filter +} + +func (ccvfilter *CompositeColumnValueFilter) AddFilter(filter ColumnFilter) { + ccvfilter.Filters = append(ccvfilter.Filters, filter) +} + +func (condition *SingleColumnCondition) ToFilter() *otsprotocol.Filter { + singlefilter := NewSingleColumnValueFilter(condition) + singleFilterToBytes, _ := proto.Marshal(singlefilter) + filter := new(otsprotocol.Filter) + filter.Type = otsprotocol.FilterType_FT_SINGLE_COLUMN_VALUE.Enum() + filter.Filter = singleFilterToBytes + return filter +} + +func (condition *SingleColumnCondition) Serialize() []byte { + result, _ := proto.Marshal(condition.ToFilter()) + return result +} + +func (pageFilter *PaginationFilter) ToFilter() *otsprotocol.Filter { + compositefilter := NewPaginationFilter(pageFilter) + compositeFilterToBytes, _ := proto.Marshal(compositefilter) + filter := new(otsprotocol.Filter) + filter.Type = otsprotocol.FilterType_FT_COLUMN_PAGINATION.Enum() + filter.Filter = compositeFilterToBytes + return filter +} + +func (pageFilter *PaginationFilter) Serialize() []byte { + result, _ := proto.Marshal(pageFilter.ToFilter()) + return result +} + +func NewTableOptionWithMaxVersion(maxVersion int) *TableOption { + tableOption := new(TableOption) + tableOption.TimeToAlive = -1 + tableOption.MaxVersion = maxVersion + return tableOption +} + +func NewTableOption(timeToAlive int, maxVersion int) *TableOption { + tableOption := new(TableOption) + tableOption.TimeToAlive = timeToAlive + tableOption.MaxVersion = maxVersion + return tableOption +} + +type RowCondition struct { + RowExistenceExpectation RowExistenceExpectation + ColumnCondition ColumnFilter +} + +type PutRowChange struct { + TableName string + PrimaryKey *PrimaryKey + Columns []AttributeColumn + Condition *RowCondition + ReturnType ReturnType + TransactionId *string +} + +type PutRowRequest struct { + PutRowChange *PutRowChange +} + +type DeleteRowChange struct { + TableName string + PrimaryKey *PrimaryKey + Condition *RowCondition + TransactionId *string +} + +type DeleteRowRequest struct { + DeleteRowChange *DeleteRowChange +} + +type SingleRowQueryCriteria struct { + ColumnsToGet []string + TableName string + PrimaryKey *PrimaryKey + MaxVersion int32 + TimeRange *TimeRange + Filter ColumnFilter + StartColumn *string + EndColumn *string + TransactionId *string +} + +type UpdateRowChange struct { + TableName string + PrimaryKey *PrimaryKey + Columns []ColumnToUpdate + Condition *RowCondition + TransactionId *string + ReturnType ReturnType + ColumnNamesToReturn []string +} + +type UpdateRowRequest struct { + UpdateRowChange *UpdateRowChange +} + +func (rowQueryCriteria *SingleRowQueryCriteria) AddColumnToGet(columnName string) { + rowQueryCriteria.ColumnsToGet = append(rowQueryCriteria.ColumnsToGet, columnName) +} + +func (rowQueryCriteria *SingleRowQueryCriteria) SetStartColumn(columnName string) { + rowQueryCriteria.StartColumn = &columnName +} + +func (rowQueryCriteria *SingleRowQueryCriteria) SetEndtColumn(columnName string) { + rowQueryCriteria.EndColumn = &columnName +} + +func (rowQueryCriteria *SingleRowQueryCriteria) getColumnsToGet() []string { + return rowQueryCriteria.ColumnsToGet +} + +func (rowQueryCriteria *MultiRowQueryCriteria) AddColumnToGet(columnName string) { + rowQueryCriteria.ColumnsToGet = append(rowQueryCriteria.ColumnsToGet, columnName) +} + +func (rowQueryCriteria *RangeRowQueryCriteria) AddColumnToGet(columnName string) { + rowQueryCriteria.ColumnsToGet = append(rowQueryCriteria.ColumnsToGet, columnName) +} + +func (rowQueryCriteria *MultiRowQueryCriteria) AddRow(pk *PrimaryKey) { + rowQueryCriteria.PrimaryKey = append(rowQueryCriteria.PrimaryKey, pk) +} + +type GetRowRequest struct { + SingleRowQueryCriteria *SingleRowQueryCriteria +} + +type MultiRowQueryCriteria struct { + PrimaryKey []*PrimaryKey + ColumnsToGet []string + TableName string + MaxVersion int + TimeRange *TimeRange + Filter ColumnFilter + StartColumn *string + EndColumn *string +} + +type BatchGetRowRequest struct { + MultiRowQueryCriteria []*MultiRowQueryCriteria +} + +type ColumnMap struct { + Columns map[string][]*AttributeColumn + columnsKey []string +} + +type GetRowResponse struct { + PrimaryKey PrimaryKey + Columns []*AttributeColumn + ConsumedCapacityUnit *ConsumedCapacityUnit + columnMap *ColumnMap + ResponseInfo +} + +type Error struct { + Code string + Message string +} + +type RowResult struct { + TableName string + IsSucceed bool + Error Error + PrimaryKey PrimaryKey + Columns []*AttributeColumn + ConsumedCapacityUnit *ConsumedCapacityUnit + Index int32 +} + +type RowChange interface { + Serialize() []byte + getOperationType() otsprotocol.OperationType + getCondition() *otsprotocol.Condition + GetTableName() string +} + +type BatchGetRowResponse struct { + TableToRowsResult map[string][]RowResult + ResponseInfo +} + +type BatchWriteRowRequest struct { + RowChangesGroupByTable map[string][]RowChange +} + +type BatchWriteRowResponse struct { + TableToRowsResult map[string][]RowResult + ResponseInfo +} + +type Direction int32 + +const ( + FORWARD Direction = 0 + BACKWARD Direction = 1 +) + +type RangeRowQueryCriteria struct { + TableName string + StartPrimaryKey *PrimaryKey + EndPrimaryKey *PrimaryKey + ColumnsToGet []string + MaxVersion int32 + TimeRange *TimeRange + Filter ColumnFilter + Direction Direction + Limit int32 + StartColumn *string + EndColumn *string + TransactionId *string +} + +type GetRangeRequest struct { + RangeRowQueryCriteria *RangeRowQueryCriteria +} + +type Row struct { + PrimaryKey *PrimaryKey + Columns []*AttributeColumn +} + +type GetRangeResponse struct { + Rows []*Row + ConsumedCapacityUnit *ConsumedCapacityUnit + NextStartPrimaryKey *PrimaryKey + ResponseInfo +} + +type ListStreamRequest struct { + TableName *string +} + +type Stream struct { + Id *StreamId + TableName *string + CreationTime int64 +} + +type ListStreamResponse struct { + Streams []Stream + ResponseInfo +} + +type StreamSpecification struct { + EnableStream bool + ExpirationTime int32 // must be positive. in hours +} + +type StreamDetails struct { + EnableStream bool + StreamId *StreamId // nil when stream is disabled. + ExpirationTime int32 // in hours + LastEnableTime int64 // the last time stream is enabled, in usec +} + +type DescribeStreamRequest struct { + StreamId *StreamId // required + InclusiveStartShardId *ShardId // optional + ShardLimit *int32 // optional +} + +type DescribeStreamResponse struct { + StreamId *StreamId // required + ExpirationTime int32 // in hours + TableName *string // required + CreationTime int64 // in usec + Status StreamStatus // required + Shards []*StreamShard + NextShardId *ShardId // optional. nil means "no more shards" + ResponseInfo +} + +type GetShardIteratorRequest struct { + StreamId *StreamId // required + ShardId *ShardId // required + Timestamp *int64 + Token *string +} + +type GetShardIteratorResponse struct { + ShardIterator *ShardIterator // required + Token *string + ResponseInfo +} + +type GetStreamRecordRequest struct { + ShardIterator *ShardIterator // required + Limit *int32 // optional. max records which will reside in response +} + +type GetStreamRecordResponse struct { + Records []*StreamRecord + NextShardIterator *ShardIterator // optional. an indicator to be used to read more records in this shard + ResponseInfo +} + +type ComputeSplitPointsBySizeRequest struct { + TableName string + SplitSize int64 +} + +type ComputeSplitPointsBySizeResponse struct { + SchemaEntry []*PrimaryKeySchema + Splits []*Split + ResponseInfo +} + +type Split struct { + LowerBound *PrimaryKey + UpperBound *PrimaryKey + Location string +} + +type StreamId string +type ShardId string +type ShardIterator string +type StreamStatus int + +const ( + SS_Enabling StreamStatus = iota + SS_Active +) + +/* + * Shards are possibly splitted into two or merged from two. + * After splitting, both newly generated shards have the same FatherShard. + * After merging, the newly generated shard have both FatherShard and MotherShard. + */ +type StreamShard struct { + SelfShard *ShardId // required + FatherShard *ShardId // optional + MotherShard *ShardId // optional +} + +type StreamRecord struct { + Type ActionType + Info *RecordSequenceInfo // required + PrimaryKey *PrimaryKey // required + Columns []*RecordColumn +} + +func (this *StreamRecord) String() string { + return fmt.Sprintf( + "{\"Type\":%s, \"PrimaryKey\":%s, \"Info\":%s, \"Columns\":%s}", + this.Type, + *this.PrimaryKey, + this.Info, + this.Columns) +} + +type ActionType int + +const ( + AT_Put ActionType = iota + AT_Update + AT_Delete +) + +func (this ActionType) String() string { + switch this { + case AT_Put: + return "\"PutRow\"" + case AT_Update: + return "\"UpdateRow\"" + case AT_Delete: + return "\"DeleteRow\"" + default: + panic(fmt.Sprintf("unknown action type: %d", int(this))) + } +} + +type RecordSequenceInfo struct { + Epoch int32 + Timestamp int64 + RowIndex int32 +} + +func (this *RecordSequenceInfo) String() string { + return fmt.Sprintf( + "{\"Epoch\":%d, \"Timestamp\": %d, \"RowIndex\": %d}", + this.Epoch, + this.Timestamp, + this.RowIndex) +} + +type RecordColumn struct { + Type RecordColumnType + Name *string // required + Value interface{} // optional. present when Type is RCT_Put + Timestamp *int64 // optional, in msec. present when Type is RCT_Put or RCT_DeleteOneVersion +} + +func (this *RecordColumn) String() string { + xs := make([]string, 0) + xs = append(xs, fmt.Sprintf("\"Name\":%s", strconv.Quote(*this.Name))) + switch this.Type { + case RCT_DeleteAllVersions: + xs = append(xs, "\"Type\":\"DeleteAllVersions\"") + case RCT_DeleteOneVersion: + xs = append(xs, "\"Type\":\"DeleteOneVersion\"") + xs = append(xs, fmt.Sprintf("\"Timestamp\":%d", *this.Timestamp)) + case RCT_Put: + xs = append(xs, "\"Type\":\"Put\"") + xs = append(xs, fmt.Sprintf("\"Timestamp\":%d", *this.Timestamp)) + xs = append(xs, fmt.Sprintf("\"Value\":%s", this.Value)) + } + return fmt.Sprintf("{%s}", strings.Join(xs, ", ")) +} + +type RecordColumnType int + +const ( + RCT_Put RecordColumnType = iota + RCT_DeleteOneVersion + RCT_DeleteAllVersions +) + +type IndexMeta struct { + IndexName string + Primarykey []string + DefinedColumns []string + IndexType IndexType +} + +type DefinedColumnSchema struct { + Name string + ColumnType DefinedColumnType +} + +type IndexType int32 + +const ( + IT_GLOBAL_INDEX IndexType = 1 + IT_LOCAL_INDEX IndexType = 2 +) + +type DefinedColumnType int32 + +const ( + /** + * 64位整数。 + */ + DefinedColumn_INTEGER DefinedColumnType = 1 + + /** + * 浮点数。 + */ + DefinedColumn_DOUBLE DefinedColumnType = 2 + + /** + * 布尔值。 + */ + DefinedColumn_BOOLEAN DefinedColumnType = 3 + + /** + * 字符串。 + */ + DefinedColumn_STRING DefinedColumnType = 4 + + /** + * BINARY。 + */ + DefinedColumn_BINARY DefinedColumnType = 5 +) + +type StartLocalTransactionRequest struct { + PrimaryKey *PrimaryKey + TableName string +} + +type StartLocalTransactionResponse struct { + TransactionId *string + ResponseInfo +} + +type CommitTransactionRequest struct { + TransactionId *string +} + +type CommitTransactionResponse struct { + ResponseInfo +} + +type AbortTransactionRequest struct { + TransactionId *string +} + +type AbortTransactionResponse struct { + ResponseInfo +} \ No newline at end of file diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/ots_header.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/ots_header.go new file mode 100644 index 000000000000..bff7d021f500 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/ots_header.go @@ -0,0 +1,124 @@ +package tablestore + +import ( + "crypto/hmac" + "crypto/sha1" + "encoding/base64" + "hash" + "sort" + "strings" +) + +const ( + xOtsDate = "x-ots-date" + xOtsApiversion = "x-ots-apiversion" + xOtsAccesskeyid = "x-ots-accesskeyid" + xOtsContentmd5 = "x-ots-contentmd5" + xOtsHeaderStsToken = "x-ots-ststoken" + xOtsSignature = "x-ots-signature" + xOtsRequestCompressType = "x-ots-request-compress-type" + xOtsRequestCompressSize = "x-ots-request-compress-size" + xOtsResponseCompressTye = "x-ots-response-compress-type" +) + +type otsHeader struct { + name string + value string + must bool +} + +type otsHeaders struct { + headers []*otsHeader + hmacSha1 hash.Hash +} + +func createOtsHeaders(accessKey string) *otsHeaders { + h := new(otsHeaders) + + h.headers = []*otsHeader{ + &otsHeader{name: xOtsDate, must: true}, + &otsHeader{name: xOtsApiversion, must: true}, + &otsHeader{name: xOtsAccesskeyid, must: true}, + &otsHeader{name: xOtsContentmd5, must: true}, + &otsHeader{name: xOtsInstanceName, must: true}, + &otsHeader{name: xOtsSignature, must: true}, + &otsHeader{name: xOtsRequestCompressSize, must: false}, + &otsHeader{name: xOtsResponseCompressTye, must: false}, + &otsHeader{name: xOtsRequestCompressType, must: false}, + &otsHeader{name: xOtsHeaderStsToken, must: false}, + } + + sort.Sort(h) + + h.hmacSha1 = hmac.New(sha1.New, []byte(accessKey)) + return h +} + +func (h *otsHeaders) Len() int { + return len(h.headers) +} + +func (h *otsHeaders) Swap(i, j int) { + h.headers[i], h.headers[j] = h.headers[j], h.headers[i] +} + +func (h *otsHeaders) Less(i, j int) bool { + if h.headers[i].name == xOtsSignature { + return false + } + + if h.headers[j].name == xOtsSignature { + return true + } + + return h.headers[i].name < h.headers[j].name +} + +func (h *otsHeaders) search(name string) *otsHeader { + index := sort.Search(len(h.headers)-1, func(i int) bool { + return h.headers[i].name >= name + }) + + if index >= len(h.headers) { + return nil + } + + return h.headers[index] +} + +func (h *otsHeaders) set(name, value string) { + header := h.search(name) + if header == nil { + return + } + + header.value = value +} + +func (h *otsHeaders) signature(uri, method, accessKey string) (string, error) { + for _, header := range h.headers[:len(h.headers)-1] { + if header.must && header.value == "" { + return "", errMissMustHeader(header.name) + } + } + + // StringToSign = CanonicalURI + '\n' + HTTPRequestMethod + '\n' + CanonicalQueryString + '\n' + CanonicalHeaders + '\n' + // TODO CanonicalQueryString 为空 + stringToSign := uri + "\n" + method + "\n" + "\n" + + // 最后一个header 为 xOtsSignature + for _, header := range h.headers[:len(h.headers)-1] { + if header.value != "" { + stringToSign = stringToSign + header.name + ":" + strings.TrimSpace(header.value) + "\n" + } + } + + h.hmacSha1.Reset() + h.hmacSha1.Write([]byte(stringToSign)) + + // fmt.Println("stringToSign:" + stringToSign) + sign := base64.StdEncoding.EncodeToString(h.hmacSha1.Sum(nil)) + h.set(xOtsSignature, sign) + // fmt.Println("sign:" + sign) + return sign, nil +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/build_proto.sh b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/build_proto.sh new file mode 100644 index 000000000000..18cb5079e8be --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/build_proto.sh @@ -0,0 +1 @@ +protoc --go_out=. search.proto ots_filter.proto table_store.proto diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/ots_filter.pb.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/ots_filter.pb.go new file mode 100644 index 000000000000..4172901ccb6a --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/ots_filter.pb.go @@ -0,0 +1,390 @@ +// Code generated by protoc-gen-go. +// source: ots_filter.proto +// DO NOT EDIT! + +package otsprotocol + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type VariantType int32 + +const ( + VariantType_VT_INTEGER VariantType = 0 + VariantType_VT_DOUBLE VariantType = 1 + // VT_BOOLEAN = 2; + VariantType_VT_STRING VariantType = 3 + VariantType_VT_NULL VariantType = 6 + VariantType_VT_BLOB VariantType = 7 +) + +var VariantType_name = map[int32]string{ + 0: "VT_INTEGER", + 1: "VT_DOUBLE", + 3: "VT_STRING", + 6: "VT_NULL", + 7: "VT_BLOB", +} +var VariantType_value = map[string]int32{ + "VT_INTEGER": 0, + "VT_DOUBLE": 1, + "VT_STRING": 3, + "VT_NULL": 6, + "VT_BLOB": 7, +} + +func (x VariantType) Enum() *VariantType { + p := new(VariantType) + *p = x + return p +} +func (x VariantType) String() string { + return proto.EnumName(VariantType_name, int32(x)) +} +func (x *VariantType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(VariantType_value, data, "VariantType") + if err != nil { + return err + } + *x = VariantType(value) + return nil +} +func (VariantType) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{0} } + +type FilterType int32 + +const ( + FilterType_FT_SINGLE_COLUMN_VALUE FilterType = 1 + FilterType_FT_COMPOSITE_COLUMN_VALUE FilterType = 2 + FilterType_FT_COLUMN_PAGINATION FilterType = 3 +) + +var FilterType_name = map[int32]string{ + 1: "FT_SINGLE_COLUMN_VALUE", + 2: "FT_COMPOSITE_COLUMN_VALUE", + 3: "FT_COLUMN_PAGINATION", +} +var FilterType_value = map[string]int32{ + "FT_SINGLE_COLUMN_VALUE": 1, + "FT_COMPOSITE_COLUMN_VALUE": 2, + "FT_COLUMN_PAGINATION": 3, +} + +func (x FilterType) Enum() *FilterType { + p := new(FilterType) + *p = x + return p +} +func (x FilterType) String() string { + return proto.EnumName(FilterType_name, int32(x)) +} +func (x *FilterType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FilterType_value, data, "FilterType") + if err != nil { + return err + } + *x = FilterType(value) + return nil +} +func (FilterType) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{1} } + +type ComparatorType int32 + +const ( + ComparatorType_CT_EQUAL ComparatorType = 1 + ComparatorType_CT_NOT_EQUAL ComparatorType = 2 + ComparatorType_CT_GREATER_THAN ComparatorType = 3 + ComparatorType_CT_GREATER_EQUAL ComparatorType = 4 + ComparatorType_CT_LESS_THAN ComparatorType = 5 + ComparatorType_CT_LESS_EQUAL ComparatorType = 6 +) + +var ComparatorType_name = map[int32]string{ + 1: "CT_EQUAL", + 2: "CT_NOT_EQUAL", + 3: "CT_GREATER_THAN", + 4: "CT_GREATER_EQUAL", + 5: "CT_LESS_THAN", + 6: "CT_LESS_EQUAL", +} +var ComparatorType_value = map[string]int32{ + "CT_EQUAL": 1, + "CT_NOT_EQUAL": 2, + "CT_GREATER_THAN": 3, + "CT_GREATER_EQUAL": 4, + "CT_LESS_THAN": 5, + "CT_LESS_EQUAL": 6, +} + +func (x ComparatorType) Enum() *ComparatorType { + p := new(ComparatorType) + *p = x + return p +} +func (x ComparatorType) String() string { + return proto.EnumName(ComparatorType_name, int32(x)) +} +func (x *ComparatorType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ComparatorType_value, data, "ComparatorType") + if err != nil { + return err + } + *x = ComparatorType(value) + return nil +} +func (ComparatorType) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{2} } + +type LogicalOperator int32 + +const ( + LogicalOperator_LO_NOT LogicalOperator = 1 + LogicalOperator_LO_AND LogicalOperator = 2 + LogicalOperator_LO_OR LogicalOperator = 3 +) + +var LogicalOperator_name = map[int32]string{ + 1: "LO_NOT", + 2: "LO_AND", + 3: "LO_OR", +} +var LogicalOperator_value = map[string]int32{ + "LO_NOT": 1, + "LO_AND": 2, + "LO_OR": 3, +} + +func (x LogicalOperator) Enum() *LogicalOperator { + p := new(LogicalOperator) + *p = x + return p +} +func (x LogicalOperator) String() string { + return proto.EnumName(LogicalOperator_name, int32(x)) +} +func (x *LogicalOperator) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(LogicalOperator_value, data, "LogicalOperator") + if err != nil { + return err + } + *x = LogicalOperator(value) + return nil +} +func (LogicalOperator) EnumDescriptor() ([]byte, []int) { return fileDescriptor1, []int{3} } + +type ValueTransferRule struct { + Regex *string `protobuf:"bytes,1,req,name=regex" json:"regex,omitempty"` + CastType *VariantType `protobuf:"varint,2,opt,name=cast_type,enum=otsprotocol.VariantType" json:"cast_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ValueTransferRule) Reset() { *m = ValueTransferRule{} } +func (m *ValueTransferRule) String() string { return proto.CompactTextString(m) } +func (*ValueTransferRule) ProtoMessage() {} +func (*ValueTransferRule) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{0} } + +func (m *ValueTransferRule) GetRegex() string { + if m != nil && m.Regex != nil { + return *m.Regex + } + return "" +} + +func (m *ValueTransferRule) GetCastType() VariantType { + if m != nil && m.CastType != nil { + return *m.CastType + } + return VariantType_VT_INTEGER +} + +type SingleColumnValueFilter struct { + Comparator *ComparatorType `protobuf:"varint,1,req,name=comparator,enum=otsprotocol.ComparatorType" json:"comparator,omitempty"` + ColumnName *string `protobuf:"bytes,2,req,name=column_name" json:"column_name,omitempty"` + ColumnValue []byte `protobuf:"bytes,3,req,name=column_value" json:"column_value,omitempty"` + FilterIfMissing *bool `protobuf:"varint,4,req,name=filter_if_missing" json:"filter_if_missing,omitempty"` + LatestVersionOnly *bool `protobuf:"varint,5,req,name=latest_version_only" json:"latest_version_only,omitempty"` + ValueTransRule *ValueTransferRule `protobuf:"bytes,6,opt,name=value_trans_rule" json:"value_trans_rule,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SingleColumnValueFilter) Reset() { *m = SingleColumnValueFilter{} } +func (m *SingleColumnValueFilter) String() string { return proto.CompactTextString(m) } +func (*SingleColumnValueFilter) ProtoMessage() {} +func (*SingleColumnValueFilter) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{1} } + +func (m *SingleColumnValueFilter) GetComparator() ComparatorType { + if m != nil && m.Comparator != nil { + return *m.Comparator + } + return ComparatorType_CT_EQUAL +} + +func (m *SingleColumnValueFilter) GetColumnName() string { + if m != nil && m.ColumnName != nil { + return *m.ColumnName + } + return "" +} + +func (m *SingleColumnValueFilter) GetColumnValue() []byte { + if m != nil { + return m.ColumnValue + } + return nil +} + +func (m *SingleColumnValueFilter) GetFilterIfMissing() bool { + if m != nil && m.FilterIfMissing != nil { + return *m.FilterIfMissing + } + return false +} + +func (m *SingleColumnValueFilter) GetLatestVersionOnly() bool { + if m != nil && m.LatestVersionOnly != nil { + return *m.LatestVersionOnly + } + return false +} + +func (m *SingleColumnValueFilter) GetValueTransRule() *ValueTransferRule { + if m != nil { + return m.ValueTransRule + } + return nil +} + +type CompositeColumnValueFilter struct { + Combinator *LogicalOperator `protobuf:"varint,1,req,name=combinator,enum=otsprotocol.LogicalOperator" json:"combinator,omitempty"` + SubFilters []*Filter `protobuf:"bytes,2,rep,name=sub_filters" json:"sub_filters,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CompositeColumnValueFilter) Reset() { *m = CompositeColumnValueFilter{} } +func (m *CompositeColumnValueFilter) String() string { return proto.CompactTextString(m) } +func (*CompositeColumnValueFilter) ProtoMessage() {} +func (*CompositeColumnValueFilter) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{2} } + +func (m *CompositeColumnValueFilter) GetCombinator() LogicalOperator { + if m != nil && m.Combinator != nil { + return *m.Combinator + } + return LogicalOperator_LO_NOT +} + +func (m *CompositeColumnValueFilter) GetSubFilters() []*Filter { + if m != nil { + return m.SubFilters + } + return nil +} + +type ColumnPaginationFilter struct { + Offset *int32 `protobuf:"varint,1,req,name=offset" json:"offset,omitempty"` + Limit *int32 `protobuf:"varint,2,req,name=limit" json:"limit,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ColumnPaginationFilter) Reset() { *m = ColumnPaginationFilter{} } +func (m *ColumnPaginationFilter) String() string { return proto.CompactTextString(m) } +func (*ColumnPaginationFilter) ProtoMessage() {} +func (*ColumnPaginationFilter) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{3} } + +func (m *ColumnPaginationFilter) GetOffset() int32 { + if m != nil && m.Offset != nil { + return *m.Offset + } + return 0 +} + +func (m *ColumnPaginationFilter) GetLimit() int32 { + if m != nil && m.Limit != nil { + return *m.Limit + } + return 0 +} + +type Filter struct { + Type *FilterType `protobuf:"varint,1,req,name=type,enum=otsprotocol.FilterType" json:"type,omitempty"` + Filter []byte `protobuf:"bytes,2,req,name=filter" json:"filter,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Filter) Reset() { *m = Filter{} } +func (m *Filter) String() string { return proto.CompactTextString(m) } +func (*Filter) ProtoMessage() {} +func (*Filter) Descriptor() ([]byte, []int) { return fileDescriptor1, []int{4} } + +func (m *Filter) GetType() FilterType { + if m != nil && m.Type != nil { + return *m.Type + } + return FilterType_FT_SINGLE_COLUMN_VALUE +} + +func (m *Filter) GetFilter() []byte { + if m != nil { + return m.Filter + } + return nil +} + +func init() { + proto.RegisterType((*ValueTransferRule)(nil), "otsprotocol.ValueTransferRule") + proto.RegisterType((*SingleColumnValueFilter)(nil), "otsprotocol.SingleColumnValueFilter") + proto.RegisterType((*CompositeColumnValueFilter)(nil), "otsprotocol.CompositeColumnValueFilter") + proto.RegisterType((*ColumnPaginationFilter)(nil), "otsprotocol.ColumnPaginationFilter") + proto.RegisterType((*Filter)(nil), "otsprotocol.Filter") + proto.RegisterEnum("otsprotocol.VariantType", VariantType_name, VariantType_value) + proto.RegisterEnum("otsprotocol.FilterType", FilterType_name, FilterType_value) + proto.RegisterEnum("otsprotocol.ComparatorType", ComparatorType_name, ComparatorType_value) + proto.RegisterEnum("otsprotocol.LogicalOperator", LogicalOperator_name, LogicalOperator_value) +} + +func init() { proto.RegisterFile("ots_filter.proto", fileDescriptor1) } + +var fileDescriptor1 = []byte{ + // 585 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0x6c, 0x92, 0x51, 0x6b, 0xdb, 0x30, + 0x14, 0x85, 0x67, 0xa7, 0x71, 0x9b, 0xeb, 0x34, 0x55, 0x95, 0xd2, 0xba, 0xed, 0x36, 0x42, 0x60, + 0x60, 0x32, 0xe8, 0x46, 0x18, 0x6c, 0x6f, 0xc3, 0x75, 0xdd, 0x2c, 0xe0, 0xda, 0x5d, 0xa2, 0xf8, + 0x55, 0xb8, 0x41, 0x09, 0x02, 0xc7, 0x0a, 0x96, 0x52, 0xda, 0xb7, 0xfd, 0xdb, 0xfd, 0x8d, 0x61, + 0xd9, 0x1d, 0x69, 0xe8, 0x9b, 0x75, 0xef, 0xd5, 0x77, 0xee, 0xd1, 0x31, 0x20, 0xa1, 0x24, 0x5d, + 0xf0, 0x4c, 0xb1, 0xe2, 0x6a, 0x5d, 0x08, 0x25, 0xb0, 0x2d, 0x94, 0xd4, 0x5f, 0x73, 0x91, 0xf5, + 0x63, 0x38, 0x4e, 0xd2, 0x6c, 0xc3, 0x48, 0x91, 0xe6, 0x72, 0xc1, 0x8a, 0xc9, 0x26, 0x63, 0xf8, + 0x10, 0x9a, 0x05, 0x5b, 0xb2, 0x27, 0xc7, 0xe8, 0x99, 0x6e, 0x0b, 0x7f, 0x86, 0xd6, 0x3c, 0x95, + 0x8a, 0xaa, 0xe7, 0x35, 0x73, 0xcc, 0x9e, 0xe1, 0x76, 0x86, 0xce, 0xd5, 0x16, 0xe4, 0x2a, 0x49, + 0x0b, 0x9e, 0xe6, 0x8a, 0x3c, 0xaf, 0x59, 0xff, 0xaf, 0x01, 0x67, 0x53, 0x9e, 0x2f, 0x33, 0xe6, + 0x8b, 0x6c, 0xb3, 0xca, 0x35, 0xfd, 0x56, 0xeb, 0xe3, 0x2f, 0x00, 0x73, 0xb1, 0x5a, 0xa7, 0x45, + 0xaa, 0x44, 0xa1, 0xe1, 0x9d, 0xe1, 0xe5, 0x2b, 0x92, 0xff, 0xbf, 0x5d, 0xc2, 0x70, 0x17, 0xec, + 0xb9, 0xa6, 0xd0, 0x3c, 0x5d, 0x95, 0xda, 0xe5, 0x3a, 0x27, 0xd0, 0xae, 0x8b, 0x8f, 0x25, 0xdb, + 0x69, 0xf4, 0x4c, 0xb7, 0x8d, 0xcf, 0xe1, 0xb8, 0x72, 0x49, 0xf9, 0x82, 0xae, 0xb8, 0x94, 0x3c, + 0x5f, 0x3a, 0x7b, 0x3d, 0xd3, 0x3d, 0xc0, 0x97, 0xd0, 0xcd, 0x52, 0xc5, 0xa4, 0xa2, 0x8f, 0xac, + 0x90, 0x5c, 0xe4, 0x54, 0xe4, 0xd9, 0xb3, 0xd3, 0xd4, 0xcd, 0x1f, 0x80, 0x34, 0x86, 0xaa, 0xf2, + 0x05, 0x68, 0xb1, 0xc9, 0x98, 0x63, 0xf5, 0x0c, 0xd7, 0x1e, 0x7e, 0xdc, 0xf1, 0xb8, 0xf3, 0x4a, + 0xfd, 0x27, 0xb8, 0x28, 0xd7, 0x15, 0x92, 0xab, 0x37, 0xbc, 0x7e, 0xd5, 0x5e, 0x1f, 0x78, 0xbe, + 0xe5, 0xf5, 0xfd, 0x2b, 0x62, 0x28, 0x96, 0x7c, 0x9e, 0x66, 0xf1, 0x9a, 0x69, 0xc3, 0xd8, 0x05, + 0x5b, 0x6e, 0x1e, 0xea, 0xac, 0xa4, 0x63, 0xf6, 0x1a, 0xae, 0x3d, 0xec, 0xbe, 0xba, 0x52, 0xb1, + 0xfb, 0xdf, 0xe1, 0xb4, 0x12, 0xbc, 0x4f, 0x97, 0xa5, 0x00, 0x17, 0x79, 0xad, 0xda, 0x01, 0x4b, + 0x2c, 0x16, 0x92, 0x29, 0xad, 0xd8, 0x2c, 0x93, 0xcc, 0xf8, 0x8a, 0x2b, 0xfd, 0x74, 0xcd, 0xfe, + 0x4f, 0xb0, 0xea, 0xc1, 0x4f, 0xb0, 0xa7, 0xe3, 0xac, 0x16, 0x3b, 0x7b, 0x43, 0x45, 0x07, 0xd0, + 0x01, 0xab, 0xda, 0x47, 0x03, 0xda, 0x83, 0x19, 0xd8, 0x5b, 0x61, 0xe3, 0x0e, 0x40, 0x42, 0xe8, + 0x38, 0x22, 0xc1, 0x28, 0x98, 0xa0, 0x77, 0xf8, 0x10, 0x5a, 0x09, 0xa1, 0x37, 0xf1, 0xec, 0x3a, + 0x0c, 0x90, 0x51, 0x1f, 0xa7, 0x64, 0x32, 0x8e, 0x46, 0xa8, 0x81, 0x6d, 0xd8, 0x4f, 0x08, 0x8d, + 0x66, 0x61, 0x88, 0xac, 0xfa, 0x70, 0x1d, 0xc6, 0xd7, 0x68, 0x7f, 0x90, 0x02, 0x6c, 0x89, 0x5e, + 0xc0, 0xe9, 0x2d, 0xa1, 0xd3, 0x71, 0x34, 0x0a, 0x03, 0xea, 0xc7, 0xe1, 0xec, 0x2e, 0xa2, 0x89, + 0x17, 0xce, 0x4a, 0xe4, 0x07, 0x38, 0xbf, 0x25, 0xd4, 0x8f, 0xef, 0xee, 0xe3, 0xe9, 0x98, 0xec, + 0xb4, 0x4d, 0xec, 0xc0, 0x89, 0x6e, 0xeb, 0xe2, 0xbd, 0x37, 0x1a, 0x47, 0x1e, 0x19, 0xc7, 0x11, + 0x6a, 0x0c, 0xfe, 0x18, 0xd0, 0xd9, 0xf9, 0xbb, 0xda, 0x70, 0xe0, 0x13, 0x1a, 0xfc, 0x9e, 0x79, + 0x21, 0x32, 0x30, 0x82, 0xb6, 0x4f, 0x68, 0x14, 0xbf, 0x54, 0x4c, 0xdc, 0x85, 0x23, 0x9f, 0xd0, + 0xd1, 0x24, 0xf0, 0x48, 0x30, 0xa1, 0xe4, 0x97, 0x17, 0xa1, 0x06, 0x3e, 0x01, 0xb4, 0x55, 0xac, + 0x46, 0xf7, 0xea, 0xcb, 0x61, 0x30, 0x9d, 0x56, 0x73, 0x4d, 0x7c, 0x0c, 0x87, 0x2f, 0x95, 0x6a, + 0xc8, 0x1a, 0x7c, 0x83, 0xa3, 0xdd, 0xcc, 0x01, 0xac, 0x30, 0x2e, 0x45, 0x91, 0x51, 0x7f, 0x7b, + 0xd1, 0x0d, 0x32, 0x71, 0x0b, 0x9a, 0x61, 0x4c, 0xe3, 0x09, 0x6a, 0xfc, 0x0b, 0x00, 0x00, 0xff, + 0xff, 0xb3, 0x10, 0x19, 0xa7, 0xc1, 0x03, 0x00, 0x00, +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/ots_filter.proto b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/ots_filter.proto new file mode 100644 index 000000000000..172d6b47a1b9 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/ots_filter.proto @@ -0,0 +1,61 @@ +syntax = "proto2"; +package otsprotocol; + +enum VariantType { + VT_INTEGER = 0; + VT_DOUBLE = 1; + //VT_BOOLEAN = 2; + VT_STRING = 3; + VT_NULL = 6; + VT_BLOB = 7; +} + +message ValueTransferRule { + required string regex = 1; + optional VariantType cast_type = 2; +} + +enum FilterType { + FT_SINGLE_COLUMN_VALUE = 1; + FT_COMPOSITE_COLUMN_VALUE = 2; + FT_COLUMN_PAGINATION = 3; +} + +enum ComparatorType { + CT_EQUAL = 1; + CT_NOT_EQUAL = 2; + CT_GREATER_THAN = 3; + CT_GREATER_EQUAL = 4; + CT_LESS_THAN = 5; + CT_LESS_EQUAL = 6; +} + +message SingleColumnValueFilter { + required ComparatorType comparator = 1; + required string column_name = 2; + required bytes column_value = 3; // Serialized SQLVariant + required bool filter_if_missing = 4; + required bool latest_version_only = 5; + optional ValueTransferRule value_trans_rule = 6; +} + +enum LogicalOperator { + LO_NOT = 1; + LO_AND = 2; + LO_OR = 3; +} + +message CompositeColumnValueFilter { + required LogicalOperator combinator = 1; + repeated Filter sub_filters = 2; +} + +message ColumnPaginationFilter { + required int32 offset = 1; + required int32 limit = 2; +} + +message Filter { + required FilterType type = 1; + required bytes filter = 2; // Serialized string of filter of the type +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/search.pb.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/search.pb.go new file mode 100644 index 000000000000..2f327b1e0356 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/search.pb.go @@ -0,0 +1,1997 @@ +// Code generated by protoc-gen-go. +// source: search.proto +// DO NOT EDIT! + +/* +Package otsprotocol is a generated protocol buffer package. + +It is generated from these files: + search.proto + ots_filter.proto + table_store.proto + +It has these top-level messages: + MatchQuery + MatchPhraseQuery + MatchAllQuery + TermQuery + TermsQuery + RangeQuery + PrefixQuery + WildcardQuery + BoolQuery + ConstScoreQuery + FieldValueFactor + FunctionScoreQuery + NestedQuery + GeoBoundingBoxQuery + GeoDistanceQuery + GeoPolygonQuery + Query + Collapse + NestedFilter + ScoreSort + FieldSort + GeoDistanceSort + PrimaryKeySort + Sorter + Sort + SearchQuery + ColumnsToGet + SearchRequest + SearchResponse + FieldSchema + IndexSchema + IndexSetting + CreateSearchIndexRequest + CreateSearchIndexResponse + IndexInfo + ListSearchIndexRequest + ListSearchIndexResponse + DeleteSearchIndexRequest + DeleteSearchIndexResponse + SyncStat + DescribeSearchIndexRequest + DescribeSearchIndexResponse + ValueTransferRule + SingleColumnValueFilter + CompositeColumnValueFilter + ColumnPaginationFilter + Filter + Error + PrimaryKeySchema + PartitionRange + TableOptions + TableMeta + Condition + CapacityUnit + ReservedThroughputDetails + ReservedThroughput + ConsumedCapacity + StreamSpecification + StreamDetails + CreateTableRequest + CreateTableResponse + UpdateTableRequest + UpdateTableResponse + DescribeTableRequest + DescribeTableResponse + ListTableRequest + ListTableResponse + DeleteTableRequest + DeleteTableResponse + LoadTableRequest + LoadTableResponse + UnloadTableRequest + UnloadTableResponse + TimeRange + ReturnContent + GetRowRequest + GetRowResponse + UpdateRowRequest + UpdateRowResponse + PutRowRequest + PutRowResponse + DeleteRowRequest + DeleteRowResponse + TableInBatchGetRowRequest + BatchGetRowRequest + RowInBatchGetRowResponse + TableInBatchGetRowResponse + BatchGetRowResponse + RowInBatchWriteRowRequest + TableInBatchWriteRowRequest + BatchWriteRowRequest + RowInBatchWriteRowResponse + TableInBatchWriteRowResponse + BatchWriteRowResponse + GetRangeRequest + GetRangeResponse + ListStreamRequest + Stream + ListStreamResponse + StreamShard + DescribeStreamRequest + DescribeStreamResponse + GetShardIteratorRequest + GetShardIteratorResponse + GetStreamRecordRequest + GetStreamRecordResponse + ComputeSplitPointsBySizeRequest + ComputeSplitPointsBySizeResponse + DefinedColumnSchema + IndexMeta + CreateIndexRequest + CreateIndexResponse + DropIndexRequest + DropIndexResponse + StartLocalTransactionRequest + StartLocalTransactionResponse + CommitTransactionRequest + CommitTransactionResponse + AbortTransactionRequest + AbortTransactionResponse +*/ +package otsprotocol + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +// This is a compile-time assertion to ensure that this generated file +// is compatible with the proto package it is being compiled against. +// A compilation error at this line likely means your copy of the +// proto package needs to be updated. +const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package + +type QueryType int32 + +const ( + QueryType_MATCH_QUERY QueryType = 1 + QueryType_MATCH_PHRASE_QUERY QueryType = 2 + QueryType_TERM_QUERY QueryType = 3 + QueryType_RANGE_QUERY QueryType = 4 + QueryType_PREFIX_QUERY QueryType = 5 + QueryType_BOOL_QUERY QueryType = 6 + QueryType_CONST_SCORE_QUERY QueryType = 7 + QueryType_FUNCTION_SCORE_QUERY QueryType = 8 + QueryType_NESTED_QUERY QueryType = 9 + QueryType_WILDCARD_QUERY QueryType = 10 + QueryType_MATCH_ALL_QUERY QueryType = 11 + QueryType_GEO_BOUNDING_BOX_QUERY QueryType = 12 + QueryType_GEO_DISTANCE_QUERY QueryType = 13 + QueryType_GEO_POLYGON_QUERY QueryType = 14 + QueryType_TERMS_QUERY QueryType = 15 +) + +var QueryType_name = map[int32]string{ + 1: "MATCH_QUERY", + 2: "MATCH_PHRASE_QUERY", + 3: "TERM_QUERY", + 4: "RANGE_QUERY", + 5: "PREFIX_QUERY", + 6: "BOOL_QUERY", + 7: "CONST_SCORE_QUERY", + 8: "FUNCTION_SCORE_QUERY", + 9: "NESTED_QUERY", + 10: "WILDCARD_QUERY", + 11: "MATCH_ALL_QUERY", + 12: "GEO_BOUNDING_BOX_QUERY", + 13: "GEO_DISTANCE_QUERY", + 14: "GEO_POLYGON_QUERY", + 15: "TERMS_QUERY", +} +var QueryType_value = map[string]int32{ + "MATCH_QUERY": 1, + "MATCH_PHRASE_QUERY": 2, + "TERM_QUERY": 3, + "RANGE_QUERY": 4, + "PREFIX_QUERY": 5, + "BOOL_QUERY": 6, + "CONST_SCORE_QUERY": 7, + "FUNCTION_SCORE_QUERY": 8, + "NESTED_QUERY": 9, + "WILDCARD_QUERY": 10, + "MATCH_ALL_QUERY": 11, + "GEO_BOUNDING_BOX_QUERY": 12, + "GEO_DISTANCE_QUERY": 13, + "GEO_POLYGON_QUERY": 14, + "TERMS_QUERY": 15, +} + +func (x QueryType) Enum() *QueryType { + p := new(QueryType) + *p = x + return p +} +func (x QueryType) String() string { + return proto.EnumName(QueryType_name, int32(x)) +} +func (x *QueryType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(QueryType_value, data, "QueryType") + if err != nil { + return err + } + *x = QueryType(value) + return nil +} +func (QueryType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } + +type QueryOperator int32 + +const ( + QueryOperator_OR QueryOperator = 1 + QueryOperator_AND QueryOperator = 2 +) + +var QueryOperator_name = map[int32]string{ + 1: "OR", + 2: "AND", +} +var QueryOperator_value = map[string]int32{ + "OR": 1, + "AND": 2, +} + +func (x QueryOperator) Enum() *QueryOperator { + p := new(QueryOperator) + *p = x + return p +} +func (x QueryOperator) String() string { + return proto.EnumName(QueryOperator_name, int32(x)) +} +func (x *QueryOperator) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(QueryOperator_value, data, "QueryOperator") + if err != nil { + return err + } + *x = QueryOperator(value) + return nil +} +func (QueryOperator) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } + +type ScoreMode int32 + +const ( + ScoreMode_SCORE_MODE_NONE ScoreMode = 1 + ScoreMode_SCORE_MODE_AVG ScoreMode = 2 + ScoreMode_SCORE_MODE_MAX ScoreMode = 3 + ScoreMode_SCORE_MODE_TOTAL ScoreMode = 4 + ScoreMode_SCORE_MODE_MIN ScoreMode = 5 +) + +var ScoreMode_name = map[int32]string{ + 1: "SCORE_MODE_NONE", + 2: "SCORE_MODE_AVG", + 3: "SCORE_MODE_MAX", + 4: "SCORE_MODE_TOTAL", + 5: "SCORE_MODE_MIN", +} +var ScoreMode_value = map[string]int32{ + "SCORE_MODE_NONE": 1, + "SCORE_MODE_AVG": 2, + "SCORE_MODE_MAX": 3, + "SCORE_MODE_TOTAL": 4, + "SCORE_MODE_MIN": 5, +} + +func (x ScoreMode) Enum() *ScoreMode { + p := new(ScoreMode) + *p = x + return p +} +func (x ScoreMode) String() string { + return proto.EnumName(ScoreMode_name, int32(x)) +} +func (x *ScoreMode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ScoreMode_value, data, "ScoreMode") + if err != nil { + return err + } + *x = ScoreMode(value) + return nil +} +func (ScoreMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } + +type SortOrder int32 + +const ( + SortOrder_SORT_ORDER_ASC SortOrder = 0 + SortOrder_SORT_ORDER_DESC SortOrder = 1 +) + +var SortOrder_name = map[int32]string{ + 0: "SORT_ORDER_ASC", + 1: "SORT_ORDER_DESC", +} +var SortOrder_value = map[string]int32{ + "SORT_ORDER_ASC": 0, + "SORT_ORDER_DESC": 1, +} + +func (x SortOrder) Enum() *SortOrder { + p := new(SortOrder) + *p = x + return p +} +func (x SortOrder) String() string { + return proto.EnumName(SortOrder_name, int32(x)) +} +func (x *SortOrder) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(SortOrder_value, data, "SortOrder") + if err != nil { + return err + } + *x = SortOrder(value) + return nil +} +func (SortOrder) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } + +type SortMode int32 + +const ( + SortMode_SORT_MODE_MIN SortMode = 0 + SortMode_SORT_MODE_MAX SortMode = 1 + SortMode_SORT_MODE_AVG SortMode = 2 +) + +var SortMode_name = map[int32]string{ + 0: "SORT_MODE_MIN", + 1: "SORT_MODE_MAX", + 2: "SORT_MODE_AVG", +} +var SortMode_value = map[string]int32{ + "SORT_MODE_MIN": 0, + "SORT_MODE_MAX": 1, + "SORT_MODE_AVG": 2, +} + +func (x SortMode) Enum() *SortMode { + p := new(SortMode) + *p = x + return p +} +func (x SortMode) String() string { + return proto.EnumName(SortMode_name, int32(x)) +} +func (x *SortMode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(SortMode_value, data, "SortMode") + if err != nil { + return err + } + *x = SortMode(value) + return nil +} +func (SortMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } + +type GeoDistanceType int32 + +const ( + GeoDistanceType_GEO_DISTANCE_ARC GeoDistanceType = 0 + GeoDistanceType_GEO_DISTANCE_PLANE GeoDistanceType = 1 +) + +var GeoDistanceType_name = map[int32]string{ + 0: "GEO_DISTANCE_ARC", + 1: "GEO_DISTANCE_PLANE", +} +var GeoDistanceType_value = map[string]int32{ + "GEO_DISTANCE_ARC": 0, + "GEO_DISTANCE_PLANE": 1, +} + +func (x GeoDistanceType) Enum() *GeoDistanceType { + p := new(GeoDistanceType) + *p = x + return p +} +func (x GeoDistanceType) String() string { + return proto.EnumName(GeoDistanceType_name, int32(x)) +} +func (x *GeoDistanceType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(GeoDistanceType_value, data, "GeoDistanceType") + if err != nil { + return err + } + *x = GeoDistanceType(value) + return nil +} +func (GeoDistanceType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } + +type ColumnReturnType int32 + +const ( + ColumnReturnType_RETURN_ALL ColumnReturnType = 1 + ColumnReturnType_RETURN_SPECIFIED ColumnReturnType = 2 + ColumnReturnType_RETURN_NONE ColumnReturnType = 3 +) + +var ColumnReturnType_name = map[int32]string{ + 1: "RETURN_ALL", + 2: "RETURN_SPECIFIED", + 3: "RETURN_NONE", +} +var ColumnReturnType_value = map[string]int32{ + "RETURN_ALL": 1, + "RETURN_SPECIFIED": 2, + "RETURN_NONE": 3, +} + +func (x ColumnReturnType) Enum() *ColumnReturnType { + p := new(ColumnReturnType) + *p = x + return p +} +func (x ColumnReturnType) String() string { + return proto.EnumName(ColumnReturnType_name, int32(x)) +} +func (x *ColumnReturnType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ColumnReturnType_value, data, "ColumnReturnType") + if err != nil { + return err + } + *x = ColumnReturnType(value) + return nil +} +func (ColumnReturnType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } + +type IndexOptions int32 + +const ( + IndexOptions_DOCS IndexOptions = 1 + IndexOptions_FREQS IndexOptions = 2 + IndexOptions_POSITIONS IndexOptions = 3 + IndexOptions_OFFSETS IndexOptions = 4 +) + +var IndexOptions_name = map[int32]string{ + 1: "DOCS", + 2: "FREQS", + 3: "POSITIONS", + 4: "OFFSETS", +} +var IndexOptions_value = map[string]int32{ + "DOCS": 1, + "FREQS": 2, + "POSITIONS": 3, + "OFFSETS": 4, +} + +func (x IndexOptions) Enum() *IndexOptions { + p := new(IndexOptions) + *p = x + return p +} +func (x IndexOptions) String() string { + return proto.EnumName(IndexOptions_name, int32(x)) +} +func (x *IndexOptions) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(IndexOptions_value, data, "IndexOptions") + if err != nil { + return err + } + *x = IndexOptions(value) + return nil +} +func (IndexOptions) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } + +type FieldType int32 + +const ( + FieldType_LONG FieldType = 1 + FieldType_DOUBLE FieldType = 2 + FieldType_BOOLEAN FieldType = 3 + FieldType_KEYWORD FieldType = 4 + FieldType_TEXT FieldType = 5 + FieldType_NESTED FieldType = 6 + FieldType_GEO_POINT FieldType = 7 +) + +var FieldType_name = map[int32]string{ + 1: "LONG", + 2: "DOUBLE", + 3: "BOOLEAN", + 4: "KEYWORD", + 5: "TEXT", + 6: "NESTED", + 7: "GEO_POINT", +} +var FieldType_value = map[string]int32{ + "LONG": 1, + "DOUBLE": 2, + "BOOLEAN": 3, + "KEYWORD": 4, + "TEXT": 5, + "NESTED": 6, + "GEO_POINT": 7, +} + +func (x FieldType) Enum() *FieldType { + p := new(FieldType) + *p = x + return p +} +func (x FieldType) String() string { + return proto.EnumName(FieldType_name, int32(x)) +} +func (x *FieldType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(FieldType_value, data, "FieldType") + if err != nil { + return err + } + *x = FieldType(value) + return nil +} +func (FieldType) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } + +type SyncPhase int32 + +const ( + SyncPhase_FULL SyncPhase = 1 + SyncPhase_INCR SyncPhase = 2 +) + +var SyncPhase_name = map[int32]string{ + 1: "FULL", + 2: "INCR", +} +var SyncPhase_value = map[string]int32{ + "FULL": 1, + "INCR": 2, +} + +func (x SyncPhase) Enum() *SyncPhase { + p := new(SyncPhase) + *p = x + return p +} +func (x SyncPhase) String() string { + return proto.EnumName(SyncPhase_name, int32(x)) +} +func (x *SyncPhase) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(SyncPhase_value, data, "SyncPhase") + if err != nil { + return err + } + *x = SyncPhase(value) + return nil +} +func (SyncPhase) EnumDescriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } + +type MatchQuery struct { + FieldName *string `protobuf:"bytes,1,opt,name=field_name" json:"field_name,omitempty"` + Text *string `protobuf:"bytes,2,opt,name=text" json:"text,omitempty"` + MinimumShouldMatch *int32 `protobuf:"varint,3,opt,name=minimum_should_match" json:"minimum_should_match,omitempty"` + Operator *QueryOperator `protobuf:"varint,4,opt,name=operator,enum=otsprotocol.QueryOperator" json:"operator,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MatchQuery) Reset() { *m = MatchQuery{} } +func (m *MatchQuery) String() string { return proto.CompactTextString(m) } +func (*MatchQuery) ProtoMessage() {} +func (*MatchQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} } + +func (m *MatchQuery) GetFieldName() string { + if m != nil && m.FieldName != nil { + return *m.FieldName + } + return "" +} + +func (m *MatchQuery) GetText() string { + if m != nil && m.Text != nil { + return *m.Text + } + return "" +} + +func (m *MatchQuery) GetMinimumShouldMatch() int32 { + if m != nil && m.MinimumShouldMatch != nil { + return *m.MinimumShouldMatch + } + return 0 +} + +func (m *MatchQuery) GetOperator() QueryOperator { + if m != nil && m.Operator != nil { + return *m.Operator + } + return QueryOperator_OR +} + +type MatchPhraseQuery struct { + FieldName *string `protobuf:"bytes,1,opt,name=field_name" json:"field_name,omitempty"` + Text *string `protobuf:"bytes,2,opt,name=text" json:"text,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *MatchPhraseQuery) Reset() { *m = MatchPhraseQuery{} } +func (m *MatchPhraseQuery) String() string { return proto.CompactTextString(m) } +func (*MatchPhraseQuery) ProtoMessage() {} +func (*MatchPhraseQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} } + +func (m *MatchPhraseQuery) GetFieldName() string { + if m != nil && m.FieldName != nil { + return *m.FieldName + } + return "" +} + +func (m *MatchPhraseQuery) GetText() string { + if m != nil && m.Text != nil { + return *m.Text + } + return "" +} + +type MatchAllQuery struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *MatchAllQuery) Reset() { *m = MatchAllQuery{} } +func (m *MatchAllQuery) String() string { return proto.CompactTextString(m) } +func (*MatchAllQuery) ProtoMessage() {} +func (*MatchAllQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{2} } + +type TermQuery struct { + FieldName *string `protobuf:"bytes,1,opt,name=field_name" json:"field_name,omitempty"` + Term []byte `protobuf:"bytes,2,opt,name=term" json:"term,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TermQuery) Reset() { *m = TermQuery{} } +func (m *TermQuery) String() string { return proto.CompactTextString(m) } +func (*TermQuery) ProtoMessage() {} +func (*TermQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{3} } + +func (m *TermQuery) GetFieldName() string { + if m != nil && m.FieldName != nil { + return *m.FieldName + } + return "" +} + +func (m *TermQuery) GetTerm() []byte { + if m != nil { + return m.Term + } + return nil +} + +type TermsQuery struct { + FieldName *string `protobuf:"bytes,1,opt,name=field_name" json:"field_name,omitempty"` + Terms [][]byte `protobuf:"bytes,2,rep,name=terms" json:"terms,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TermsQuery) Reset() { *m = TermsQuery{} } +func (m *TermsQuery) String() string { return proto.CompactTextString(m) } +func (*TermsQuery) ProtoMessage() {} +func (*TermsQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{4} } + +func (m *TermsQuery) GetFieldName() string { + if m != nil && m.FieldName != nil { + return *m.FieldName + } + return "" +} + +func (m *TermsQuery) GetTerms() [][]byte { + if m != nil { + return m.Terms + } + return nil +} + +type RangeQuery struct { + FieldName *string `protobuf:"bytes,1,opt,name=field_name" json:"field_name,omitempty"` + RangeFrom []byte `protobuf:"bytes,2,opt,name=range_from" json:"range_from,omitempty"` + RangeTo []byte `protobuf:"bytes,3,opt,name=range_to" json:"range_to,omitempty"` + IncludeLower *bool `protobuf:"varint,4,opt,name=include_lower" json:"include_lower,omitempty"` + IncludeUpper *bool `protobuf:"varint,5,opt,name=include_upper" json:"include_upper,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *RangeQuery) Reset() { *m = RangeQuery{} } +func (m *RangeQuery) String() string { return proto.CompactTextString(m) } +func (*RangeQuery) ProtoMessage() {} +func (*RangeQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{5} } + +func (m *RangeQuery) GetFieldName() string { + if m != nil && m.FieldName != nil { + return *m.FieldName + } + return "" +} + +func (m *RangeQuery) GetRangeFrom() []byte { + if m != nil { + return m.RangeFrom + } + return nil +} + +func (m *RangeQuery) GetRangeTo() []byte { + if m != nil { + return m.RangeTo + } + return nil +} + +func (m *RangeQuery) GetIncludeLower() bool { + if m != nil && m.IncludeLower != nil { + return *m.IncludeLower + } + return false +} + +func (m *RangeQuery) GetIncludeUpper() bool { + if m != nil && m.IncludeUpper != nil { + return *m.IncludeUpper + } + return false +} + +type PrefixQuery struct { + FieldName *string `protobuf:"bytes,1,opt,name=field_name" json:"field_name,omitempty"` + Prefix *string `protobuf:"bytes,2,opt,name=prefix" json:"prefix,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PrefixQuery) Reset() { *m = PrefixQuery{} } +func (m *PrefixQuery) String() string { return proto.CompactTextString(m) } +func (*PrefixQuery) ProtoMessage() {} +func (*PrefixQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{6} } + +func (m *PrefixQuery) GetFieldName() string { + if m != nil && m.FieldName != nil { + return *m.FieldName + } + return "" +} + +func (m *PrefixQuery) GetPrefix() string { + if m != nil && m.Prefix != nil { + return *m.Prefix + } + return "" +} + +type WildcardQuery struct { + FieldName *string `protobuf:"bytes,1,opt,name=field_name" json:"field_name,omitempty"` + Value *string `protobuf:"bytes,2,opt,name=value" json:"value,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *WildcardQuery) Reset() { *m = WildcardQuery{} } +func (m *WildcardQuery) String() string { return proto.CompactTextString(m) } +func (*WildcardQuery) ProtoMessage() {} +func (*WildcardQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{7} } + +func (m *WildcardQuery) GetFieldName() string { + if m != nil && m.FieldName != nil { + return *m.FieldName + } + return "" +} + +func (m *WildcardQuery) GetValue() string { + if m != nil && m.Value != nil { + return *m.Value + } + return "" +} + +type BoolQuery struct { + MustQueries []*Query `protobuf:"bytes,1,rep,name=must_queries" json:"must_queries,omitempty"` + MustNotQueries []*Query `protobuf:"bytes,2,rep,name=must_not_queries" json:"must_not_queries,omitempty"` + FilterQueries []*Query `protobuf:"bytes,3,rep,name=filter_queries" json:"filter_queries,omitempty"` + ShouldQueries []*Query `protobuf:"bytes,4,rep,name=should_queries" json:"should_queries,omitempty"` + MinimumShouldMatch *int32 `protobuf:"varint,5,opt,name=minimum_should_match" json:"minimum_should_match,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *BoolQuery) Reset() { *m = BoolQuery{} } +func (m *BoolQuery) String() string { return proto.CompactTextString(m) } +func (*BoolQuery) ProtoMessage() {} +func (*BoolQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{8} } + +func (m *BoolQuery) GetMustQueries() []*Query { + if m != nil { + return m.MustQueries + } + return nil +} + +func (m *BoolQuery) GetMustNotQueries() []*Query { + if m != nil { + return m.MustNotQueries + } + return nil +} + +func (m *BoolQuery) GetFilterQueries() []*Query { + if m != nil { + return m.FilterQueries + } + return nil +} + +func (m *BoolQuery) GetShouldQueries() []*Query { + if m != nil { + return m.ShouldQueries + } + return nil +} + +func (m *BoolQuery) GetMinimumShouldMatch() int32 { + if m != nil && m.MinimumShouldMatch != nil { + return *m.MinimumShouldMatch + } + return 0 +} + +type ConstScoreQuery struct { + Filter *Query `protobuf:"bytes,1,opt,name=filter" json:"filter,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ConstScoreQuery) Reset() { *m = ConstScoreQuery{} } +func (m *ConstScoreQuery) String() string { return proto.CompactTextString(m) } +func (*ConstScoreQuery) ProtoMessage() {} +func (*ConstScoreQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{9} } + +func (m *ConstScoreQuery) GetFilter() *Query { + if m != nil { + return m.Filter + } + return nil +} + +type FieldValueFactor struct { + FieldName *string `protobuf:"bytes,1,opt,name=field_name" json:"field_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FieldValueFactor) Reset() { *m = FieldValueFactor{} } +func (m *FieldValueFactor) String() string { return proto.CompactTextString(m) } +func (*FieldValueFactor) ProtoMessage() {} +func (*FieldValueFactor) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{10} } + +func (m *FieldValueFactor) GetFieldName() string { + if m != nil && m.FieldName != nil { + return *m.FieldName + } + return "" +} + +type FunctionScoreQuery struct { + Query *Query `protobuf:"bytes,1,opt,name=query" json:"query,omitempty"` + FieldValueFactor *FieldValueFactor `protobuf:"bytes,2,opt,name=field_value_factor" json:"field_value_factor,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FunctionScoreQuery) Reset() { *m = FunctionScoreQuery{} } +func (m *FunctionScoreQuery) String() string { return proto.CompactTextString(m) } +func (*FunctionScoreQuery) ProtoMessage() {} +func (*FunctionScoreQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{11} } + +func (m *FunctionScoreQuery) GetQuery() *Query { + if m != nil { + return m.Query + } + return nil +} + +func (m *FunctionScoreQuery) GetFieldValueFactor() *FieldValueFactor { + if m != nil { + return m.FieldValueFactor + } + return nil +} + +type NestedQuery struct { + Path *string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"` + Query *Query `protobuf:"bytes,2,opt,name=query" json:"query,omitempty"` + ScoreMode *ScoreMode `protobuf:"varint,3,opt,name=score_mode,enum=otsprotocol.ScoreMode" json:"score_mode,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedQuery) Reset() { *m = NestedQuery{} } +func (m *NestedQuery) String() string { return proto.CompactTextString(m) } +func (*NestedQuery) ProtoMessage() {} +func (*NestedQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{12} } + +func (m *NestedQuery) GetPath() string { + if m != nil && m.Path != nil { + return *m.Path + } + return "" +} + +func (m *NestedQuery) GetQuery() *Query { + if m != nil { + return m.Query + } + return nil +} + +func (m *NestedQuery) GetScoreMode() ScoreMode { + if m != nil && m.ScoreMode != nil { + return *m.ScoreMode + } + return ScoreMode_SCORE_MODE_NONE +} + +type GeoBoundingBoxQuery struct { + FieldName *string `protobuf:"bytes,1,opt,name=field_name" json:"field_name,omitempty"` + TopLeft *string `protobuf:"bytes,2,opt,name=top_left" json:"top_left,omitempty"` + BottomRight *string `protobuf:"bytes,3,opt,name=bottom_right" json:"bottom_right,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GeoBoundingBoxQuery) Reset() { *m = GeoBoundingBoxQuery{} } +func (m *GeoBoundingBoxQuery) String() string { return proto.CompactTextString(m) } +func (*GeoBoundingBoxQuery) ProtoMessage() {} +func (*GeoBoundingBoxQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{13} } + +func (m *GeoBoundingBoxQuery) GetFieldName() string { + if m != nil && m.FieldName != nil { + return *m.FieldName + } + return "" +} + +func (m *GeoBoundingBoxQuery) GetTopLeft() string { + if m != nil && m.TopLeft != nil { + return *m.TopLeft + } + return "" +} + +func (m *GeoBoundingBoxQuery) GetBottomRight() string { + if m != nil && m.BottomRight != nil { + return *m.BottomRight + } + return "" +} + +type GeoDistanceQuery struct { + FieldName *string `protobuf:"bytes,1,opt,name=field_name" json:"field_name,omitempty"` + CenterPoint *string `protobuf:"bytes,2,opt,name=center_point" json:"center_point,omitempty"` + Distance *float64 `protobuf:"fixed64,3,opt,name=distance" json:"distance,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GeoDistanceQuery) Reset() { *m = GeoDistanceQuery{} } +func (m *GeoDistanceQuery) String() string { return proto.CompactTextString(m) } +func (*GeoDistanceQuery) ProtoMessage() {} +func (*GeoDistanceQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{14} } + +func (m *GeoDistanceQuery) GetFieldName() string { + if m != nil && m.FieldName != nil { + return *m.FieldName + } + return "" +} + +func (m *GeoDistanceQuery) GetCenterPoint() string { + if m != nil && m.CenterPoint != nil { + return *m.CenterPoint + } + return "" +} + +func (m *GeoDistanceQuery) GetDistance() float64 { + if m != nil && m.Distance != nil { + return *m.Distance + } + return 0 +} + +type GeoPolygonQuery struct { + FieldName *string `protobuf:"bytes,1,opt,name=field_name" json:"field_name,omitempty"` + Points []string `protobuf:"bytes,2,rep,name=points" json:"points,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GeoPolygonQuery) Reset() { *m = GeoPolygonQuery{} } +func (m *GeoPolygonQuery) String() string { return proto.CompactTextString(m) } +func (*GeoPolygonQuery) ProtoMessage() {} +func (*GeoPolygonQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{15} } + +func (m *GeoPolygonQuery) GetFieldName() string { + if m != nil && m.FieldName != nil { + return *m.FieldName + } + return "" +} + +func (m *GeoPolygonQuery) GetPoints() []string { + if m != nil { + return m.Points + } + return nil +} + +type Query struct { + Type *QueryType `protobuf:"varint,1,opt,name=type,enum=otsprotocol.QueryType" json:"type,omitempty"` + Query []byte `protobuf:"bytes,2,opt,name=query" json:"query,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Query) Reset() { *m = Query{} } +func (m *Query) String() string { return proto.CompactTextString(m) } +func (*Query) ProtoMessage() {} +func (*Query) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{16} } + +func (m *Query) GetType() QueryType { + if m != nil && m.Type != nil { + return *m.Type + } + return QueryType_MATCH_QUERY +} + +func (m *Query) GetQuery() []byte { + if m != nil { + return m.Query + } + return nil +} + +type Collapse struct { + FieldName *string `protobuf:"bytes,1,opt,name=field_name" json:"field_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Collapse) Reset() { *m = Collapse{} } +func (m *Collapse) String() string { return proto.CompactTextString(m) } +func (*Collapse) ProtoMessage() {} +func (*Collapse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{17} } + +func (m *Collapse) GetFieldName() string { + if m != nil && m.FieldName != nil { + return *m.FieldName + } + return "" +} + +type NestedFilter struct { + Path *string `protobuf:"bytes,1,opt,name=path" json:"path,omitempty"` + Filter *Query `protobuf:"bytes,2,opt,name=filter" json:"filter,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *NestedFilter) Reset() { *m = NestedFilter{} } +func (m *NestedFilter) String() string { return proto.CompactTextString(m) } +func (*NestedFilter) ProtoMessage() {} +func (*NestedFilter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{18} } + +func (m *NestedFilter) GetPath() string { + if m != nil && m.Path != nil { + return *m.Path + } + return "" +} + +func (m *NestedFilter) GetFilter() *Query { + if m != nil { + return m.Filter + } + return nil +} + +type ScoreSort struct { + Order *SortOrder `protobuf:"varint,1,opt,name=order,enum=otsprotocol.SortOrder" json:"order,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ScoreSort) Reset() { *m = ScoreSort{} } +func (m *ScoreSort) String() string { return proto.CompactTextString(m) } +func (*ScoreSort) ProtoMessage() {} +func (*ScoreSort) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{19} } + +func (m *ScoreSort) GetOrder() SortOrder { + if m != nil && m.Order != nil { + return *m.Order + } + return SortOrder_SORT_ORDER_ASC +} + +type FieldSort struct { + FieldName *string `protobuf:"bytes,1,opt,name=field_name" json:"field_name,omitempty"` + Order *SortOrder `protobuf:"varint,2,opt,name=order,enum=otsprotocol.SortOrder" json:"order,omitempty"` + Mode *SortMode `protobuf:"varint,3,opt,name=mode,enum=otsprotocol.SortMode" json:"mode,omitempty"` + NestedFilter *NestedFilter `protobuf:"bytes,4,opt,name=nested_filter" json:"nested_filter,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FieldSort) Reset() { *m = FieldSort{} } +func (m *FieldSort) String() string { return proto.CompactTextString(m) } +func (*FieldSort) ProtoMessage() {} +func (*FieldSort) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{20} } + +func (m *FieldSort) GetFieldName() string { + if m != nil && m.FieldName != nil { + return *m.FieldName + } + return "" +} + +func (m *FieldSort) GetOrder() SortOrder { + if m != nil && m.Order != nil { + return *m.Order + } + return SortOrder_SORT_ORDER_ASC +} + +func (m *FieldSort) GetMode() SortMode { + if m != nil && m.Mode != nil { + return *m.Mode + } + return SortMode_SORT_MODE_MIN +} + +func (m *FieldSort) GetNestedFilter() *NestedFilter { + if m != nil { + return m.NestedFilter + } + return nil +} + +type GeoDistanceSort struct { + FieldName *string `protobuf:"bytes,1,opt,name=field_name" json:"field_name,omitempty"` + Points []string `protobuf:"bytes,2,rep,name=points" json:"points,omitempty"` + Order *SortOrder `protobuf:"varint,3,opt,name=order,enum=otsprotocol.SortOrder" json:"order,omitempty"` + Mode *SortMode `protobuf:"varint,4,opt,name=mode,enum=otsprotocol.SortMode" json:"mode,omitempty"` + DistanceType *GeoDistanceType `protobuf:"varint,5,opt,name=distance_type,enum=otsprotocol.GeoDistanceType" json:"distance_type,omitempty"` + NestedFilter *NestedFilter `protobuf:"bytes,6,opt,name=nested_filter" json:"nested_filter,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GeoDistanceSort) Reset() { *m = GeoDistanceSort{} } +func (m *GeoDistanceSort) String() string { return proto.CompactTextString(m) } +func (*GeoDistanceSort) ProtoMessage() {} +func (*GeoDistanceSort) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{21} } + +func (m *GeoDistanceSort) GetFieldName() string { + if m != nil && m.FieldName != nil { + return *m.FieldName + } + return "" +} + +func (m *GeoDistanceSort) GetPoints() []string { + if m != nil { + return m.Points + } + return nil +} + +func (m *GeoDistanceSort) GetOrder() SortOrder { + if m != nil && m.Order != nil { + return *m.Order + } + return SortOrder_SORT_ORDER_ASC +} + +func (m *GeoDistanceSort) GetMode() SortMode { + if m != nil && m.Mode != nil { + return *m.Mode + } + return SortMode_SORT_MODE_MIN +} + +func (m *GeoDistanceSort) GetDistanceType() GeoDistanceType { + if m != nil && m.DistanceType != nil { + return *m.DistanceType + } + return GeoDistanceType_GEO_DISTANCE_ARC +} + +func (m *GeoDistanceSort) GetNestedFilter() *NestedFilter { + if m != nil { + return m.NestedFilter + } + return nil +} + +type PrimaryKeySort struct { + Order *SortOrder `protobuf:"varint,1,opt,name=order,enum=otsprotocol.SortOrder" json:"order,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PrimaryKeySort) Reset() { *m = PrimaryKeySort{} } +func (m *PrimaryKeySort) String() string { return proto.CompactTextString(m) } +func (*PrimaryKeySort) ProtoMessage() {} +func (*PrimaryKeySort) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{22} } + +func (m *PrimaryKeySort) GetOrder() SortOrder { + if m != nil && m.Order != nil { + return *m.Order + } + return SortOrder_SORT_ORDER_ASC +} + +type Sorter struct { + FieldSort *FieldSort `protobuf:"bytes,1,opt,name=field_sort" json:"field_sort,omitempty"` + GeoDistanceSort *GeoDistanceSort `protobuf:"bytes,2,opt,name=geo_distance_sort" json:"geo_distance_sort,omitempty"` + ScoreSort *ScoreSort `protobuf:"bytes,3,opt,name=score_sort" json:"score_sort,omitempty"` + PkSort *PrimaryKeySort `protobuf:"bytes,4,opt,name=pk_sort" json:"pk_sort,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Sorter) Reset() { *m = Sorter{} } +func (m *Sorter) String() string { return proto.CompactTextString(m) } +func (*Sorter) ProtoMessage() {} +func (*Sorter) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{23} } + +func (m *Sorter) GetFieldSort() *FieldSort { + if m != nil { + return m.FieldSort + } + return nil +} + +func (m *Sorter) GetGeoDistanceSort() *GeoDistanceSort { + if m != nil { + return m.GeoDistanceSort + } + return nil +} + +func (m *Sorter) GetScoreSort() *ScoreSort { + if m != nil { + return m.ScoreSort + } + return nil +} + +func (m *Sorter) GetPkSort() *PrimaryKeySort { + if m != nil { + return m.PkSort + } + return nil +} + +type Sort struct { + Sorter []*Sorter `protobuf:"bytes,1,rep,name=sorter" json:"sorter,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Sort) Reset() { *m = Sort{} } +func (m *Sort) String() string { return proto.CompactTextString(m) } +func (*Sort) ProtoMessage() {} +func (*Sort) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{24} } + +func (m *Sort) GetSorter() []*Sorter { + if m != nil { + return m.Sorter + } + return nil +} + +type SearchQuery struct { + Offset *int32 `protobuf:"varint,1,opt,name=offset" json:"offset,omitempty"` + Limit *int32 `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"` + Query *Query `protobuf:"bytes,4,opt,name=query" json:"query,omitempty"` + Collapse *Collapse `protobuf:"bytes,5,opt,name=collapse" json:"collapse,omitempty"` + Sort *Sort `protobuf:"bytes,6,opt,name=sort" json:"sort,omitempty"` + GetTotalCount *bool `protobuf:"varint,8,opt,name=getTotalCount" json:"getTotalCount,omitempty"` + Token []byte `protobuf:"bytes,9,opt,name=token" json:"token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SearchQuery) Reset() { *m = SearchQuery{} } +func (m *SearchQuery) String() string { return proto.CompactTextString(m) } +func (*SearchQuery) ProtoMessage() {} +func (*SearchQuery) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{25} } + +func (m *SearchQuery) GetOffset() int32 { + if m != nil && m.Offset != nil { + return *m.Offset + } + return 0 +} + +func (m *SearchQuery) GetLimit() int32 { + if m != nil && m.Limit != nil { + return *m.Limit + } + return 0 +} + +func (m *SearchQuery) GetQuery() *Query { + if m != nil { + return m.Query + } + return nil +} + +func (m *SearchQuery) GetCollapse() *Collapse { + if m != nil { + return m.Collapse + } + return nil +} + +func (m *SearchQuery) GetSort() *Sort { + if m != nil { + return m.Sort + } + return nil +} + +func (m *SearchQuery) GetGetTotalCount() bool { + if m != nil && m.GetTotalCount != nil { + return *m.GetTotalCount + } + return false +} + +func (m *SearchQuery) GetToken() []byte { + if m != nil { + return m.Token + } + return nil +} + +type ColumnsToGet struct { + ReturnType *ColumnReturnType `protobuf:"varint,1,opt,name=return_type,enum=otsprotocol.ColumnReturnType" json:"return_type,omitempty"` + ColumnNames []string `protobuf:"bytes,2,rep,name=column_names" json:"column_names,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ColumnsToGet) Reset() { *m = ColumnsToGet{} } +func (m *ColumnsToGet) String() string { return proto.CompactTextString(m) } +func (*ColumnsToGet) ProtoMessage() {} +func (*ColumnsToGet) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{26} } + +func (m *ColumnsToGet) GetReturnType() ColumnReturnType { + if m != nil && m.ReturnType != nil { + return *m.ReturnType + } + return ColumnReturnType_RETURN_ALL +} + +func (m *ColumnsToGet) GetColumnNames() []string { + if m != nil { + return m.ColumnNames + } + return nil +} + +type SearchRequest struct { + TableName *string `protobuf:"bytes,1,opt,name=table_name" json:"table_name,omitempty"` + IndexName *string `protobuf:"bytes,2,opt,name=index_name" json:"index_name,omitempty"` + ColumnsToGet *ColumnsToGet `protobuf:"bytes,3,opt,name=columns_to_get" json:"columns_to_get,omitempty"` + SearchQuery []byte `protobuf:"bytes,4,opt,name=search_query" json:"search_query,omitempty"` + RoutingValues [][]byte `protobuf:"bytes,5,rep,name=routing_values" json:"routing_values,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SearchRequest) Reset() { *m = SearchRequest{} } +func (m *SearchRequest) String() string { return proto.CompactTextString(m) } +func (*SearchRequest) ProtoMessage() {} +func (*SearchRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{27} } + +func (m *SearchRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *SearchRequest) GetIndexName() string { + if m != nil && m.IndexName != nil { + return *m.IndexName + } + return "" +} + +func (m *SearchRequest) GetColumnsToGet() *ColumnsToGet { + if m != nil { + return m.ColumnsToGet + } + return nil +} + +func (m *SearchRequest) GetSearchQuery() []byte { + if m != nil { + return m.SearchQuery + } + return nil +} + +func (m *SearchRequest) GetRoutingValues() [][]byte { + if m != nil { + return m.RoutingValues + } + return nil +} + +type SearchResponse struct { + TotalHits *int64 `protobuf:"varint,1,opt,name=total_hits" json:"total_hits,omitempty"` + Rows [][]byte `protobuf:"bytes,2,rep,name=rows" json:"rows,omitempty"` + IsAllSucceeded *bool `protobuf:"varint,3,opt,name=is_all_succeeded" json:"is_all_succeeded,omitempty"` + NextToken []byte `protobuf:"bytes,6,opt,name=next_token" json:"next_token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SearchResponse) Reset() { *m = SearchResponse{} } +func (m *SearchResponse) String() string { return proto.CompactTextString(m) } +func (*SearchResponse) ProtoMessage() {} +func (*SearchResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{28} } + +func (m *SearchResponse) GetTotalHits() int64 { + if m != nil && m.TotalHits != nil { + return *m.TotalHits + } + return 0 +} + +func (m *SearchResponse) GetRows() [][]byte { + if m != nil { + return m.Rows + } + return nil +} + +func (m *SearchResponse) GetIsAllSucceeded() bool { + if m != nil && m.IsAllSucceeded != nil { + return *m.IsAllSucceeded + } + return false +} + +func (m *SearchResponse) GetNextToken() []byte { + if m != nil { + return m.NextToken + } + return nil +} + +type FieldSchema struct { + FieldName *string `protobuf:"bytes,1,opt,name=field_name" json:"field_name,omitempty"` + FieldType *FieldType `protobuf:"varint,2,opt,name=field_type,enum=otsprotocol.FieldType" json:"field_type,omitempty"` + IndexOptions *IndexOptions `protobuf:"varint,3,opt,name=index_options,enum=otsprotocol.IndexOptions" json:"index_options,omitempty"` + Analyzer *string `protobuf:"bytes,4,opt,name=analyzer" json:"analyzer,omitempty"` + Index *bool `protobuf:"varint,5,opt,name=index" json:"index,omitempty"` + DocValues *bool `protobuf:"varint,6,opt,name=doc_values" json:"doc_values,omitempty"` + Store *bool `protobuf:"varint,7,opt,name=store" json:"store,omitempty"` + FieldSchemas []*FieldSchema `protobuf:"bytes,8,rep,name=field_schemas" json:"field_schemas,omitempty"` + IsArray *bool `protobuf:"varint,9,opt,name=is_array" json:"is_array,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *FieldSchema) Reset() { *m = FieldSchema{} } +func (m *FieldSchema) String() string { return proto.CompactTextString(m) } +func (*FieldSchema) ProtoMessage() {} +func (*FieldSchema) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{29} } + +func (m *FieldSchema) GetFieldName() string { + if m != nil && m.FieldName != nil { + return *m.FieldName + } + return "" +} + +func (m *FieldSchema) GetFieldType() FieldType { + if m != nil && m.FieldType != nil { + return *m.FieldType + } + return FieldType_LONG +} + +func (m *FieldSchema) GetIndexOptions() IndexOptions { + if m != nil && m.IndexOptions != nil { + return *m.IndexOptions + } + return IndexOptions_DOCS +} + +func (m *FieldSchema) GetAnalyzer() string { + if m != nil && m.Analyzer != nil { + return *m.Analyzer + } + return "" +} + +func (m *FieldSchema) GetIndex() bool { + if m != nil && m.Index != nil { + return *m.Index + } + return false +} + +func (m *FieldSchema) GetDocValues() bool { + if m != nil && m.DocValues != nil { + return *m.DocValues + } + return false +} + +func (m *FieldSchema) GetStore() bool { + if m != nil && m.Store != nil { + return *m.Store + } + return false +} + +func (m *FieldSchema) GetFieldSchemas() []*FieldSchema { + if m != nil { + return m.FieldSchemas + } + return nil +} + +func (m *FieldSchema) GetIsArray() bool { + if m != nil && m.IsArray != nil { + return *m.IsArray + } + return false +} + +type IndexSchema struct { + FieldSchemas []*FieldSchema `protobuf:"bytes,1,rep,name=field_schemas" json:"field_schemas,omitempty"` + IndexSetting *IndexSetting `protobuf:"bytes,2,opt,name=index_setting" json:"index_setting,omitempty"` + IndexSort *Sort `protobuf:"bytes,3,opt,name=index_sort" json:"index_sort,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *IndexSchema) Reset() { *m = IndexSchema{} } +func (m *IndexSchema) String() string { return proto.CompactTextString(m) } +func (*IndexSchema) ProtoMessage() {} +func (*IndexSchema) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{30} } + +func (m *IndexSchema) GetFieldSchemas() []*FieldSchema { + if m != nil { + return m.FieldSchemas + } + return nil +} + +func (m *IndexSchema) GetIndexSetting() *IndexSetting { + if m != nil { + return m.IndexSetting + } + return nil +} + +func (m *IndexSchema) GetIndexSort() *Sort { + if m != nil { + return m.IndexSort + } + return nil +} + +type IndexSetting struct { + NumberOfShards *int32 `protobuf:"varint,1,opt,name=number_of_shards" json:"number_of_shards,omitempty"` + RoutingFields []string `protobuf:"bytes,2,rep,name=routing_fields" json:"routing_fields,omitempty"` + RoutingPartitionSize *int32 `protobuf:"varint,3,opt,name=routing_partition_size" json:"routing_partition_size,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *IndexSetting) Reset() { *m = IndexSetting{} } +func (m *IndexSetting) String() string { return proto.CompactTextString(m) } +func (*IndexSetting) ProtoMessage() {} +func (*IndexSetting) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{31} } + +func (m *IndexSetting) GetNumberOfShards() int32 { + if m != nil && m.NumberOfShards != nil { + return *m.NumberOfShards + } + return 0 +} + +func (m *IndexSetting) GetRoutingFields() []string { + if m != nil { + return m.RoutingFields + } + return nil +} + +func (m *IndexSetting) GetRoutingPartitionSize() int32 { + if m != nil && m.RoutingPartitionSize != nil { + return *m.RoutingPartitionSize + } + return 0 +} + +type CreateSearchIndexRequest struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + IndexName *string `protobuf:"bytes,2,req,name=index_name" json:"index_name,omitempty"` + Schema *IndexSchema `protobuf:"bytes,3,opt,name=schema" json:"schema,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CreateSearchIndexRequest) Reset() { *m = CreateSearchIndexRequest{} } +func (m *CreateSearchIndexRequest) String() string { return proto.CompactTextString(m) } +func (*CreateSearchIndexRequest) ProtoMessage() {} +func (*CreateSearchIndexRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{32} } + +func (m *CreateSearchIndexRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *CreateSearchIndexRequest) GetIndexName() string { + if m != nil && m.IndexName != nil { + return *m.IndexName + } + return "" +} + +func (m *CreateSearchIndexRequest) GetSchema() *IndexSchema { + if m != nil { + return m.Schema + } + return nil +} + +type CreateSearchIndexResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CreateSearchIndexResponse) Reset() { *m = CreateSearchIndexResponse{} } +func (m *CreateSearchIndexResponse) String() string { return proto.CompactTextString(m) } +func (*CreateSearchIndexResponse) ProtoMessage() {} +func (*CreateSearchIndexResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{33} } + +type IndexInfo struct { + TableName *string `protobuf:"bytes,1,opt,name=table_name" json:"table_name,omitempty"` + IndexName *string `protobuf:"bytes,2,opt,name=index_name" json:"index_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *IndexInfo) Reset() { *m = IndexInfo{} } +func (m *IndexInfo) String() string { return proto.CompactTextString(m) } +func (*IndexInfo) ProtoMessage() {} +func (*IndexInfo) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{34} } + +func (m *IndexInfo) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *IndexInfo) GetIndexName() string { + if m != nil && m.IndexName != nil { + return *m.IndexName + } + return "" +} + +type ListSearchIndexRequest struct { + TableName *string `protobuf:"bytes,1,opt,name=table_name" json:"table_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ListSearchIndexRequest) Reset() { *m = ListSearchIndexRequest{} } +func (m *ListSearchIndexRequest) String() string { return proto.CompactTextString(m) } +func (*ListSearchIndexRequest) ProtoMessage() {} +func (*ListSearchIndexRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{35} } + +func (m *ListSearchIndexRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +type ListSearchIndexResponse struct { + Indices []*IndexInfo `protobuf:"bytes,1,rep,name=indices" json:"indices,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ListSearchIndexResponse) Reset() { *m = ListSearchIndexResponse{} } +func (m *ListSearchIndexResponse) String() string { return proto.CompactTextString(m) } +func (*ListSearchIndexResponse) ProtoMessage() {} +func (*ListSearchIndexResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{36} } + +func (m *ListSearchIndexResponse) GetIndices() []*IndexInfo { + if m != nil { + return m.Indices + } + return nil +} + +type DeleteSearchIndexRequest struct { + TableName *string `protobuf:"bytes,1,opt,name=table_name" json:"table_name,omitempty"` + IndexName *string `protobuf:"bytes,2,opt,name=index_name" json:"index_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeleteSearchIndexRequest) Reset() { *m = DeleteSearchIndexRequest{} } +func (m *DeleteSearchIndexRequest) String() string { return proto.CompactTextString(m) } +func (*DeleteSearchIndexRequest) ProtoMessage() {} +func (*DeleteSearchIndexRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{37} } + +func (m *DeleteSearchIndexRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *DeleteSearchIndexRequest) GetIndexName() string { + if m != nil && m.IndexName != nil { + return *m.IndexName + } + return "" +} + +type DeleteSearchIndexResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeleteSearchIndexResponse) Reset() { *m = DeleteSearchIndexResponse{} } +func (m *DeleteSearchIndexResponse) String() string { return proto.CompactTextString(m) } +func (*DeleteSearchIndexResponse) ProtoMessage() {} +func (*DeleteSearchIndexResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{38} } + +type SyncStat struct { + SyncPhase *SyncPhase `protobuf:"varint,1,opt,name=sync_phase,enum=otsprotocol.SyncPhase" json:"sync_phase,omitempty"` + CurrentSyncTimestamp *int64 `protobuf:"varint,2,opt,name=current_sync_timestamp" json:"current_sync_timestamp,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *SyncStat) Reset() { *m = SyncStat{} } +func (m *SyncStat) String() string { return proto.CompactTextString(m) } +func (*SyncStat) ProtoMessage() {} +func (*SyncStat) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{39} } + +func (m *SyncStat) GetSyncPhase() SyncPhase { + if m != nil && m.SyncPhase != nil { + return *m.SyncPhase + } + return SyncPhase_FULL +} + +func (m *SyncStat) GetCurrentSyncTimestamp() int64 { + if m != nil && m.CurrentSyncTimestamp != nil { + return *m.CurrentSyncTimestamp + } + return 0 +} + +type DescribeSearchIndexRequest struct { + TableName *string `protobuf:"bytes,1,opt,name=table_name" json:"table_name,omitempty"` + IndexName *string `protobuf:"bytes,2,opt,name=index_name" json:"index_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DescribeSearchIndexRequest) Reset() { *m = DescribeSearchIndexRequest{} } +func (m *DescribeSearchIndexRequest) String() string { return proto.CompactTextString(m) } +func (*DescribeSearchIndexRequest) ProtoMessage() {} +func (*DescribeSearchIndexRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{40} } + +func (m *DescribeSearchIndexRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *DescribeSearchIndexRequest) GetIndexName() string { + if m != nil && m.IndexName != nil { + return *m.IndexName + } + return "" +} + +type DescribeSearchIndexResponse struct { + Schema *IndexSchema `protobuf:"bytes,1,opt,name=schema" json:"schema,omitempty"` + SyncStat *SyncStat `protobuf:"bytes,2,opt,name=sync_stat" json:"sync_stat,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DescribeSearchIndexResponse) Reset() { *m = DescribeSearchIndexResponse{} } +func (m *DescribeSearchIndexResponse) String() string { return proto.CompactTextString(m) } +func (*DescribeSearchIndexResponse) ProtoMessage() {} +func (*DescribeSearchIndexResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{41} } + +func (m *DescribeSearchIndexResponse) GetSchema() *IndexSchema { + if m != nil { + return m.Schema + } + return nil +} + +func (m *DescribeSearchIndexResponse) GetSyncStat() *SyncStat { + if m != nil { + return m.SyncStat + } + return nil +} + +func init() { + proto.RegisterType((*MatchQuery)(nil), "otsprotocol.MatchQuery") + proto.RegisterType((*MatchPhraseQuery)(nil), "otsprotocol.MatchPhraseQuery") + proto.RegisterType((*MatchAllQuery)(nil), "otsprotocol.MatchAllQuery") + proto.RegisterType((*TermQuery)(nil), "otsprotocol.TermQuery") + proto.RegisterType((*TermsQuery)(nil), "otsprotocol.TermsQuery") + proto.RegisterType((*RangeQuery)(nil), "otsprotocol.RangeQuery") + proto.RegisterType((*PrefixQuery)(nil), "otsprotocol.PrefixQuery") + proto.RegisterType((*WildcardQuery)(nil), "otsprotocol.WildcardQuery") + proto.RegisterType((*BoolQuery)(nil), "otsprotocol.BoolQuery") + proto.RegisterType((*ConstScoreQuery)(nil), "otsprotocol.ConstScoreQuery") + proto.RegisterType((*FieldValueFactor)(nil), "otsprotocol.FieldValueFactor") + proto.RegisterType((*FunctionScoreQuery)(nil), "otsprotocol.FunctionScoreQuery") + proto.RegisterType((*NestedQuery)(nil), "otsprotocol.NestedQuery") + proto.RegisterType((*GeoBoundingBoxQuery)(nil), "otsprotocol.GeoBoundingBoxQuery") + proto.RegisterType((*GeoDistanceQuery)(nil), "otsprotocol.GeoDistanceQuery") + proto.RegisterType((*GeoPolygonQuery)(nil), "otsprotocol.GeoPolygonQuery") + proto.RegisterType((*Query)(nil), "otsprotocol.Query") + proto.RegisterType((*Collapse)(nil), "otsprotocol.Collapse") + proto.RegisterType((*NestedFilter)(nil), "otsprotocol.NestedFilter") + proto.RegisterType((*ScoreSort)(nil), "otsprotocol.ScoreSort") + proto.RegisterType((*FieldSort)(nil), "otsprotocol.FieldSort") + proto.RegisterType((*GeoDistanceSort)(nil), "otsprotocol.GeoDistanceSort") + proto.RegisterType((*PrimaryKeySort)(nil), "otsprotocol.PrimaryKeySort") + proto.RegisterType((*Sorter)(nil), "otsprotocol.Sorter") + proto.RegisterType((*Sort)(nil), "otsprotocol.Sort") + proto.RegisterType((*SearchQuery)(nil), "otsprotocol.SearchQuery") + proto.RegisterType((*ColumnsToGet)(nil), "otsprotocol.ColumnsToGet") + proto.RegisterType((*SearchRequest)(nil), "otsprotocol.SearchRequest") + proto.RegisterType((*SearchResponse)(nil), "otsprotocol.SearchResponse") + proto.RegisterType((*FieldSchema)(nil), "otsprotocol.FieldSchema") + proto.RegisterType((*IndexSchema)(nil), "otsprotocol.IndexSchema") + proto.RegisterType((*IndexSetting)(nil), "otsprotocol.IndexSetting") + proto.RegisterType((*CreateSearchIndexRequest)(nil), "otsprotocol.CreateSearchIndexRequest") + proto.RegisterType((*CreateSearchIndexResponse)(nil), "otsprotocol.CreateSearchIndexResponse") + proto.RegisterType((*IndexInfo)(nil), "otsprotocol.IndexInfo") + proto.RegisterType((*ListSearchIndexRequest)(nil), "otsprotocol.ListSearchIndexRequest") + proto.RegisterType((*ListSearchIndexResponse)(nil), "otsprotocol.ListSearchIndexResponse") + proto.RegisterType((*DeleteSearchIndexRequest)(nil), "otsprotocol.DeleteSearchIndexRequest") + proto.RegisterType((*DeleteSearchIndexResponse)(nil), "otsprotocol.DeleteSearchIndexResponse") + proto.RegisterType((*SyncStat)(nil), "otsprotocol.SyncStat") + proto.RegisterType((*DescribeSearchIndexRequest)(nil), "otsprotocol.DescribeSearchIndexRequest") + proto.RegisterType((*DescribeSearchIndexResponse)(nil), "otsprotocol.DescribeSearchIndexResponse") + proto.RegisterEnum("otsprotocol.QueryType", QueryType_name, QueryType_value) + proto.RegisterEnum("otsprotocol.QueryOperator", QueryOperator_name, QueryOperator_value) + proto.RegisterEnum("otsprotocol.ScoreMode", ScoreMode_name, ScoreMode_value) + proto.RegisterEnum("otsprotocol.SortOrder", SortOrder_name, SortOrder_value) + proto.RegisterEnum("otsprotocol.SortMode", SortMode_name, SortMode_value) + proto.RegisterEnum("otsprotocol.GeoDistanceType", GeoDistanceType_name, GeoDistanceType_value) + proto.RegisterEnum("otsprotocol.ColumnReturnType", ColumnReturnType_name, ColumnReturnType_value) + proto.RegisterEnum("otsprotocol.IndexOptions", IndexOptions_name, IndexOptions_value) + proto.RegisterEnum("otsprotocol.FieldType", FieldType_name, FieldType_value) + proto.RegisterEnum("otsprotocol.SyncPhase", SyncPhase_name, SyncPhase_value) +} + +func init() { proto.RegisterFile("search.proto", fileDescriptor0) } + +var fileDescriptor0 = []byte{ + // 1930 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xa4, 0x58, 0xe9, 0x72, 0xdb, 0xd6, + 0x15, 0x0e, 0xb8, 0x89, 0x3c, 0x5c, 0x04, 0x5f, 0xcb, 0x2a, 0x6d, 0x67, 0x51, 0x91, 0xa6, 0xd1, + 0xb0, 0xae, 0xd3, 0x28, 0xe9, 0x64, 0x3a, 0xd3, 0x99, 0x94, 0x22, 0x41, 0x86, 0x13, 0x09, 0xa0, + 0x01, 0xca, 0x96, 0x7f, 0xc1, 0x30, 0x78, 0x29, 0xa2, 0x01, 0x71, 0xe9, 0x8b, 0xcb, 0xc6, 0xf4, + 0x03, 0xf4, 0x15, 0xda, 0x3f, 0x7d, 0x16, 0xff, 0xec, 0x33, 0xf4, 0x0d, 0xfa, 0x18, 0x9d, 0xbb, + 0x80, 0x3b, 0x65, 0x75, 0xf2, 0xcf, 0x38, 0xfc, 0xce, 0xf6, 0x9d, 0xe5, 0x1e, 0x0b, 0x2a, 0x09, + 0xf6, 0x69, 0x30, 0x7e, 0x3a, 0xa5, 0x84, 0x11, 0x54, 0x26, 0x2c, 0x11, 0xff, 0x0a, 0x48, 0x64, + 0xbc, 0x03, 0xb8, 0xf4, 0x59, 0x30, 0x7e, 0x36, 0xc3, 0x74, 0x8e, 0x10, 0xc0, 0x28, 0xc4, 0xd1, + 0xd0, 0x8b, 0xfd, 0x09, 0xae, 0x6b, 0x27, 0xda, 0x69, 0x09, 0x55, 0x20, 0xc7, 0xf0, 0x5b, 0x56, + 0xcf, 0x88, 0xaf, 0x8f, 0xe1, 0x68, 0x12, 0xc6, 0xe1, 0x64, 0x36, 0xf1, 0x92, 0x31, 0x99, 0x45, + 0x43, 0x6f, 0xc2, 0xd5, 0xeb, 0xd9, 0x13, 0xed, 0x34, 0x8f, 0x9e, 0x40, 0x91, 0x4c, 0x31, 0xf5, + 0x19, 0xa1, 0xf5, 0xdc, 0x89, 0x76, 0x5a, 0x3b, 0x7b, 0xf4, 0x74, 0xc5, 0xdb, 0x53, 0xe1, 0xc5, + 0x56, 0x08, 0xe3, 0x5b, 0xd0, 0x85, 0xef, 0xfe, 0x98, 0xfa, 0x09, 0xbe, 0x63, 0x04, 0xc6, 0x21, + 0x54, 0x85, 0x56, 0x33, 0x8a, 0x84, 0x8a, 0xf1, 0x7b, 0x28, 0x0d, 0x30, 0x9d, 0x7c, 0x40, 0x9f, + 0x4e, 0x84, 0x7e, 0xc5, 0xf8, 0x0a, 0x80, 0xc3, 0x93, 0xfd, 0xf8, 0x2a, 0xe4, 0x39, 0x3e, 0xa9, + 0x67, 0x4e, 0xb2, 0xa7, 0x15, 0x83, 0x01, 0x38, 0x7e, 0x7c, 0x73, 0x4b, 0x80, 0x08, 0x80, 0x72, + 0x84, 0x37, 0xa2, 0x44, 0xb9, 0x41, 0x3a, 0x14, 0xa5, 0x8c, 0x11, 0x41, 0x4e, 0x05, 0x3d, 0x80, + 0x6a, 0x18, 0x07, 0xd1, 0x6c, 0x88, 0xbd, 0x88, 0xfc, 0x8c, 0x25, 0x43, 0xc5, 0x55, 0xf1, 0x6c, + 0x3a, 0xc5, 0xb4, 0x9e, 0xe7, 0x62, 0xe3, 0x6b, 0x28, 0xf7, 0x29, 0x1e, 0x85, 0x6f, 0xf7, 0xbb, + 0xad, 0x41, 0x61, 0x2a, 0x20, 0x8a, 0x99, 0x33, 0xa8, 0xbe, 0x08, 0xa3, 0x61, 0xe0, 0xd3, 0xe1, + 0xad, 0xc9, 0xfd, 0xcd, 0x8f, 0x66, 0x58, 0xe9, 0xfc, 0x47, 0x83, 0xd2, 0x39, 0x21, 0x92, 0x4a, + 0x74, 0x0a, 0x95, 0xc9, 0x2c, 0x61, 0xde, 0x9b, 0x19, 0xa6, 0x21, 0x4e, 0xea, 0xda, 0x49, 0xf6, + 0xb4, 0x7c, 0x86, 0xb6, 0x6b, 0x88, 0x9e, 0x80, 0x2e, 0x90, 0x31, 0x59, 0xa2, 0x33, 0x7b, 0xd1, + 0x0d, 0xa8, 0x8d, 0xc2, 0x88, 0x61, 0xba, 0xc0, 0x66, 0x6f, 0xc3, 0xaa, 0xce, 0x4a, 0xb1, 0xb9, + 0xbd, 0xd8, 0x7d, 0xdd, 0xc8, 0x29, 0xcc, 0x1b, 0x7f, 0x84, 0xc3, 0x16, 0x89, 0x13, 0xe6, 0x06, + 0x84, 0xaa, 0xea, 0x19, 0x50, 0x90, 0x81, 0x08, 0x36, 0x76, 0x1a, 0x35, 0x7e, 0x0b, 0x7a, 0x87, + 0xb3, 0xf6, 0x9c, 0xd3, 0xd4, 0xf1, 0x03, 0x46, 0xe8, 0x2e, 0x26, 0x0d, 0x0a, 0xa8, 0x33, 0x8b, + 0x03, 0x16, 0x92, 0x78, 0xc5, 0xc3, 0xaf, 0x21, 0xcf, 0xe3, 0x9e, 0xef, 0x77, 0x80, 0xfe, 0x04, + 0x48, 0x1a, 0x13, 0x85, 0xf0, 0x46, 0xc2, 0x85, 0xa8, 0x47, 0xf9, 0xec, 0x93, 0x35, 0xfc, 0x66, + 0x1c, 0xc6, 0x5f, 0xa1, 0x6c, 0xe1, 0x84, 0x61, 0x55, 0xe0, 0x0a, 0xe4, 0xa6, 0x3e, 0x1b, 0xab, + 0xd2, 0x2e, 0x5c, 0x67, 0xf6, 0xba, 0x6e, 0x00, 0x24, 0x3c, 0x56, 0x6f, 0x42, 0x86, 0x58, 0xf4, + 0x65, 0xed, 0xec, 0x78, 0x0d, 0x27, 0x52, 0xb9, 0x24, 0x43, 0x6c, 0x3c, 0x83, 0xfb, 0x5d, 0x4c, + 0xce, 0xc9, 0x2c, 0x1e, 0x86, 0xf1, 0xcd, 0x39, 0xb9, 0xa5, 0x13, 0x75, 0x28, 0x32, 0x32, 0xf5, + 0x22, 0x3c, 0x4a, 0xf7, 0xc4, 0x11, 0x54, 0x5e, 0x13, 0xc6, 0xc8, 0xc4, 0xa3, 0xe1, 0xcd, 0x98, + 0x09, 0x57, 0x25, 0xc3, 0x02, 0xbd, 0x8b, 0x49, 0x3b, 0x4c, 0x98, 0x1f, 0x07, 0xb7, 0x0c, 0xd4, + 0x11, 0x54, 0x02, 0x1c, 0xf3, 0x7e, 0x99, 0x92, 0x30, 0x4e, 0x6d, 0xea, 0x50, 0x1c, 0x2a, 0x55, + 0x61, 0x4f, 0xe3, 0x15, 0xee, 0x62, 0xd2, 0x27, 0xd1, 0xfc, 0x86, 0xc4, 0xb7, 0x0f, 0x0a, 0xb7, + 0x23, 0x5b, 0xb4, 0x64, 0xfc, 0x19, 0xf2, 0x12, 0xfc, 0x1b, 0xc8, 0xb1, 0xf9, 0x54, 0xc2, 0x36, + 0x89, 0x10, 0x88, 0xc1, 0x7c, 0x8a, 0xf9, 0xc8, 0x2c, 0x79, 0xad, 0x18, 0x9f, 0x42, 0xb1, 0x45, + 0xa2, 0xc8, 0x9f, 0x26, 0x78, 0x67, 0x5f, 0xfc, 0x05, 0x2a, 0xb2, 0x46, 0x1d, 0xd1, 0x69, 0x1b, + 0x45, 0x5a, 0x76, 0xe0, 0xde, 0x2a, 0x19, 0x67, 0x50, 0x12, 0x65, 0x70, 0x09, 0x65, 0xe8, 0x0b, + 0xc8, 0x13, 0x3a, 0x54, 0x1d, 0xbb, 0x55, 0x2d, 0x42, 0x99, 0xcd, 0x7f, 0x35, 0xfe, 0xa5, 0x41, + 0x49, 0xb4, 0x8b, 0x50, 0xda, 0xc5, 0xc2, 0xc2, 0x50, 0xe6, 0x36, 0x43, 0xe8, 0x73, 0xc8, 0xad, + 0x34, 0xc7, 0x83, 0x2d, 0x14, 0xef, 0x0d, 0xf4, 0x07, 0xa8, 0xc6, 0x22, 0x47, 0x4f, 0x25, 0x93, + 0x13, 0xc9, 0x3c, 0x5c, 0x43, 0xaf, 0xb2, 0x60, 0xfc, 0x57, 0x13, 0xb5, 0x4a, 0x6b, 0xbf, 0x37, + 0xca, 0x8d, 0x5a, 0x2d, 0xa3, 0xce, 0xde, 0x29, 0xea, 0xdc, 0x6d, 0x51, 0x7f, 0x03, 0xd5, 0xb4, + 0x81, 0x3c, 0x51, 0xf7, 0xbc, 0x40, 0x7f, 0xbc, 0x86, 0x5e, 0x09, 0x52, 0x54, 0x7f, 0x2b, 0xd5, + 0xc2, 0x87, 0x52, 0xfd, 0x0e, 0x6a, 0x7d, 0x1a, 0x4e, 0x7c, 0x3a, 0xff, 0x11, 0xcf, 0xff, 0x9f, + 0x1a, 0xfe, 0x5b, 0x83, 0x02, 0xff, 0xc2, 0x94, 0x0f, 0xaa, 0xa4, 0x26, 0x21, 0x94, 0xa9, 0x5d, + 0x72, 0xbc, 0xbd, 0x1b, 0x84, 0xf5, 0xef, 0xe0, 0xde, 0x0d, 0x26, 0xde, 0x22, 0x35, 0xa1, 0x22, + 0xbb, 0x6b, 0x6f, 0x6a, 0x42, 0x71, 0xb1, 0x0d, 0x84, 0x46, 0x76, 0x87, 0x93, 0x65, 0x1b, 0x3e, + 0x81, 0x83, 0xe9, 0x4f, 0x12, 0x28, 0x6b, 0xfd, 0x78, 0x0d, 0xb8, 0x9e, 0xb0, 0xf1, 0x3b, 0xc8, + 0x09, 0xad, 0xcf, 0xa1, 0x90, 0x88, 0x84, 0xd4, 0x53, 0x72, 0x7f, 0x2b, 0x73, 0x4c, 0x8d, 0xf7, + 0x1a, 0x94, 0x5d, 0x71, 0xa1, 0xc8, 0xa9, 0xac, 0x41, 0x81, 0x8c, 0x46, 0x09, 0x96, 0x79, 0xe7, + 0xf9, 0xfc, 0x45, 0xe1, 0x24, 0x94, 0x39, 0xe5, 0x97, 0x6b, 0x2e, 0xb7, 0x77, 0xcd, 0x7d, 0x09, + 0xc5, 0x40, 0x8d, 0xa8, 0xa8, 0x71, 0x79, 0xa3, 0x23, 0x16, 0xf3, 0xfb, 0x19, 0xe4, 0x44, 0x4a, + 0xb2, 0xa6, 0xf7, 0xb6, 0xa2, 0xe3, 0xaf, 0xf3, 0x0d, 0x66, 0x03, 0xc2, 0xfc, 0xa8, 0x45, 0x66, + 0x31, 0xab, 0x17, 0xc5, 0xa3, 0xcd, 0x4f, 0x04, 0xf2, 0x13, 0x8e, 0xeb, 0x25, 0xb1, 0x12, 0xae, + 0xa1, 0xd2, 0x22, 0xd1, 0x6c, 0x12, 0x27, 0x03, 0xd2, 0xc5, 0x0c, 0x9d, 0x41, 0x99, 0x62, 0x36, + 0xa3, 0xb1, 0xb7, 0xb2, 0x5e, 0x3e, 0xd9, 0x0c, 0x61, 0x36, 0x89, 0x1d, 0x81, 0x12, 0x7d, 0xc6, + 0x77, 0x9e, 0x90, 0x89, 0x69, 0x48, 0x57, 0xd5, 0x3f, 0x35, 0xa8, 0x4a, 0x6e, 0x1c, 0xfc, 0x66, + 0x86, 0x13, 0x31, 0x34, 0xcc, 0x7f, 0x1d, 0xe1, 0x8d, 0x03, 0x24, 0x8c, 0x87, 0xf8, 0xad, 0x94, + 0xc9, 0x6d, 0xf9, 0x35, 0xd4, 0xa4, 0xbd, 0xc4, 0x63, 0xc4, 0xbb, 0xc1, 0x69, 0x81, 0x1f, 0xee, + 0x08, 0x43, 0x85, 0x7d, 0x94, 0x5e, 0x8a, 0xde, 0x92, 0xe0, 0x0a, 0x3a, 0x86, 0x1a, 0x25, 0x33, + 0x16, 0xc6, 0x37, 0xf2, 0xc1, 0x4a, 0xea, 0x79, 0x71, 0x17, 0xbd, 0x82, 0x5a, 0x1a, 0x59, 0x32, + 0x25, 0xb1, 0xdc, 0x86, 0x8c, 0x33, 0xe5, 0x8d, 0x43, 0x96, 0x88, 0xd0, 0xb2, 0x7c, 0xfb, 0x51, + 0xf2, 0xb3, 0xba, 0xa5, 0x50, 0x1d, 0xf4, 0x30, 0xf1, 0xfc, 0x28, 0xf2, 0x92, 0x59, 0x10, 0x60, + 0x3c, 0xc4, 0x43, 0x11, 0x56, 0x91, 0xeb, 0xc6, 0xf8, 0x2d, 0xf3, 0x24, 0xad, 0x05, 0x41, 0xeb, + 0xdf, 0x33, 0x50, 0x96, 0x6d, 0x1e, 0x8c, 0xf1, 0xc4, 0xdf, 0xb9, 0x2f, 0x16, 0x83, 0x22, 0x98, + 0xde, 0xb5, 0xda, 0x84, 0x85, 0x74, 0x94, 0x25, 0x4d, 0x64, 0xca, 0x5f, 0xed, 0x44, 0xed, 0x94, + 0x75, 0x46, 0x7a, 0x1c, 0x61, 0x4b, 0x00, 0x7f, 0x72, 0xfc, 0xd8, 0x8f, 0xe6, 0xef, 0xd4, 0x8a, + 0x13, 0xf7, 0x93, 0xb0, 0x21, 0xcf, 0x34, 0x1e, 0xd2, 0x90, 0x04, 0x29, 0x31, 0x85, 0xb4, 0x39, + 0x12, 0x46, 0x28, 0xae, 0x1f, 0x88, 0xcf, 0xaf, 0xa0, 0xaa, 0x46, 0x59, 0x64, 0x91, 0xd4, 0x8b, + 0x62, 0x14, 0xea, 0x3b, 0xa6, 0x59, 0xa6, 0xa9, 0x43, 0x91, 0x93, 0x44, 0xa9, 0x3f, 0x17, 0xfd, + 0x55, 0x34, 0xfe, 0xa1, 0x41, 0x59, 0xc4, 0xa5, 0x10, 0x5b, 0x26, 0xb5, 0x0f, 0x98, 0x5c, 0x64, + 0x9e, 0x60, 0xc6, 0x2b, 0xa9, 0xd6, 0xc3, 0x8e, 0xcc, 0x5d, 0x09, 0x40, 0x5f, 0xa4, 0x2d, 0xb5, + 0xb2, 0x1b, 0xb6, 0xe7, 0xc3, 0x78, 0x05, 0x95, 0x35, 0xb5, 0x3a, 0xe8, 0xf1, 0x6c, 0xf2, 0x1a, + 0x53, 0x8f, 0x8c, 0xbc, 0x64, 0xec, 0xd3, 0x61, 0xa2, 0xa6, 0x78, 0xa5, 0x8d, 0x44, 0xec, 0xe9, + 0x82, 0xff, 0x14, 0x8e, 0x53, 0xf9, 0xd4, 0xa7, 0x2c, 0xe4, 0xc4, 0x7b, 0x49, 0xf8, 0x4e, 0xbe, + 0x40, 0x79, 0x23, 0x82, 0x7a, 0x8b, 0x62, 0x9f, 0x61, 0xd9, 0x6c, 0xc2, 0xdb, 0xbe, 0x59, 0xc8, + 0xec, 0x98, 0x05, 0x2e, 0x3b, 0x85, 0x82, 0x64, 0x4a, 0x25, 0x52, 0xdf, 0x91, 0xb7, 0xf8, 0xdd, + 0x78, 0x0c, 0x0f, 0x77, 0x78, 0x93, 0xfd, 0x6d, 0x7c, 0x03, 0x25, 0x21, 0xe8, 0xc5, 0x23, 0x72, + 0xd7, 0x39, 0x34, 0x9e, 0xc0, 0xf1, 0x45, 0x98, 0xb0, 0x3b, 0x44, 0xcf, 0xd1, 0xe7, 0xf0, 0xab, + 0x2d, 0xb4, 0x9a, 0xae, 0x2f, 0xe1, 0x20, 0x8c, 0x87, 0x61, 0xb0, 0xb8, 0xcb, 0x8f, 0xb7, 0xb3, + 0xe0, 0x91, 0x19, 0xe7, 0x50, 0x6f, 0xe3, 0x08, 0xdf, 0x89, 0xb1, 0x7d, 0x51, 0x3f, 0x86, 0x87, + 0x3b, 0x6c, 0x28, 0x1e, 0x9e, 0x43, 0xd1, 0x9d, 0xc7, 0x81, 0xcb, 0x7c, 0xf9, 0x86, 0xcc, 0xe3, + 0xc0, 0x9b, 0x8e, 0xfd, 0x64, 0xf7, 0x21, 0xc5, 0xa1, 0x7d, 0xfe, 0x2b, 0x2f, 0x75, 0x30, 0xa3, + 0x14, 0xc7, 0xcc, 0x13, 0x3a, 0x2c, 0x9c, 0xe0, 0x84, 0xf9, 0x93, 0xa9, 0x70, 0x9a, 0x35, 0xda, + 0xf0, 0xa8, 0x8d, 0x93, 0x80, 0x86, 0xaf, 0x7f, 0x49, 0xe8, 0x6f, 0xe0, 0xf1, 0x4e, 0x2b, 0x8a, + 0xc6, 0x65, 0x2f, 0x68, 0xb7, 0xf7, 0x02, 0x3a, 0x85, 0x92, 0x08, 0x33, 0x61, 0x7e, 0xfa, 0x9e, + 0x3e, 0xd8, 0xca, 0x8c, 0x93, 0xd0, 0x78, 0x9f, 0x81, 0xd2, 0xf2, 0x5e, 0x3c, 0x84, 0xf2, 0x65, + 0x73, 0xd0, 0xfa, 0xc1, 0x7b, 0x76, 0x65, 0x3a, 0x2f, 0x75, 0x0d, 0x1d, 0x03, 0x92, 0x82, 0xfe, + 0x0f, 0x4e, 0xd3, 0x35, 0x95, 0x3c, 0x83, 0x6a, 0x00, 0x03, 0xd3, 0xb9, 0x54, 0xdf, 0x59, 0xae, + 0xe8, 0x34, 0xad, 0x6e, 0x0a, 0xc8, 0x21, 0x1d, 0x2a, 0x7d, 0xc7, 0xec, 0xf4, 0xae, 0x95, 0x24, + 0xcf, 0x55, 0xce, 0x6d, 0xfb, 0x42, 0x7d, 0x17, 0xd0, 0x03, 0xb8, 0xd7, 0xb2, 0x2d, 0x77, 0xe0, + 0xb9, 0x2d, 0xdb, 0x49, 0x15, 0x0f, 0x50, 0x1d, 0x8e, 0x3a, 0x57, 0x56, 0x6b, 0xd0, 0xb3, 0xad, + 0xb5, 0x5f, 0x8a, 0xdc, 0xa4, 0x65, 0xba, 0x03, 0xb3, 0xad, 0x24, 0x9c, 0xc3, 0xda, 0x8b, 0xde, + 0x45, 0xbb, 0xd5, 0x74, 0x52, 0x19, 0xa0, 0xfb, 0x70, 0x28, 0x23, 0x6e, 0x5e, 0xa4, 0xbe, 0xca, + 0xe8, 0x11, 0x1c, 0x77, 0x4d, 0xdb, 0x3b, 0xb7, 0xaf, 0xac, 0x76, 0xcf, 0xea, 0x7a, 0xe7, 0x76, + 0x1a, 0x17, 0x7f, 0x24, 0x10, 0xff, 0xad, 0xdd, 0x73, 0x07, 0x4d, 0xab, 0x95, 0xba, 0xab, 0xf2, + 0xf8, 0xb8, 0xbc, 0x6f, 0x5f, 0xbc, 0xec, 0xda, 0x96, 0x12, 0xd7, 0x78, 0xa6, 0x3c, 0x73, 0x57, + 0x09, 0x0e, 0x1b, 0x27, 0x50, 0x5d, 0xfb, 0xe3, 0x00, 0x2a, 0x40, 0xc6, 0x76, 0x74, 0x0d, 0x1d, + 0x40, 0xb6, 0x69, 0xb5, 0xf5, 0x4c, 0x83, 0xaa, 0xa3, 0x58, 0x5c, 0x72, 0xf7, 0xe1, 0x50, 0xa6, + 0x75, 0x69, 0xb7, 0x4d, 0xcf, 0xb2, 0x2d, 0x53, 0xd7, 0x78, 0x22, 0x2b, 0xc2, 0xe6, 0xf3, 0xae, + 0x9e, 0xd9, 0x90, 0x5d, 0x36, 0xaf, 0xf5, 0x2c, 0x3a, 0x02, 0x7d, 0x45, 0x36, 0xb0, 0x07, 0xcd, + 0x0b, 0x3d, 0xb7, 0x89, 0xec, 0x59, 0x7a, 0xbe, 0xf1, 0x2d, 0x94, 0x96, 0x27, 0x26, 0x07, 0xd8, + 0xce, 0xc0, 0xb3, 0x9d, 0xb6, 0xe9, 0x78, 0x4d, 0xb7, 0xa5, 0x7f, 0x24, 0xe2, 0x58, 0xca, 0xda, + 0xa6, 0xdb, 0xd2, 0xb5, 0x46, 0x0b, 0x8a, 0x8b, 0x93, 0xf3, 0x1e, 0x54, 0x05, 0x60, 0x61, 0xf4, + 0xa3, 0x0d, 0x51, 0xf3, 0x5a, 0xd7, 0xd6, 0x45, 0x22, 0xf0, 0xc6, 0xf7, 0x6b, 0xe7, 0xb2, 0xba, + 0x10, 0xf4, 0x35, 0x8e, 0x9b, 0x0e, 0x0f, 0x61, 0x93, 0xf9, 0xfe, 0x45, 0x93, 0xb3, 0xd1, 0xe8, + 0x81, 0xbe, 0x75, 0x63, 0xd4, 0x00, 0x1c, 0x73, 0x70, 0xe5, 0x58, 0xbc, 0xae, 0xba, 0xc6, 0x2d, + 0xaa, 0x6f, 0xb7, 0x6f, 0xb6, 0x7a, 0x9d, 0x9e, 0xd9, 0xd6, 0x33, 0xa2, 0x0d, 0xa5, 0x54, 0x10, + 0x9b, 0x6d, 0x7c, 0xaf, 0x96, 0x7c, 0xfa, 0x2a, 0x16, 0x21, 0xd7, 0xb6, 0x5b, 0xae, 0xae, 0xa1, + 0x12, 0xe4, 0x3b, 0x8e, 0xf9, 0xcc, 0xd5, 0x33, 0xa8, 0x0a, 0xa5, 0xbe, 0xed, 0xf6, 0x78, 0xcb, + 0xb9, 0x7a, 0x16, 0x95, 0xe1, 0xc0, 0xee, 0x74, 0x5c, 0x73, 0xe0, 0xea, 0xb9, 0xc6, 0x2b, 0xf5, + 0x7f, 0x13, 0x11, 0x44, 0x11, 0x72, 0x17, 0xb6, 0xd5, 0xd5, 0x35, 0x04, 0x50, 0x68, 0xdb, 0x57, + 0xe7, 0x17, 0xa6, 0x9e, 0xe1, 0x78, 0xde, 0xd8, 0x66, 0xd3, 0x92, 0xca, 0x3f, 0x9a, 0x2f, 0x5f, + 0xd8, 0x4e, 0x5b, 0xcf, 0x71, 0xfc, 0xc0, 0xbc, 0x1e, 0xe8, 0x79, 0x8e, 0x97, 0xbd, 0xab, 0x17, + 0xb8, 0x3b, 0xd9, 0x58, 0x3d, 0x6b, 0xa0, 0x1f, 0x34, 0x3e, 0x83, 0xd2, 0x72, 0xcf, 0x14, 0x21, + 0xd7, 0xb9, 0x12, 0x09, 0x16, 0x21, 0xd7, 0xb3, 0x5a, 0x8e, 0x9e, 0xf9, 0x5f, 0x00, 0x00, 0x00, + 0xff, 0xff, 0xe6, 0x50, 0x1e, 0x93, 0x04, 0x13, 0x00, 0x00, +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/search.proto b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/search.proto new file mode 100644 index 000000000000..0a6613203885 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/search.proto @@ -0,0 +1,323 @@ +syntax = "proto2"; +package otsprotocol; + +enum QueryType { + MATCH_QUERY = 1; + MATCH_PHRASE_QUERY = 2; + TERM_QUERY = 3; + RANGE_QUERY = 4; + PREFIX_QUERY = 5; + BOOL_QUERY = 6; + CONST_SCORE_QUERY = 7; + FUNCTION_SCORE_QUERY = 8; + NESTED_QUERY = 9; + WILDCARD_QUERY = 10; + MATCH_ALL_QUERY = 11; + GEO_BOUNDING_BOX_QUERY = 12; + GEO_DISTANCE_QUERY = 13; + GEO_POLYGON_QUERY = 14; + TERMS_QUERY = 15; +} + +enum QueryOperator { + OR = 1; + AND = 2; +} + +message MatchQuery { + optional string field_name = 1; + optional string text = 2; + optional int32 minimum_should_match = 3; + optional QueryOperator operator = 4; +} + +message MatchPhraseQuery { + optional string field_name = 1; + optional string text = 2; +} + +message MatchAllQuery { +} + +message TermQuery { + optional string field_name = 1; + optional bytes term = 2; +} + +message TermsQuery { + optional string field_name = 1; + repeated bytes terms = 2; +} + +message RangeQuery { + optional string field_name = 1; + optional bytes range_from = 2; // variant value + optional bytes range_to = 3; // variant value + optional bool include_lower = 4; + optional bool include_upper = 5; +} + +message PrefixQuery { + optional string field_name = 1; + optional string prefix = 2; +} + +message WildcardQuery { + optional string field_name = 1; + optional string value = 2; +} + +message BoolQuery { + repeated Query must_queries = 1; + repeated Query must_not_queries = 2; + repeated Query filter_queries = 3; + repeated Query should_queries = 4; + optional int32 minimum_should_match = 5; +} + +message ConstScoreQuery { + optional Query filter = 1; +} + +message FieldValueFactor { + optional string field_name = 1; +} + +message FunctionScoreQuery { + optional Query query = 1; + optional FieldValueFactor field_value_factor = 2; +} + +enum ScoreMode { + SCORE_MODE_NONE = 1; + SCORE_MODE_AVG = 2; + SCORE_MODE_MAX = 3; + SCORE_MODE_TOTAL = 4; + SCORE_MODE_MIN = 5; +} + +message NestedQuery { + optional string path = 1; + optional Query query = 2; + optional ScoreMode score_mode = 3; +} + +message GeoBoundingBoxQuery { + optional string field_name = 1; + optional string top_left = 2; + optional string bottom_right = 3; +} + +message GeoDistanceQuery { + optional string field_name = 1; + optional string center_point = 2; + optional double distance = 3; +} + +message GeoPolygonQuery { + optional string field_name = 1; + repeated string points = 2; +} + +message Query { + optional QueryType type = 1; + optional bytes query = 2; +} + +message Collapse { + optional string field_name = 1; +} + +message NestedFilter { + optional string path = 1; + optional Query filter = 2; +} + +enum SortOrder { + SORT_ORDER_ASC = 0; + SORT_ORDER_DESC = 1; +} + +enum SortMode { + SORT_MODE_MIN = 0; + SORT_MODE_MAX = 1; + SORT_MODE_AVG = 2; +} + +message ScoreSort { + optional SortOrder order = 1; +} + +message FieldSort { + optional string field_name = 1; + optional SortOrder order = 2; + optional SortMode mode = 3; + optional NestedFilter nested_filter = 4; +} + +enum GeoDistanceType { + GEO_DISTANCE_ARC = 0; + GEO_DISTANCE_PLANE = 1; +} + +message GeoDistanceSort { + optional string field_name = 1; + repeated string points = 2; + optional SortOrder order = 3; + optional SortMode mode = 4; + optional GeoDistanceType distance_type = 5; + optional NestedFilter nested_filter = 6; +} + +message PrimaryKeySort { + optional SortOrder order = 1; +} + +message Sorter { + optional FieldSort field_sort = 1; + optional GeoDistanceSort geo_distance_sort = 2; + optional ScoreSort score_sort = 3; + optional PrimaryKeySort pk_sort = 4; +} + +message Sort { + repeated Sorter sorter = 1; +} + +message SearchQuery { + optional int32 offset = 1; + optional int32 limit = 2; + optional Query query = 4; + optional Collapse collapse = 5; + optional Sort sort = 6; + optional bool getTotalCount = 8; + optional bytes token = 9; +} + +enum ColumnReturnType { + RETURN_ALL = 1; + RETURN_SPECIFIED = 2; + RETURN_NONE = 3; +} + +message ColumnsToGet { + optional ColumnReturnType return_type = 1; + repeated string column_names = 2; +} + +message SearchRequest { + optional string table_name = 1; + optional string index_name = 2; + optional ColumnsToGet columns_to_get = 3; + optional bytes search_query = 4; + repeated bytes routing_values = 5; +} + +/** + * Response部分： + **/ + +message SearchResponse { + optional int64 total_hits = 1; + repeated bytes rows = 2; + optional bool is_all_succeeded = 3; + optional bytes next_token = 6; +} + +/* Create Search Index */ + +enum IndexOptions { + DOCS = 1; + FREQS = 2; + POSITIONS = 3; + OFFSETS = 4; +} + +enum FieldType { + LONG = 1; + DOUBLE = 2; + BOOLEAN = 3; + KEYWORD = 4; + TEXT = 5; + NESTED = 6; + GEO_POINT = 7; +} + +message FieldSchema { + optional string field_name = 1; + optional FieldType field_type = 2; + optional IndexOptions index_options = 3; + optional string analyzer = 4; + optional bool index = 5; + optional bool doc_values = 6; + optional bool store = 7; + repeated FieldSchema field_schemas = 8; // only for nested type + optional bool is_array = 9; +} + +message IndexSchema { + repeated FieldSchema field_schemas = 1; + optional IndexSetting index_setting = 2; + optional Sort index_sort = 3; +} + +message IndexSetting { + optional int32 number_of_shards = 1; + repeated string routing_fields = 2; + optional int32 routing_partition_size = 3; +} + +message CreateSearchIndexRequest { + required string table_name = 1; + required string index_name = 2; + optional IndexSchema schema = 3; +} + +message CreateSearchIndexResponse { +} + +/* List Search Index */ + +message IndexInfo { + optional string table_name = 1; + optional string index_name = 2; +} + +message ListSearchIndexRequest { + optional string table_name = 1; +} +message ListSearchIndexResponse { + repeated IndexInfo indices = 1; +} + +/* Delete Search Index */ + +message DeleteSearchIndexRequest { + optional string table_name = 1; + optional string index_name = 2; +} + +message DeleteSearchIndexResponse { +} + +/* Describe Search Index */ + +enum SyncPhase { + FULL = 1; + INCR = 2; +} + +message SyncStat { + optional SyncPhase sync_phase = 1; + optional int64 current_sync_timestamp = 2; // 同步进度，参考TunnelService。 +} + +message DescribeSearchIndexRequest { + optional string table_name = 1; + optional string index_name = 2; +} + +message DescribeSearchIndexResponse { + optional IndexSchema schema = 1; + optional SyncStat sync_stat = 2; +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/table_store.pb.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/table_store.pb.go new file mode 100644 index 000000000000..de5d507d13b6 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/table_store.pb.go @@ -0,0 +1,3141 @@ +// Code generated by protoc-gen-go. +// source: table_store.proto +// DO NOT EDIT! + +package otsprotocol + +import proto "github.com/golang/protobuf/proto" +import fmt "fmt" +import math "math" + +// Reference imports to suppress errors if they are not otherwise used. +var _ = proto.Marshal +var _ = fmt.Errorf +var _ = math.Inf + +type PrimaryKeyType int32 + +const ( + PrimaryKeyType_INTEGER PrimaryKeyType = 1 + PrimaryKeyType_STRING PrimaryKeyType = 2 + PrimaryKeyType_BINARY PrimaryKeyType = 3 +) + +var PrimaryKeyType_name = map[int32]string{ + 1: "INTEGER", + 2: "STRING", + 3: "BINARY", +} +var PrimaryKeyType_value = map[string]int32{ + "INTEGER": 1, + "STRING": 2, + "BINARY": 3, +} + +func (x PrimaryKeyType) Enum() *PrimaryKeyType { + p := new(PrimaryKeyType) + *p = x + return p +} +func (x PrimaryKeyType) String() string { + return proto.EnumName(PrimaryKeyType_name, int32(x)) +} +func (x *PrimaryKeyType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(PrimaryKeyType_value, data, "PrimaryKeyType") + if err != nil { + return err + } + *x = PrimaryKeyType(value) + return nil +} +func (PrimaryKeyType) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{0} } + +type PrimaryKeyOption int32 + +const ( + PrimaryKeyOption_AUTO_INCREMENT PrimaryKeyOption = 1 +) + +var PrimaryKeyOption_name = map[int32]string{ + 1: "AUTO_INCREMENT", +} +var PrimaryKeyOption_value = map[string]int32{ + "AUTO_INCREMENT": 1, +} + +func (x PrimaryKeyOption) Enum() *PrimaryKeyOption { + p := new(PrimaryKeyOption) + *p = x + return p +} +func (x PrimaryKeyOption) String() string { + return proto.EnumName(PrimaryKeyOption_name, int32(x)) +} +func (x *PrimaryKeyOption) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(PrimaryKeyOption_value, data, "PrimaryKeyOption") + if err != nil { + return err + } + *x = PrimaryKeyOption(value) + return nil +} +func (PrimaryKeyOption) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{1} } + +type BloomFilterType int32 + +const ( + BloomFilterType_NONE BloomFilterType = 1 + BloomFilterType_CELL BloomFilterType = 2 + BloomFilterType_ROW BloomFilterType = 3 +) + +var BloomFilterType_name = map[int32]string{ + 1: "NONE", + 2: "CELL", + 3: "ROW", +} +var BloomFilterType_value = map[string]int32{ + "NONE": 1, + "CELL": 2, + "ROW": 3, +} + +func (x BloomFilterType) Enum() *BloomFilterType { + p := new(BloomFilterType) + *p = x + return p +} +func (x BloomFilterType) String() string { + return proto.EnumName(BloomFilterType_name, int32(x)) +} +func (x *BloomFilterType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(BloomFilterType_value, data, "BloomFilterType") + if err != nil { + return err + } + *x = BloomFilterType(value) + return nil +} +func (BloomFilterType) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{2} } + +// * +// 表的状态变更只与用户的操作对应，内部的机器failover等状况不对应表的状态变更。 +// 有三个考虑： +// 一是一般场景下用户只会在做了对表的修改操作后才会去检查表的状态； +// 二是内部机器failover导致访问异常到用户能够查看到表的状态变更这两个时刻之间会有一段延迟，无法将表的不可服务状态与用户查看到的表的状态完全匹配上。 +// 三是内部机器failover后不能说是表的整个状态变更，而应该是partition的状态变更，对应表的状态就是PARTIAL_FAILOVER，这个partial的粒度无法体现，会让用户更加困惑。 +type TableStatus int32 + +const ( + TableStatus_ACTIVE TableStatus = 1 + TableStatus_INACTIVE TableStatus = 2 + TableStatus_LOADING TableStatus = 3 + TableStatus_UNLOADING TableStatus = 4 + TableStatus_UPDATING TableStatus = 5 +) + +var TableStatus_name = map[int32]string{ + 1: "ACTIVE", + 2: "INACTIVE", + 3: "LOADING", + 4: "UNLOADING", + 5: "UPDATING", +} +var TableStatus_value = map[string]int32{ + "ACTIVE": 1, + "INACTIVE": 2, + "LOADING": 3, + "UNLOADING": 4, + "UPDATING": 5, +} + +func (x TableStatus) Enum() *TableStatus { + p := new(TableStatus) + *p = x + return p +} +func (x TableStatus) String() string { + return proto.EnumName(TableStatus_name, int32(x)) +} +func (x *TableStatus) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(TableStatus_value, data, "TableStatus") + if err != nil { + return err + } + *x = TableStatus(value) + return nil +} +func (TableStatus) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{3} } + +type RowExistenceExpectation int32 + +const ( + RowExistenceExpectation_IGNORE RowExistenceExpectation = 0 + RowExistenceExpectation_EXPECT_EXIST RowExistenceExpectation = 1 + RowExistenceExpectation_EXPECT_NOT_EXIST RowExistenceExpectation = 2 +) + +var RowExistenceExpectation_name = map[int32]string{ + 0: "IGNORE", + 1: "EXPECT_EXIST", + 2: "EXPECT_NOT_EXIST", +} +var RowExistenceExpectation_value = map[string]int32{ + "IGNORE": 0, + "EXPECT_EXIST": 1, + "EXPECT_NOT_EXIST": 2, +} + +func (x RowExistenceExpectation) Enum() *RowExistenceExpectation { + p := new(RowExistenceExpectation) + *p = x + return p +} +func (x RowExistenceExpectation) String() string { + return proto.EnumName(RowExistenceExpectation_name, int32(x)) +} +func (x *RowExistenceExpectation) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(RowExistenceExpectation_value, data, "RowExistenceExpectation") + if err != nil { + return err + } + *x = RowExistenceExpectation(value) + return nil +} +func (RowExistenceExpectation) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{4} } + +type ReturnType int32 + +const ( + ReturnType_RT_NONE ReturnType = 0 + ReturnType_RT_PK ReturnType = 1 + ReturnType_RT_AFTER_MODIFY ReturnType = 2 +) + +var ReturnType_name = map[int32]string{ + 0: "RT_NONE", + 1: "RT_PK", + 2: "RT_AFTER_MODIFY", +} +var ReturnType_value = map[string]int32{ + "RT_NONE": 0, + "RT_PK": 1, + "RT_AFTER_MODIFY": 2, +} + +func (x ReturnType) Enum() *ReturnType { + p := new(ReturnType) + *p = x + return p +} +func (x ReturnType) String() string { + return proto.EnumName(ReturnType_name, int32(x)) +} +func (x *ReturnType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ReturnType_value, data, "ReturnType") + if err != nil { + return err + } + *x = ReturnType(value) + return nil +} +func (ReturnType) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{5} } + +type OperationType int32 + +const ( + OperationType_PUT OperationType = 1 + OperationType_UPDATE OperationType = 2 + OperationType_DELETE OperationType = 3 +) + +var OperationType_name = map[int32]string{ + 1: "PUT", + 2: "UPDATE", + 3: "DELETE", +} +var OperationType_value = map[string]int32{ + "PUT": 1, + "UPDATE": 2, + "DELETE": 3, +} + +func (x OperationType) Enum() *OperationType { + p := new(OperationType) + *p = x + return p +} +func (x OperationType) String() string { + return proto.EnumName(OperationType_name, int32(x)) +} +func (x *OperationType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(OperationType_value, data, "OperationType") + if err != nil { + return err + } + *x = OperationType(value) + return nil +} +func (OperationType) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{6} } + +// ############################################# GetRange ############################################# +type Direction int32 + +const ( + Direction_FORWARD Direction = 0 + Direction_BACKWARD Direction = 1 +) + +var Direction_name = map[int32]string{ + 0: "FORWARD", + 1: "BACKWARD", +} +var Direction_value = map[string]int32{ + "FORWARD": 0, + "BACKWARD": 1, +} + +func (x Direction) Enum() *Direction { + p := new(Direction) + *p = x + return p +} +func (x Direction) String() string { + return proto.EnumName(Direction_name, int32(x)) +} +func (x *Direction) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(Direction_value, data, "Direction") + if err != nil { + return err + } + *x = Direction(value) + return nil +} +func (Direction) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{7} } + +type StreamStatus int32 + +const ( + StreamStatus_STREAM_ENABLING StreamStatus = 1 + StreamStatus_STREAM_ACTIVE StreamStatus = 2 +) + +var StreamStatus_name = map[int32]string{ + 1: "STREAM_ENABLING", + 2: "STREAM_ACTIVE", +} +var StreamStatus_value = map[string]int32{ + "STREAM_ENABLING": 1, + "STREAM_ACTIVE": 2, +} + +func (x StreamStatus) Enum() *StreamStatus { + p := new(StreamStatus) + *p = x + return p +} +func (x StreamStatus) String() string { + return proto.EnumName(StreamStatus_name, int32(x)) +} +func (x *StreamStatus) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(StreamStatus_value, data, "StreamStatus") + if err != nil { + return err + } + *x = StreamStatus(value) + return nil +} +func (StreamStatus) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{8} } + +type ActionType int32 + +const ( + ActionType_PUT_ROW ActionType = 1 + ActionType_UPDATE_ROW ActionType = 2 + ActionType_DELETE_ROW ActionType = 3 +) + +var ActionType_name = map[int32]string{ + 1: "PUT_ROW", + 2: "UPDATE_ROW", + 3: "DELETE_ROW", +} +var ActionType_value = map[string]int32{ + "PUT_ROW": 1, + "UPDATE_ROW": 2, + "DELETE_ROW": 3, +} + +func (x ActionType) Enum() *ActionType { + p := new(ActionType) + *p = x + return p +} +func (x ActionType) String() string { + return proto.EnumName(ActionType_name, int32(x)) +} +func (x *ActionType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(ActionType_value, data, "ActionType") + if err != nil { + return err + } + *x = ActionType(value) + return nil +} +func (ActionType) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{9} } + +type DefinedColumnType int32 + +const ( + DefinedColumnType_DCT_INTEGER DefinedColumnType = 1 + DefinedColumnType_DCT_DOUBLE DefinedColumnType = 2 + DefinedColumnType_DCT_BOOLEAN DefinedColumnType = 3 + DefinedColumnType_DCT_STRING DefinedColumnType = 4 + // field 5 is reserved for date type, not supported yet + // field 6 is reserved for decimal type, not supported yet + DefinedColumnType_DCT_BLOB DefinedColumnType = 7 +) + +var DefinedColumnType_name = map[int32]string{ + 1: "DCT_INTEGER", + 2: "DCT_DOUBLE", + 3: "DCT_BOOLEAN", + 4: "DCT_STRING", + 7: "DCT_BLOB", +} +var DefinedColumnType_value = map[string]int32{ + "DCT_INTEGER": 1, + "DCT_DOUBLE": 2, + "DCT_BOOLEAN": 3, + "DCT_STRING": 4, + "DCT_BLOB": 7, +} + +func (x DefinedColumnType) Enum() *DefinedColumnType { + p := new(DefinedColumnType) + *p = x + return p +} +func (x DefinedColumnType) String() string { + return proto.EnumName(DefinedColumnType_name, int32(x)) +} +func (x *DefinedColumnType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(DefinedColumnType_value, data, "DefinedColumnType") + if err != nil { + return err + } + *x = DefinedColumnType(value) + return nil +} +func (DefinedColumnType) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{10} } + +type IndexUpdateMode int32 + +const ( + IndexUpdateMode_IUM_ASYNC_INDEX IndexUpdateMode = 0 + IndexUpdateMode_IUM_SYNC_INDEX IndexUpdateMode = 1 +) + +var IndexUpdateMode_name = map[int32]string{ + 0: "IUM_ASYNC_INDEX", + 1: "IUM_SYNC_INDEX", +} +var IndexUpdateMode_value = map[string]int32{ + "IUM_ASYNC_INDEX": 0, + "IUM_SYNC_INDEX": 1, +} + +func (x IndexUpdateMode) Enum() *IndexUpdateMode { + p := new(IndexUpdateMode) + *p = x + return p +} +func (x IndexUpdateMode) String() string { + return proto.EnumName(IndexUpdateMode_name, int32(x)) +} +func (x *IndexUpdateMode) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(IndexUpdateMode_value, data, "IndexUpdateMode") + if err != nil { + return err + } + *x = IndexUpdateMode(value) + return nil +} +func (IndexUpdateMode) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{11} } + +type IndexType int32 + +const ( + IndexType_IT_GLOBAL_INDEX IndexType = 0 + IndexType_IT_LOCAL_INDEX IndexType = 1 +) + +var IndexType_name = map[int32]string{ + 0: "IT_GLOBAL_INDEX", + 1: "IT_LOCAL_INDEX", +} +var IndexType_value = map[string]int32{ + "IT_GLOBAL_INDEX": 0, + "IT_LOCAL_INDEX": 1, +} + +func (x IndexType) Enum() *IndexType { + p := new(IndexType) + *p = x + return p +} +func (x IndexType) String() string { + return proto.EnumName(IndexType_name, int32(x)) +} +func (x *IndexType) UnmarshalJSON(data []byte) error { + value, err := proto.UnmarshalJSONEnum(IndexType_value, data, "IndexType") + if err != nil { + return err + } + *x = IndexType(value) + return nil +} +func (IndexType) EnumDescriptor() ([]byte, []int) { return fileDescriptor2, []int{12} } + +type Error struct { + Code *string `protobuf:"bytes,1,req,name=code" json:"code,omitempty"` + Message *string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Error) Reset() { *m = Error{} } +func (m *Error) String() string { return proto.CompactTextString(m) } +func (*Error) ProtoMessage() {} +func (*Error) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{0} } + +func (m *Error) GetCode() string { + if m != nil && m.Code != nil { + return *m.Code + } + return "" +} + +func (m *Error) GetMessage() string { + if m != nil && m.Message != nil { + return *m.Message + } + return "" +} + +type PrimaryKeySchema struct { + Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"` + Type *PrimaryKeyType `protobuf:"varint,2,req,name=type,enum=otsprotocol.PrimaryKeyType" json:"type,omitempty"` + Option *PrimaryKeyOption `protobuf:"varint,3,opt,name=option,enum=otsprotocol.PrimaryKeyOption" json:"option,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PrimaryKeySchema) Reset() { *m = PrimaryKeySchema{} } +func (m *PrimaryKeySchema) String() string { return proto.CompactTextString(m) } +func (*PrimaryKeySchema) ProtoMessage() {} +func (*PrimaryKeySchema) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{1} } + +func (m *PrimaryKeySchema) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *PrimaryKeySchema) GetType() PrimaryKeyType { + if m != nil && m.Type != nil { + return *m.Type + } + return PrimaryKeyType_INTEGER +} + +func (m *PrimaryKeySchema) GetOption() PrimaryKeyOption { + if m != nil && m.Option != nil { + return *m.Option + } + return PrimaryKeyOption_AUTO_INCREMENT +} + +type PartitionRange struct { + Begin []byte `protobuf:"bytes,1,req,name=begin" json:"begin,omitempty"` + End []byte `protobuf:"bytes,2,req,name=end" json:"end,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PartitionRange) Reset() { *m = PartitionRange{} } +func (m *PartitionRange) String() string { return proto.CompactTextString(m) } +func (*PartitionRange) ProtoMessage() {} +func (*PartitionRange) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{2} } + +func (m *PartitionRange) GetBegin() []byte { + if m != nil { + return m.Begin + } + return nil +} + +func (m *PartitionRange) GetEnd() []byte { + if m != nil { + return m.End + } + return nil +} + +type TableOptions struct { + TimeToLive *int32 `protobuf:"varint,1,opt,name=time_to_live" json:"time_to_live,omitempty"` + MaxVersions *int32 `protobuf:"varint,2,opt,name=max_versions" json:"max_versions,omitempty"` + BloomFilterType *BloomFilterType `protobuf:"varint,3,opt,name=bloom_filter_type,enum=otsprotocol.BloomFilterType" json:"bloom_filter_type,omitempty"` + BlockSize *int32 `protobuf:"varint,4,opt,name=block_size" json:"block_size,omitempty"` + DeviationCellVersionInSec *int64 `protobuf:"varint,5,opt,name=deviation_cell_version_in_sec" json:"deviation_cell_version_in_sec,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TableOptions) Reset() { *m = TableOptions{} } +func (m *TableOptions) String() string { return proto.CompactTextString(m) } +func (*TableOptions) ProtoMessage() {} +func (*TableOptions) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{3} } + +func (m *TableOptions) GetTimeToLive() int32 { + if m != nil && m.TimeToLive != nil { + return *m.TimeToLive + } + return 0 +} + +func (m *TableOptions) GetMaxVersions() int32 { + if m != nil && m.MaxVersions != nil { + return *m.MaxVersions + } + return 0 +} + +func (m *TableOptions) GetBloomFilterType() BloomFilterType { + if m != nil && m.BloomFilterType != nil { + return *m.BloomFilterType + } + return BloomFilterType_NONE +} + +func (m *TableOptions) GetBlockSize() int32 { + if m != nil && m.BlockSize != nil { + return *m.BlockSize + } + return 0 +} + +func (m *TableOptions) GetDeviationCellVersionInSec() int64 { + if m != nil && m.DeviationCellVersionInSec != nil { + return *m.DeviationCellVersionInSec + } + return 0 +} + +type TableMeta struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + PrimaryKey []*PrimaryKeySchema `protobuf:"bytes,2,rep,name=primary_key" json:"primary_key,omitempty"` + DefinedColumn []*DefinedColumnSchema `protobuf:"bytes,3,rep,name=defined_column" json:"defined_column,omitempty"` + IndexMeta []*IndexMeta `protobuf:"bytes,4,rep,name=index_meta" json:"index_meta,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TableMeta) Reset() { *m = TableMeta{} } +func (m *TableMeta) String() string { return proto.CompactTextString(m) } +func (*TableMeta) ProtoMessage() {} +func (*TableMeta) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{4} } + +func (m *TableMeta) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *TableMeta) GetPrimaryKey() []*PrimaryKeySchema { + if m != nil { + return m.PrimaryKey + } + return nil +} + +func (m *TableMeta) GetDefinedColumn() []*DefinedColumnSchema { + if m != nil { + return m.DefinedColumn + } + return nil +} + +func (m *TableMeta) GetIndexMeta() []*IndexMeta { + if m != nil { + return m.IndexMeta + } + return nil +} + +type Condition struct { + RowExistence *RowExistenceExpectation `protobuf:"varint,1,req,name=row_existence,enum=otsprotocol.RowExistenceExpectation" json:"row_existence,omitempty"` + ColumnCondition []byte `protobuf:"bytes,2,opt,name=column_condition" json:"column_condition,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Condition) Reset() { *m = Condition{} } +func (m *Condition) String() string { return proto.CompactTextString(m) } +func (*Condition) ProtoMessage() {} +func (*Condition) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{5} } + +func (m *Condition) GetRowExistence() RowExistenceExpectation { + if m != nil && m.RowExistence != nil { + return *m.RowExistence + } + return RowExistenceExpectation_IGNORE +} + +func (m *Condition) GetColumnCondition() []byte { + if m != nil { + return m.ColumnCondition + } + return nil +} + +type CapacityUnit struct { + Read *int32 `protobuf:"varint,1,opt,name=read" json:"read,omitempty"` + Write *int32 `protobuf:"varint,2,opt,name=write" json:"write,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CapacityUnit) Reset() { *m = CapacityUnit{} } +func (m *CapacityUnit) String() string { return proto.CompactTextString(m) } +func (*CapacityUnit) ProtoMessage() {} +func (*CapacityUnit) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{6} } + +func (m *CapacityUnit) GetRead() int32 { + if m != nil && m.Read != nil { + return *m.Read + } + return 0 +} + +func (m *CapacityUnit) GetWrite() int32 { + if m != nil && m.Write != nil { + return *m.Write + } + return 0 +} + +type ReservedThroughputDetails struct { + CapacityUnit *CapacityUnit `protobuf:"bytes,1,req,name=capacity_unit" json:"capacity_unit,omitempty"` + LastIncreaseTime *int64 `protobuf:"varint,2,req,name=last_increase_time" json:"last_increase_time,omitempty"` + LastDecreaseTime *int64 `protobuf:"varint,3,opt,name=last_decrease_time" json:"last_decrease_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ReservedThroughputDetails) Reset() { *m = ReservedThroughputDetails{} } +func (m *ReservedThroughputDetails) String() string { return proto.CompactTextString(m) } +func (*ReservedThroughputDetails) ProtoMessage() {} +func (*ReservedThroughputDetails) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{7} } + +func (m *ReservedThroughputDetails) GetCapacityUnit() *CapacityUnit { + if m != nil { + return m.CapacityUnit + } + return nil +} + +func (m *ReservedThroughputDetails) GetLastIncreaseTime() int64 { + if m != nil && m.LastIncreaseTime != nil { + return *m.LastIncreaseTime + } + return 0 +} + +func (m *ReservedThroughputDetails) GetLastDecreaseTime() int64 { + if m != nil && m.LastDecreaseTime != nil { + return *m.LastDecreaseTime + } + return 0 +} + +type ReservedThroughput struct { + CapacityUnit *CapacityUnit `protobuf:"bytes,1,req,name=capacity_unit" json:"capacity_unit,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ReservedThroughput) Reset() { *m = ReservedThroughput{} } +func (m *ReservedThroughput) String() string { return proto.CompactTextString(m) } +func (*ReservedThroughput) ProtoMessage() {} +func (*ReservedThroughput) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{8} } + +func (m *ReservedThroughput) GetCapacityUnit() *CapacityUnit { + if m != nil { + return m.CapacityUnit + } + return nil +} + +type ConsumedCapacity struct { + CapacityUnit *CapacityUnit `protobuf:"bytes,1,req,name=capacity_unit" json:"capacity_unit,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ConsumedCapacity) Reset() { *m = ConsumedCapacity{} } +func (m *ConsumedCapacity) String() string { return proto.CompactTextString(m) } +func (*ConsumedCapacity) ProtoMessage() {} +func (*ConsumedCapacity) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{9} } + +func (m *ConsumedCapacity) GetCapacityUnit() *CapacityUnit { + if m != nil { + return m.CapacityUnit + } + return nil +} + +type StreamSpecification struct { + EnableStream *bool `protobuf:"varint,1,req,name=enable_stream" json:"enable_stream,omitempty"` + ExpirationTime *int32 `protobuf:"varint,2,opt,name=expiration_time" json:"expiration_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *StreamSpecification) Reset() { *m = StreamSpecification{} } +func (m *StreamSpecification) String() string { return proto.CompactTextString(m) } +func (*StreamSpecification) ProtoMessage() {} +func (*StreamSpecification) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{10} } + +func (m *StreamSpecification) GetEnableStream() bool { + if m != nil && m.EnableStream != nil { + return *m.EnableStream + } + return false +} + +func (m *StreamSpecification) GetExpirationTime() int32 { + if m != nil && m.ExpirationTime != nil { + return *m.ExpirationTime + } + return 0 +} + +type StreamDetails struct { + EnableStream *bool `protobuf:"varint,1,req,name=enable_stream" json:"enable_stream,omitempty"` + StreamId *string `protobuf:"bytes,2,opt,name=stream_id" json:"stream_id,omitempty"` + ExpirationTime *int32 `protobuf:"varint,3,opt,name=expiration_time" json:"expiration_time,omitempty"` + LastEnableTime *int64 `protobuf:"varint,4,opt,name=last_enable_time" json:"last_enable_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *StreamDetails) Reset() { *m = StreamDetails{} } +func (m *StreamDetails) String() string { return proto.CompactTextString(m) } +func (*StreamDetails) ProtoMessage() {} +func (*StreamDetails) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{11} } + +func (m *StreamDetails) GetEnableStream() bool { + if m != nil && m.EnableStream != nil { + return *m.EnableStream + } + return false +} + +func (m *StreamDetails) GetStreamId() string { + if m != nil && m.StreamId != nil { + return *m.StreamId + } + return "" +} + +func (m *StreamDetails) GetExpirationTime() int32 { + if m != nil && m.ExpirationTime != nil { + return *m.ExpirationTime + } + return 0 +} + +func (m *StreamDetails) GetLastEnableTime() int64 { + if m != nil && m.LastEnableTime != nil { + return *m.LastEnableTime + } + return 0 +} + +// * +// table_meta用于存储表中不可更改的schema属性，可以更改的ReservedThroughput和TableOptions独立出来，作为UpdateTable的参数。 +// 加入GlobalIndex和LocalIndex之后，结构会变为： +// message CreateTableRequest { +// required TableMeta table_meta = 1; +// required ReservedThroughput reserved_throughput = 2; +// required TableOptions table_options = 3; +// repeated LocalIndex local_indexes = 4; // LocalIndex不再单独包含ReservedThroughput和TableOptions，其与主表共享配置。 +// repeated GlobalIndex global_indexes = 5; // GlobalIndex内单独包含ReservedThroughput和TableOptions +// } +type CreateTableRequest struct { + TableMeta *TableMeta `protobuf:"bytes,1,req,name=table_meta" json:"table_meta,omitempty"` + ReservedThroughput *ReservedThroughput `protobuf:"bytes,2,req,name=reserved_throughput" json:"reserved_throughput,omitempty"` + TableOptions *TableOptions `protobuf:"bytes,3,opt,name=table_options" json:"table_options,omitempty"` + Partitions []*PartitionRange `protobuf:"bytes,4,rep,name=partitions" json:"partitions,omitempty"` + StreamSpec *StreamSpecification `protobuf:"bytes,5,opt,name=stream_spec" json:"stream_spec,omitempty"` + IndexMetas []*IndexMeta `protobuf:"bytes,7,rep,name=index_metas" json:"index_metas,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CreateTableRequest) Reset() { *m = CreateTableRequest{} } +func (m *CreateTableRequest) String() string { return proto.CompactTextString(m) } +func (*CreateTableRequest) ProtoMessage() {} +func (*CreateTableRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{12} } + +func (m *CreateTableRequest) GetTableMeta() *TableMeta { + if m != nil { + return m.TableMeta + } + return nil +} + +func (m *CreateTableRequest) GetReservedThroughput() *ReservedThroughput { + if m != nil { + return m.ReservedThroughput + } + return nil +} + +func (m *CreateTableRequest) GetTableOptions() *TableOptions { + if m != nil { + return m.TableOptions + } + return nil +} + +func (m *CreateTableRequest) GetPartitions() []*PartitionRange { + if m != nil { + return m.Partitions + } + return nil +} + +func (m *CreateTableRequest) GetStreamSpec() *StreamSpecification { + if m != nil { + return m.StreamSpec + } + return nil +} + +func (m *CreateTableRequest) GetIndexMetas() []*IndexMeta { + if m != nil { + return m.IndexMetas + } + return nil +} + +type CreateTableResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CreateTableResponse) Reset() { *m = CreateTableResponse{} } +func (m *CreateTableResponse) String() string { return proto.CompactTextString(m) } +func (*CreateTableResponse) ProtoMessage() {} +func (*CreateTableResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{13} } + +// ############################################# UpdateTable ############################################# +type UpdateTableRequest struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + ReservedThroughput *ReservedThroughput `protobuf:"bytes,2,opt,name=reserved_throughput" json:"reserved_throughput,omitempty"` + TableOptions *TableOptions `protobuf:"bytes,3,opt,name=table_options" json:"table_options,omitempty"` + StreamSpec *StreamSpecification `protobuf:"bytes,4,opt,name=stream_spec" json:"stream_spec,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UpdateTableRequest) Reset() { *m = UpdateTableRequest{} } +func (m *UpdateTableRequest) String() string { return proto.CompactTextString(m) } +func (*UpdateTableRequest) ProtoMessage() {} +func (*UpdateTableRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{14} } + +func (m *UpdateTableRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *UpdateTableRequest) GetReservedThroughput() *ReservedThroughput { + if m != nil { + return m.ReservedThroughput + } + return nil +} + +func (m *UpdateTableRequest) GetTableOptions() *TableOptions { + if m != nil { + return m.TableOptions + } + return nil +} + +func (m *UpdateTableRequest) GetStreamSpec() *StreamSpecification { + if m != nil { + return m.StreamSpec + } + return nil +} + +type UpdateTableResponse struct { + ReservedThroughputDetails *ReservedThroughputDetails `protobuf:"bytes,1,req,name=reserved_throughput_details" json:"reserved_throughput_details,omitempty"` + TableOptions *TableOptions `protobuf:"bytes,2,req,name=table_options" json:"table_options,omitempty"` + StreamDetails *StreamDetails `protobuf:"bytes,3,opt,name=stream_details" json:"stream_details,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UpdateTableResponse) Reset() { *m = UpdateTableResponse{} } +func (m *UpdateTableResponse) String() string { return proto.CompactTextString(m) } +func (*UpdateTableResponse) ProtoMessage() {} +func (*UpdateTableResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{15} } + +func (m *UpdateTableResponse) GetReservedThroughputDetails() *ReservedThroughputDetails { + if m != nil { + return m.ReservedThroughputDetails + } + return nil +} + +func (m *UpdateTableResponse) GetTableOptions() *TableOptions { + if m != nil { + return m.TableOptions + } + return nil +} + +func (m *UpdateTableResponse) GetStreamDetails() *StreamDetails { + if m != nil { + return m.StreamDetails + } + return nil +} + +// ############################################# DescribeTable ############################################# +type DescribeTableRequest struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DescribeTableRequest) Reset() { *m = DescribeTableRequest{} } +func (m *DescribeTableRequest) String() string { return proto.CompactTextString(m) } +func (*DescribeTableRequest) ProtoMessage() {} +func (*DescribeTableRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{16} } + +func (m *DescribeTableRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +type DescribeTableResponse struct { + TableMeta *TableMeta `protobuf:"bytes,1,req,name=table_meta" json:"table_meta,omitempty"` + ReservedThroughputDetails *ReservedThroughputDetails `protobuf:"bytes,2,req,name=reserved_throughput_details" json:"reserved_throughput_details,omitempty"` + TableOptions *TableOptions `protobuf:"bytes,3,req,name=table_options" json:"table_options,omitempty"` + TableStatus *TableStatus `protobuf:"varint,4,req,name=table_status,enum=otsprotocol.TableStatus" json:"table_status,omitempty"` + StreamDetails *StreamDetails `protobuf:"bytes,5,opt,name=stream_details" json:"stream_details,omitempty"` + ShardSplits [][]byte `protobuf:"bytes,6,rep,name=shard_splits" json:"shard_splits,omitempty"` + IndexMetas []*IndexMeta `protobuf:"bytes,8,rep,name=index_metas" json:"index_metas,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DescribeTableResponse) Reset() { *m = DescribeTableResponse{} } +func (m *DescribeTableResponse) String() string { return proto.CompactTextString(m) } +func (*DescribeTableResponse) ProtoMessage() {} +func (*DescribeTableResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{17} } + +func (m *DescribeTableResponse) GetTableMeta() *TableMeta { + if m != nil { + return m.TableMeta + } + return nil +} + +func (m *DescribeTableResponse) GetReservedThroughputDetails() *ReservedThroughputDetails { + if m != nil { + return m.ReservedThroughputDetails + } + return nil +} + +func (m *DescribeTableResponse) GetTableOptions() *TableOptions { + if m != nil { + return m.TableOptions + } + return nil +} + +func (m *DescribeTableResponse) GetTableStatus() TableStatus { + if m != nil && m.TableStatus != nil { + return *m.TableStatus + } + return TableStatus_ACTIVE +} + +func (m *DescribeTableResponse) GetStreamDetails() *StreamDetails { + if m != nil { + return m.StreamDetails + } + return nil +} + +func (m *DescribeTableResponse) GetShardSplits() [][]byte { + if m != nil { + return m.ShardSplits + } + return nil +} + +func (m *DescribeTableResponse) GetIndexMetas() []*IndexMeta { + if m != nil { + return m.IndexMetas + } + return nil +} + +// ############################################# ListTable ############################################# +type ListTableRequest struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *ListTableRequest) Reset() { *m = ListTableRequest{} } +func (m *ListTableRequest) String() string { return proto.CompactTextString(m) } +func (*ListTableRequest) ProtoMessage() {} +func (*ListTableRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{18} } + +// * +// 当前只返回一个简单的名称列表，需要讨论是否有业务场景需要获取除了表名之外的其他信息。 +// 其他信息可以包含预留吞吐量以及表的状态，这个信息只能是一个粗略的信息，表的详细信息还是需要通过DescribeTable来获取。 +type ListTableResponse struct { + TableNames []string `protobuf:"bytes,1,rep,name=table_names" json:"table_names,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ListTableResponse) Reset() { *m = ListTableResponse{} } +func (m *ListTableResponse) String() string { return proto.CompactTextString(m) } +func (*ListTableResponse) ProtoMessage() {} +func (*ListTableResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{19} } + +func (m *ListTableResponse) GetTableNames() []string { + if m != nil { + return m.TableNames + } + return nil +} + +// ############################################# DeleteTable ############################################# +type DeleteTableRequest struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeleteTableRequest) Reset() { *m = DeleteTableRequest{} } +func (m *DeleteTableRequest) String() string { return proto.CompactTextString(m) } +func (*DeleteTableRequest) ProtoMessage() {} +func (*DeleteTableRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{20} } + +func (m *DeleteTableRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +type DeleteTableResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeleteTableResponse) Reset() { *m = DeleteTableResponse{} } +func (m *DeleteTableResponse) String() string { return proto.CompactTextString(m) } +func (*DeleteTableResponse) ProtoMessage() {} +func (*DeleteTableResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{21} } + +// ############################################# LoadTable ############################################# +type LoadTableRequest struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *LoadTableRequest) Reset() { *m = LoadTableRequest{} } +func (m *LoadTableRequest) String() string { return proto.CompactTextString(m) } +func (*LoadTableRequest) ProtoMessage() {} +func (*LoadTableRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{22} } + +func (m *LoadTableRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +type LoadTableResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *LoadTableResponse) Reset() { *m = LoadTableResponse{} } +func (m *LoadTableResponse) String() string { return proto.CompactTextString(m) } +func (*LoadTableResponse) ProtoMessage() {} +func (*LoadTableResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{23} } + +// ############################################# UnloadTable ############################################# +type UnloadTableRequest struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnloadTableRequest) Reset() { *m = UnloadTableRequest{} } +func (m *UnloadTableRequest) String() string { return proto.CompactTextString(m) } +func (*UnloadTableRequest) ProtoMessage() {} +func (*UnloadTableRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{24} } + +func (m *UnloadTableRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +type UnloadTableResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *UnloadTableResponse) Reset() { *m = UnloadTableResponse{} } +func (m *UnloadTableResponse) String() string { return proto.CompactTextString(m) } +func (*UnloadTableResponse) ProtoMessage() {} +func (*UnloadTableResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{25} } + +// * +// 时间戳的取值最小值为0，最大值为INT64.MAX +// 1. 若要查询一个范围，则指定start_time和end_time +// 2. 若要查询一个特定时间戳，则指定specific_time +type TimeRange struct { + StartTime *int64 `protobuf:"varint,1,opt,name=start_time" json:"start_time,omitempty"` + EndTime *int64 `protobuf:"varint,2,opt,name=end_time" json:"end_time,omitempty"` + SpecificTime *int64 `protobuf:"varint,3,opt,name=specific_time" json:"specific_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TimeRange) Reset() { *m = TimeRange{} } +func (m *TimeRange) String() string { return proto.CompactTextString(m) } +func (*TimeRange) ProtoMessage() {} +func (*TimeRange) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{26} } + +func (m *TimeRange) GetStartTime() int64 { + if m != nil && m.StartTime != nil { + return *m.StartTime + } + return 0 +} + +func (m *TimeRange) GetEndTime() int64 { + if m != nil && m.EndTime != nil { + return *m.EndTime + } + return 0 +} + +func (m *TimeRange) GetSpecificTime() int64 { + if m != nil && m.SpecificTime != nil { + return *m.SpecificTime + } + return 0 +} + +type ReturnContent struct { + ReturnType *ReturnType `protobuf:"varint,1,opt,name=return_type,enum=otsprotocol.ReturnType" json:"return_type,omitempty"` + ReturnColumnNames []string `protobuf:"bytes,2,rep,name=return_column_names" json:"return_column_names,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ReturnContent) Reset() { *m = ReturnContent{} } +func (m *ReturnContent) String() string { return proto.CompactTextString(m) } +func (*ReturnContent) ProtoMessage() {} +func (*ReturnContent) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{27} } + +func (m *ReturnContent) GetReturnType() ReturnType { + if m != nil && m.ReturnType != nil { + return *m.ReturnType + } + return ReturnType_RT_NONE +} + +func (m *ReturnContent) GetReturnColumnNames() []string { + if m != nil { + return m.ReturnColumnNames + } + return nil +} + +// * +// 1. 支持用户指定版本时间戳范围或者特定的版本时间来读取指定版本的列 +// 2. 目前暂不支持行内的断点 +type GetRowRequest struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + PrimaryKey []byte `protobuf:"bytes,2,req,name=primary_key" json:"primary_key,omitempty"` + ColumnsToGet []string `protobuf:"bytes,3,rep,name=columns_to_get" json:"columns_to_get,omitempty"` + TimeRange *TimeRange `protobuf:"bytes,4,opt,name=time_range" json:"time_range,omitempty"` + MaxVersions *int32 `protobuf:"varint,5,opt,name=max_versions" json:"max_versions,omitempty"` + CacheBlocks *bool `protobuf:"varint,6,opt,name=cache_blocks,def=1" json:"cache_blocks,omitempty"` + Filter []byte `protobuf:"bytes,7,opt,name=filter" json:"filter,omitempty"` + StartColumn *string `protobuf:"bytes,8,opt,name=start_column" json:"start_column,omitempty"` + EndColumn *string `protobuf:"bytes,9,opt,name=end_column" json:"end_column,omitempty"` + Token []byte `protobuf:"bytes,10,opt,name=token" json:"token,omitempty"` + TransactionId *string `protobuf:"bytes,11,opt,name=transaction_id" json:"transaction_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetRowRequest) Reset() { *m = GetRowRequest{} } +func (m *GetRowRequest) String() string { return proto.CompactTextString(m) } +func (*GetRowRequest) ProtoMessage() {} +func (*GetRowRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{28} } + +const Default_GetRowRequest_CacheBlocks bool = true + +func (m *GetRowRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *GetRowRequest) GetPrimaryKey() []byte { + if m != nil { + return m.PrimaryKey + } + return nil +} + +func (m *GetRowRequest) GetColumnsToGet() []string { + if m != nil { + return m.ColumnsToGet + } + return nil +} + +func (m *GetRowRequest) GetTimeRange() *TimeRange { + if m != nil { + return m.TimeRange + } + return nil +} + +func (m *GetRowRequest) GetMaxVersions() int32 { + if m != nil && m.MaxVersions != nil { + return *m.MaxVersions + } + return 0 +} + +func (m *GetRowRequest) GetCacheBlocks() bool { + if m != nil && m.CacheBlocks != nil { + return *m.CacheBlocks + } + return Default_GetRowRequest_CacheBlocks +} + +func (m *GetRowRequest) GetFilter() []byte { + if m != nil { + return m.Filter + } + return nil +} + +func (m *GetRowRequest) GetStartColumn() string { + if m != nil && m.StartColumn != nil { + return *m.StartColumn + } + return "" +} + +func (m *GetRowRequest) GetEndColumn() string { + if m != nil && m.EndColumn != nil { + return *m.EndColumn + } + return "" +} + +func (m *GetRowRequest) GetToken() []byte { + if m != nil { + return m.Token + } + return nil +} + +func (m *GetRowRequest) GetTransactionId() string { + if m != nil && m.TransactionId != nil { + return *m.TransactionId + } + return "" +} + +type GetRowResponse struct { + Consumed *ConsumedCapacity `protobuf:"bytes,1,req,name=consumed" json:"consumed,omitempty"` + Row []byte `protobuf:"bytes,2,req,name=row" json:"row,omitempty"` + NextToken []byte `protobuf:"bytes,3,opt,name=next_token" json:"next_token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetRowResponse) Reset() { *m = GetRowResponse{} } +func (m *GetRowResponse) String() string { return proto.CompactTextString(m) } +func (*GetRowResponse) ProtoMessage() {} +func (*GetRowResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{29} } + +func (m *GetRowResponse) GetConsumed() *ConsumedCapacity { + if m != nil { + return m.Consumed + } + return nil +} + +func (m *GetRowResponse) GetRow() []byte { + if m != nil { + return m.Row + } + return nil +} + +func (m *GetRowResponse) GetNextToken() []byte { + if m != nil { + return m.NextToken + } + return nil +} + +// ############################################# UpdateRow ############################################# +type UpdateRowRequest struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + RowChange []byte `protobuf:"bytes,2,req,name=row_change" json:"row_change,omitempty"` + Condition *Condition `protobuf:"bytes,3,req,name=condition" json:"condition,omitempty"` + ReturnContent *ReturnContent `protobuf:"bytes,4,opt,name=return_content" json:"return_content,omitempty"` + TransactionId *string `protobuf:"bytes,5,opt,name=transaction_id" json:"transaction_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UpdateRowRequest) Reset() { *m = UpdateRowRequest{} } +func (m *UpdateRowRequest) String() string { return proto.CompactTextString(m) } +func (*UpdateRowRequest) ProtoMessage() {} +func (*UpdateRowRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{30} } + +func (m *UpdateRowRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *UpdateRowRequest) GetRowChange() []byte { + if m != nil { + return m.RowChange + } + return nil +} + +func (m *UpdateRowRequest) GetCondition() *Condition { + if m != nil { + return m.Condition + } + return nil +} + +func (m *UpdateRowRequest) GetReturnContent() *ReturnContent { + if m != nil { + return m.ReturnContent + } + return nil +} + +func (m *UpdateRowRequest) GetTransactionId() string { + if m != nil && m.TransactionId != nil { + return *m.TransactionId + } + return "" +} + +type UpdateRowResponse struct { + Consumed *ConsumedCapacity `protobuf:"bytes,1,req,name=consumed" json:"consumed,omitempty"` + Row []byte `protobuf:"bytes,2,opt,name=row" json:"row,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *UpdateRowResponse) Reset() { *m = UpdateRowResponse{} } +func (m *UpdateRowResponse) String() string { return proto.CompactTextString(m) } +func (*UpdateRowResponse) ProtoMessage() {} +func (*UpdateRowResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{31} } + +func (m *UpdateRowResponse) GetConsumed() *ConsumedCapacity { + if m != nil { + return m.Consumed + } + return nil +} + +func (m *UpdateRowResponse) GetRow() []byte { + if m != nil { + return m.Row + } + return nil +} + +// * +// 这里允许用户为每列单独设置timestamp，而不是强制整行统一一个timestamp。 +// 原因是列都是用统一的结构，该结构本身是带timestamp的，其次强制统一timestamp增强了规范性但是丧失了灵活性，且该规范性没有明显的好处，反而带来了结构的复杂。 +type PutRowRequest struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + Row []byte `protobuf:"bytes,2,req,name=row" json:"row,omitempty"` + Condition *Condition `protobuf:"bytes,3,req,name=condition" json:"condition,omitempty"` + ReturnContent *ReturnContent `protobuf:"bytes,4,opt,name=return_content" json:"return_content,omitempty"` + TransactionId *string `protobuf:"bytes,5,opt,name=transaction_id" json:"transaction_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PutRowRequest) Reset() { *m = PutRowRequest{} } +func (m *PutRowRequest) String() string { return proto.CompactTextString(m) } +func (*PutRowRequest) ProtoMessage() {} +func (*PutRowRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{32} } + +func (m *PutRowRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *PutRowRequest) GetRow() []byte { + if m != nil { + return m.Row + } + return nil +} + +func (m *PutRowRequest) GetCondition() *Condition { + if m != nil { + return m.Condition + } + return nil +} + +func (m *PutRowRequest) GetReturnContent() *ReturnContent { + if m != nil { + return m.ReturnContent + } + return nil +} + +func (m *PutRowRequest) GetTransactionId() string { + if m != nil && m.TransactionId != nil { + return *m.TransactionId + } + return "" +} + +type PutRowResponse struct { + Consumed *ConsumedCapacity `protobuf:"bytes,1,req,name=consumed" json:"consumed,omitempty"` + Row []byte `protobuf:"bytes,2,opt,name=row" json:"row,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *PutRowResponse) Reset() { *m = PutRowResponse{} } +func (m *PutRowResponse) String() string { return proto.CompactTextString(m) } +func (*PutRowResponse) ProtoMessage() {} +func (*PutRowResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{33} } + +func (m *PutRowResponse) GetConsumed() *ConsumedCapacity { + if m != nil { + return m.Consumed + } + return nil +} + +func (m *PutRowResponse) GetRow() []byte { + if m != nil { + return m.Row + } + return nil +} + +// * +// OTS只支持删除该行的所有列所有版本，不支持： +// 1. 删除所有列的所有小于等于某个版本的所有版本 +type DeleteRowRequest struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + PrimaryKey []byte `protobuf:"bytes,2,req,name=primary_key" json:"primary_key,omitempty"` + Condition *Condition `protobuf:"bytes,3,req,name=condition" json:"condition,omitempty"` + ReturnContent *ReturnContent `protobuf:"bytes,4,opt,name=return_content" json:"return_content,omitempty"` + TransactionId *string `protobuf:"bytes,5,opt,name=transaction_id" json:"transaction_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeleteRowRequest) Reset() { *m = DeleteRowRequest{} } +func (m *DeleteRowRequest) String() string { return proto.CompactTextString(m) } +func (*DeleteRowRequest) ProtoMessage() {} +func (*DeleteRowRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{34} } + +func (m *DeleteRowRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *DeleteRowRequest) GetPrimaryKey() []byte { + if m != nil { + return m.PrimaryKey + } + return nil +} + +func (m *DeleteRowRequest) GetCondition() *Condition { + if m != nil { + return m.Condition + } + return nil +} + +func (m *DeleteRowRequest) GetReturnContent() *ReturnContent { + if m != nil { + return m.ReturnContent + } + return nil +} + +func (m *DeleteRowRequest) GetTransactionId() string { + if m != nil && m.TransactionId != nil { + return *m.TransactionId + } + return "" +} + +type DeleteRowResponse struct { + Consumed *ConsumedCapacity `protobuf:"bytes,1,req,name=consumed" json:"consumed,omitempty"` + Row []byte `protobuf:"bytes,2,opt,name=row" json:"row,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DeleteRowResponse) Reset() { *m = DeleteRowResponse{} } +func (m *DeleteRowResponse) String() string { return proto.CompactTextString(m) } +func (*DeleteRowResponse) ProtoMessage() {} +func (*DeleteRowResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{35} } + +func (m *DeleteRowResponse) GetConsumed() *ConsumedCapacity { + if m != nil { + return m.Consumed + } + return nil +} + +func (m *DeleteRowResponse) GetRow() []byte { + if m != nil { + return m.Row + } + return nil +} + +// * +// HBase支持Batch操作的每行都拥有不同的查询参数，OTS不支持。 +type TableInBatchGetRowRequest struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + PrimaryKey [][]byte `protobuf:"bytes,2,rep,name=primary_key" json:"primary_key,omitempty"` + Token [][]byte `protobuf:"bytes,3,rep,name=token" json:"token,omitempty"` + ColumnsToGet []string `protobuf:"bytes,4,rep,name=columns_to_get" json:"columns_to_get,omitempty"` + TimeRange *TimeRange `protobuf:"bytes,5,opt,name=time_range" json:"time_range,omitempty"` + MaxVersions *int32 `protobuf:"varint,6,opt,name=max_versions" json:"max_versions,omitempty"` + CacheBlocks *bool `protobuf:"varint,7,opt,name=cache_blocks,def=1" json:"cache_blocks,omitempty"` + Filter []byte `protobuf:"bytes,8,opt,name=filter" json:"filter,omitempty"` + StartColumn *string `protobuf:"bytes,9,opt,name=start_column" json:"start_column,omitempty"` + EndColumn *string `protobuf:"bytes,10,opt,name=end_column" json:"end_column,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TableInBatchGetRowRequest) Reset() { *m = TableInBatchGetRowRequest{} } +func (m *TableInBatchGetRowRequest) String() string { return proto.CompactTextString(m) } +func (*TableInBatchGetRowRequest) ProtoMessage() {} +func (*TableInBatchGetRowRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{36} } + +const Default_TableInBatchGetRowRequest_CacheBlocks bool = true + +func (m *TableInBatchGetRowRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *TableInBatchGetRowRequest) GetPrimaryKey() [][]byte { + if m != nil { + return m.PrimaryKey + } + return nil +} + +func (m *TableInBatchGetRowRequest) GetToken() [][]byte { + if m != nil { + return m.Token + } + return nil +} + +func (m *TableInBatchGetRowRequest) GetColumnsToGet() []string { + if m != nil { + return m.ColumnsToGet + } + return nil +} + +func (m *TableInBatchGetRowRequest) GetTimeRange() *TimeRange { + if m != nil { + return m.TimeRange + } + return nil +} + +func (m *TableInBatchGetRowRequest) GetMaxVersions() int32 { + if m != nil && m.MaxVersions != nil { + return *m.MaxVersions + } + return 0 +} + +func (m *TableInBatchGetRowRequest) GetCacheBlocks() bool { + if m != nil && m.CacheBlocks != nil { + return *m.CacheBlocks + } + return Default_TableInBatchGetRowRequest_CacheBlocks +} + +func (m *TableInBatchGetRowRequest) GetFilter() []byte { + if m != nil { + return m.Filter + } + return nil +} + +func (m *TableInBatchGetRowRequest) GetStartColumn() string { + if m != nil && m.StartColumn != nil { + return *m.StartColumn + } + return "" +} + +func (m *TableInBatchGetRowRequest) GetEndColumn() string { + if m != nil && m.EndColumn != nil { + return *m.EndColumn + } + return "" +} + +type BatchGetRowRequest struct { + Tables []*TableInBatchGetRowRequest `protobuf:"bytes,1,rep,name=tables" json:"tables,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *BatchGetRowRequest) Reset() { *m = BatchGetRowRequest{} } +func (m *BatchGetRowRequest) String() string { return proto.CompactTextString(m) } +func (*BatchGetRowRequest) ProtoMessage() {} +func (*BatchGetRowRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{37} } + +func (m *BatchGetRowRequest) GetTables() []*TableInBatchGetRowRequest { + if m != nil { + return m.Tables + } + return nil +} + +type RowInBatchGetRowResponse struct { + IsOk *bool `protobuf:"varint,1,req,name=is_ok" json:"is_ok,omitempty"` + Error *Error `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` + Consumed *ConsumedCapacity `protobuf:"bytes,3,opt,name=consumed" json:"consumed,omitempty"` + Row []byte `protobuf:"bytes,4,opt,name=row" json:"row,omitempty"` + NextToken []byte `protobuf:"bytes,5,opt,name=next_token" json:"next_token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *RowInBatchGetRowResponse) Reset() { *m = RowInBatchGetRowResponse{} } +func (m *RowInBatchGetRowResponse) String() string { return proto.CompactTextString(m) } +func (*RowInBatchGetRowResponse) ProtoMessage() {} +func (*RowInBatchGetRowResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{38} } + +func (m *RowInBatchGetRowResponse) GetIsOk() bool { + if m != nil && m.IsOk != nil { + return *m.IsOk + } + return false +} + +func (m *RowInBatchGetRowResponse) GetError() *Error { + if m != nil { + return m.Error + } + return nil +} + +func (m *RowInBatchGetRowResponse) GetConsumed() *ConsumedCapacity { + if m != nil { + return m.Consumed + } + return nil +} + +func (m *RowInBatchGetRowResponse) GetRow() []byte { + if m != nil { + return m.Row + } + return nil +} + +func (m *RowInBatchGetRowResponse) GetNextToken() []byte { + if m != nil { + return m.NextToken + } + return nil +} + +type TableInBatchGetRowResponse struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + Rows []*RowInBatchGetRowResponse `protobuf:"bytes,2,rep,name=rows" json:"rows,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TableInBatchGetRowResponse) Reset() { *m = TableInBatchGetRowResponse{} } +func (m *TableInBatchGetRowResponse) String() string { return proto.CompactTextString(m) } +func (*TableInBatchGetRowResponse) ProtoMessage() {} +func (*TableInBatchGetRowResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{39} } + +func (m *TableInBatchGetRowResponse) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *TableInBatchGetRowResponse) GetRows() []*RowInBatchGetRowResponse { + if m != nil { + return m.Rows + } + return nil +} + +type BatchGetRowResponse struct { + Tables []*TableInBatchGetRowResponse `protobuf:"bytes,1,rep,name=tables" json:"tables,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *BatchGetRowResponse) Reset() { *m = BatchGetRowResponse{} } +func (m *BatchGetRowResponse) String() string { return proto.CompactTextString(m) } +func (*BatchGetRowResponse) ProtoMessage() {} +func (*BatchGetRowResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{40} } + +func (m *BatchGetRowResponse) GetTables() []*TableInBatchGetRowResponse { + if m != nil { + return m.Tables + } + return nil +} + +type RowInBatchWriteRowRequest struct { + Type *OperationType `protobuf:"varint,1,req,name=type,enum=otsprotocol.OperationType" json:"type,omitempty"` + RowChange []byte `protobuf:"bytes,2,req,name=row_change" json:"row_change,omitempty"` + Condition *Condition `protobuf:"bytes,3,req,name=condition" json:"condition,omitempty"` + ReturnContent *ReturnContent `protobuf:"bytes,4,opt,name=return_content" json:"return_content,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *RowInBatchWriteRowRequest) Reset() { *m = RowInBatchWriteRowRequest{} } +func (m *RowInBatchWriteRowRequest) String() string { return proto.CompactTextString(m) } +func (*RowInBatchWriteRowRequest) ProtoMessage() {} +func (*RowInBatchWriteRowRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{41} } + +func (m *RowInBatchWriteRowRequest) GetType() OperationType { + if m != nil && m.Type != nil { + return *m.Type + } + return OperationType_PUT +} + +func (m *RowInBatchWriteRowRequest) GetRowChange() []byte { + if m != nil { + return m.RowChange + } + return nil +} + +func (m *RowInBatchWriteRowRequest) GetCondition() *Condition { + if m != nil { + return m.Condition + } + return nil +} + +func (m *RowInBatchWriteRowRequest) GetReturnContent() *ReturnContent { + if m != nil { + return m.ReturnContent + } + return nil +} + +type TableInBatchWriteRowRequest struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + Rows []*RowInBatchWriteRowRequest `protobuf:"bytes,2,rep,name=rows" json:"rows,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TableInBatchWriteRowRequest) Reset() { *m = TableInBatchWriteRowRequest{} } +func (m *TableInBatchWriteRowRequest) String() string { return proto.CompactTextString(m) } +func (*TableInBatchWriteRowRequest) ProtoMessage() {} +func (*TableInBatchWriteRowRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{42} } + +func (m *TableInBatchWriteRowRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *TableInBatchWriteRowRequest) GetRows() []*RowInBatchWriteRowRequest { + if m != nil { + return m.Rows + } + return nil +} + +type BatchWriteRowRequest struct { + Tables []*TableInBatchWriteRowRequest `protobuf:"bytes,1,rep,name=tables" json:"tables,omitempty"` + TransactionId *string `protobuf:"bytes,2,opt,name=transaction_id" json:"transaction_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *BatchWriteRowRequest) Reset() { *m = BatchWriteRowRequest{} } +func (m *BatchWriteRowRequest) String() string { return proto.CompactTextString(m) } +func (*BatchWriteRowRequest) ProtoMessage() {} +func (*BatchWriteRowRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{43} } + +func (m *BatchWriteRowRequest) GetTables() []*TableInBatchWriteRowRequest { + if m != nil { + return m.Tables + } + return nil +} + +func (m *BatchWriteRowRequest) GetTransactionId() string { + if m != nil && m.TransactionId != nil { + return *m.TransactionId + } + return "" +} + +type RowInBatchWriteRowResponse struct { + IsOk *bool `protobuf:"varint,1,req,name=is_ok" json:"is_ok,omitempty"` + Error *Error `protobuf:"bytes,2,opt,name=error" json:"error,omitempty"` + Consumed *ConsumedCapacity `protobuf:"bytes,3,opt,name=consumed" json:"consumed,omitempty"` + Row []byte `protobuf:"bytes,4,opt,name=row" json:"row,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *RowInBatchWriteRowResponse) Reset() { *m = RowInBatchWriteRowResponse{} } +func (m *RowInBatchWriteRowResponse) String() string { return proto.CompactTextString(m) } +func (*RowInBatchWriteRowResponse) ProtoMessage() {} +func (*RowInBatchWriteRowResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{44} } + +func (m *RowInBatchWriteRowResponse) GetIsOk() bool { + if m != nil && m.IsOk != nil { + return *m.IsOk + } + return false +} + +func (m *RowInBatchWriteRowResponse) GetError() *Error { + if m != nil { + return m.Error + } + return nil +} + +func (m *RowInBatchWriteRowResponse) GetConsumed() *ConsumedCapacity { + if m != nil { + return m.Consumed + } + return nil +} + +func (m *RowInBatchWriteRowResponse) GetRow() []byte { + if m != nil { + return m.Row + } + return nil +} + +type TableInBatchWriteRowResponse struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + Rows []*RowInBatchWriteRowResponse `protobuf:"bytes,2,rep,name=rows" json:"rows,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *TableInBatchWriteRowResponse) Reset() { *m = TableInBatchWriteRowResponse{} } +func (m *TableInBatchWriteRowResponse) String() string { return proto.CompactTextString(m) } +func (*TableInBatchWriteRowResponse) ProtoMessage() {} +func (*TableInBatchWriteRowResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{45} } + +func (m *TableInBatchWriteRowResponse) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *TableInBatchWriteRowResponse) GetRows() []*RowInBatchWriteRowResponse { + if m != nil { + return m.Rows + } + return nil +} + +type BatchWriteRowResponse struct { + Tables []*TableInBatchWriteRowResponse `protobuf:"bytes,1,rep,name=tables" json:"tables,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *BatchWriteRowResponse) Reset() { *m = BatchWriteRowResponse{} } +func (m *BatchWriteRowResponse) String() string { return proto.CompactTextString(m) } +func (*BatchWriteRowResponse) ProtoMessage() {} +func (*BatchWriteRowResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{46} } + +func (m *BatchWriteRowResponse) GetTables() []*TableInBatchWriteRowResponse { + if m != nil { + return m.Tables + } + return nil +} + +// * +// HBase支持以下参数： +// 1. TimeRange或指定time +// 2. Filter（根据列值或列名来过滤） +// 我们只支持给同版本的选择条件。 +type GetRangeRequest struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + Direction *Direction `protobuf:"varint,2,req,name=direction,enum=otsprotocol.Direction" json:"direction,omitempty"` + ColumnsToGet []string `protobuf:"bytes,3,rep,name=columns_to_get" json:"columns_to_get,omitempty"` + TimeRange *TimeRange `protobuf:"bytes,4,opt,name=time_range" json:"time_range,omitempty"` + MaxVersions *int32 `protobuf:"varint,5,opt,name=max_versions" json:"max_versions,omitempty"` + Limit *int32 `protobuf:"varint,6,opt,name=limit" json:"limit,omitempty"` + InclusiveStartPrimaryKey []byte `protobuf:"bytes,7,req,name=inclusive_start_primary_key" json:"inclusive_start_primary_key,omitempty"` + ExclusiveEndPrimaryKey []byte `protobuf:"bytes,8,req,name=exclusive_end_primary_key" json:"exclusive_end_primary_key,omitempty"` + CacheBlocks *bool `protobuf:"varint,9,opt,name=cache_blocks,def=1" json:"cache_blocks,omitempty"` + Filter []byte `protobuf:"bytes,10,opt,name=filter" json:"filter,omitempty"` + StartColumn *string `protobuf:"bytes,11,opt,name=start_column" json:"start_column,omitempty"` + EndColumn *string `protobuf:"bytes,12,opt,name=end_column" json:"end_column,omitempty"` + Token []byte `protobuf:"bytes,13,opt,name=token" json:"token,omitempty"` + TransactionId *string `protobuf:"bytes,14,opt,name=transaction_id" json:"transaction_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetRangeRequest) Reset() { *m = GetRangeRequest{} } +func (m *GetRangeRequest) String() string { return proto.CompactTextString(m) } +func (*GetRangeRequest) ProtoMessage() {} +func (*GetRangeRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{47} } + +const Default_GetRangeRequest_CacheBlocks bool = true + +func (m *GetRangeRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *GetRangeRequest) GetDirection() Direction { + if m != nil && m.Direction != nil { + return *m.Direction + } + return Direction_FORWARD +} + +func (m *GetRangeRequest) GetColumnsToGet() []string { + if m != nil { + return m.ColumnsToGet + } + return nil +} + +func (m *GetRangeRequest) GetTimeRange() *TimeRange { + if m != nil { + return m.TimeRange + } + return nil +} + +func (m *GetRangeRequest) GetMaxVersions() int32 { + if m != nil && m.MaxVersions != nil { + return *m.MaxVersions + } + return 0 +} + +func (m *GetRangeRequest) GetLimit() int32 { + if m != nil && m.Limit != nil { + return *m.Limit + } + return 0 +} + +func (m *GetRangeRequest) GetInclusiveStartPrimaryKey() []byte { + if m != nil { + return m.InclusiveStartPrimaryKey + } + return nil +} + +func (m *GetRangeRequest) GetExclusiveEndPrimaryKey() []byte { + if m != nil { + return m.ExclusiveEndPrimaryKey + } + return nil +} + +func (m *GetRangeRequest) GetCacheBlocks() bool { + if m != nil && m.CacheBlocks != nil { + return *m.CacheBlocks + } + return Default_GetRangeRequest_CacheBlocks +} + +func (m *GetRangeRequest) GetFilter() []byte { + if m != nil { + return m.Filter + } + return nil +} + +func (m *GetRangeRequest) GetStartColumn() string { + if m != nil && m.StartColumn != nil { + return *m.StartColumn + } + return "" +} + +func (m *GetRangeRequest) GetEndColumn() string { + if m != nil && m.EndColumn != nil { + return *m.EndColumn + } + return "" +} + +func (m *GetRangeRequest) GetToken() []byte { + if m != nil { + return m.Token + } + return nil +} + +func (m *GetRangeRequest) GetTransactionId() string { + if m != nil && m.TransactionId != nil { + return *m.TransactionId + } + return "" +} + +type GetRangeResponse struct { + Consumed *ConsumedCapacity `protobuf:"bytes,1,req,name=consumed" json:"consumed,omitempty"` + Rows []byte `protobuf:"bytes,2,req,name=rows" json:"rows,omitempty"` + NextStartPrimaryKey []byte `protobuf:"bytes,3,opt,name=next_start_primary_key" json:"next_start_primary_key,omitempty"` + NextToken []byte `protobuf:"bytes,4,opt,name=next_token" json:"next_token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetRangeResponse) Reset() { *m = GetRangeResponse{} } +func (m *GetRangeResponse) String() string { return proto.CompactTextString(m) } +func (*GetRangeResponse) ProtoMessage() {} +func (*GetRangeResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{48} } + +func (m *GetRangeResponse) GetConsumed() *ConsumedCapacity { + if m != nil { + return m.Consumed + } + return nil +} + +func (m *GetRangeResponse) GetRows() []byte { + if m != nil { + return m.Rows + } + return nil +} + +func (m *GetRangeResponse) GetNextStartPrimaryKey() []byte { + if m != nil { + return m.NextStartPrimaryKey + } + return nil +} + +func (m *GetRangeResponse) GetNextToken() []byte { + if m != nil { + return m.NextToken + } + return nil +} + +type ListStreamRequest struct { + TableName *string `protobuf:"bytes,1,opt,name=table_name" json:"table_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ListStreamRequest) Reset() { *m = ListStreamRequest{} } +func (m *ListStreamRequest) String() string { return proto.CompactTextString(m) } +func (*ListStreamRequest) ProtoMessage() {} +func (*ListStreamRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{49} } + +func (m *ListStreamRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +type Stream struct { + StreamId *string `protobuf:"bytes,1,req,name=stream_id" json:"stream_id,omitempty"` + TableName *string `protobuf:"bytes,2,req,name=table_name" json:"table_name,omitempty"` + CreationTime *int64 `protobuf:"varint,3,req,name=creation_time" json:"creation_time,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *Stream) Reset() { *m = Stream{} } +func (m *Stream) String() string { return proto.CompactTextString(m) } +func (*Stream) ProtoMessage() {} +func (*Stream) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{50} } + +func (m *Stream) GetStreamId() string { + if m != nil && m.StreamId != nil { + return *m.StreamId + } + return "" +} + +func (m *Stream) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *Stream) GetCreationTime() int64 { + if m != nil && m.CreationTime != nil { + return *m.CreationTime + } + return 0 +} + +type ListStreamResponse struct { + Streams []*Stream `protobuf:"bytes,1,rep,name=streams" json:"streams,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ListStreamResponse) Reset() { *m = ListStreamResponse{} } +func (m *ListStreamResponse) String() string { return proto.CompactTextString(m) } +func (*ListStreamResponse) ProtoMessage() {} +func (*ListStreamResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{51} } + +func (m *ListStreamResponse) GetStreams() []*Stream { + if m != nil { + return m.Streams + } + return nil +} + +type StreamShard struct { + ShardId *string `protobuf:"bytes,1,req,name=shard_id" json:"shard_id,omitempty"` + ParentId *string `protobuf:"bytes,2,opt,name=parent_id" json:"parent_id,omitempty"` + ParentSiblingId *string `protobuf:"bytes,3,opt,name=parent_sibling_id" json:"parent_sibling_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *StreamShard) Reset() { *m = StreamShard{} } +func (m *StreamShard) String() string { return proto.CompactTextString(m) } +func (*StreamShard) ProtoMessage() {} +func (*StreamShard) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{52} } + +func (m *StreamShard) GetShardId() string { + if m != nil && m.ShardId != nil { + return *m.ShardId + } + return "" +} + +func (m *StreamShard) GetParentId() string { + if m != nil && m.ParentId != nil { + return *m.ParentId + } + return "" +} + +func (m *StreamShard) GetParentSiblingId() string { + if m != nil && m.ParentSiblingId != nil { + return *m.ParentSiblingId + } + return "" +} + +type DescribeStreamRequest struct { + StreamId *string `protobuf:"bytes,1,req,name=stream_id" json:"stream_id,omitempty"` + InclusiveStartShardId *string `protobuf:"bytes,2,opt,name=inclusive_start_shard_id" json:"inclusive_start_shard_id,omitempty"` + ShardLimit *int32 `protobuf:"varint,3,opt,name=shard_limit" json:"shard_limit,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DescribeStreamRequest) Reset() { *m = DescribeStreamRequest{} } +func (m *DescribeStreamRequest) String() string { return proto.CompactTextString(m) } +func (*DescribeStreamRequest) ProtoMessage() {} +func (*DescribeStreamRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{53} } + +func (m *DescribeStreamRequest) GetStreamId() string { + if m != nil && m.StreamId != nil { + return *m.StreamId + } + return "" +} + +func (m *DescribeStreamRequest) GetInclusiveStartShardId() string { + if m != nil && m.InclusiveStartShardId != nil { + return *m.InclusiveStartShardId + } + return "" +} + +func (m *DescribeStreamRequest) GetShardLimit() int32 { + if m != nil && m.ShardLimit != nil { + return *m.ShardLimit + } + return 0 +} + +type DescribeStreamResponse struct { + StreamId *string `protobuf:"bytes,1,req,name=stream_id" json:"stream_id,omitempty"` + ExpirationTime *int32 `protobuf:"varint,2,req,name=expiration_time" json:"expiration_time,omitempty"` + TableName *string `protobuf:"bytes,3,req,name=table_name" json:"table_name,omitempty"` + CreationTime *int64 `protobuf:"varint,4,req,name=creation_time" json:"creation_time,omitempty"` + StreamStatus *StreamStatus `protobuf:"varint,5,req,name=stream_status,enum=otsprotocol.StreamStatus" json:"stream_status,omitempty"` + Shards []*StreamShard `protobuf:"bytes,6,rep,name=shards" json:"shards,omitempty"` + NextShardId *string `protobuf:"bytes,7,opt,name=next_shard_id" json:"next_shard_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DescribeStreamResponse) Reset() { *m = DescribeStreamResponse{} } +func (m *DescribeStreamResponse) String() string { return proto.CompactTextString(m) } +func (*DescribeStreamResponse) ProtoMessage() {} +func (*DescribeStreamResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{54} } + +func (m *DescribeStreamResponse) GetStreamId() string { + if m != nil && m.StreamId != nil { + return *m.StreamId + } + return "" +} + +func (m *DescribeStreamResponse) GetExpirationTime() int32 { + if m != nil && m.ExpirationTime != nil { + return *m.ExpirationTime + } + return 0 +} + +func (m *DescribeStreamResponse) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *DescribeStreamResponse) GetCreationTime() int64 { + if m != nil && m.CreationTime != nil { + return *m.CreationTime + } + return 0 +} + +func (m *DescribeStreamResponse) GetStreamStatus() StreamStatus { + if m != nil && m.StreamStatus != nil { + return *m.StreamStatus + } + return StreamStatus_STREAM_ENABLING +} + +func (m *DescribeStreamResponse) GetShards() []*StreamShard { + if m != nil { + return m.Shards + } + return nil +} + +func (m *DescribeStreamResponse) GetNextShardId() string { + if m != nil && m.NextShardId != nil { + return *m.NextShardId + } + return "" +} + +type GetShardIteratorRequest struct { + StreamId *string `protobuf:"bytes,1,req,name=stream_id" json:"stream_id,omitempty"` + ShardId *string `protobuf:"bytes,2,req,name=shard_id" json:"shard_id,omitempty"` + Timestamp *int64 `protobuf:"varint,3,opt,name=timestamp" json:"timestamp,omitempty"` + Token *string `protobuf:"bytes,4,opt,name=token" json:"token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetShardIteratorRequest) Reset() { *m = GetShardIteratorRequest{} } +func (m *GetShardIteratorRequest) String() string { return proto.CompactTextString(m) } +func (*GetShardIteratorRequest) ProtoMessage() {} +func (*GetShardIteratorRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{55} } + +func (m *GetShardIteratorRequest) GetStreamId() string { + if m != nil && m.StreamId != nil { + return *m.StreamId + } + return "" +} + +func (m *GetShardIteratorRequest) GetShardId() string { + if m != nil && m.ShardId != nil { + return *m.ShardId + } + return "" +} + +func (m *GetShardIteratorRequest) GetTimestamp() int64 { + if m != nil && m.Timestamp != nil { + return *m.Timestamp + } + return 0 +} + +func (m *GetShardIteratorRequest) GetToken() string { + if m != nil && m.Token != nil { + return *m.Token + } + return "" +} + +type GetShardIteratorResponse struct { + ShardIterator *string `protobuf:"bytes,1,req,name=shard_iterator" json:"shard_iterator,omitempty"` + NextToken *string `protobuf:"bytes,2,opt,name=next_token" json:"next_token,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetShardIteratorResponse) Reset() { *m = GetShardIteratorResponse{} } +func (m *GetShardIteratorResponse) String() string { return proto.CompactTextString(m) } +func (*GetShardIteratorResponse) ProtoMessage() {} +func (*GetShardIteratorResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{56} } + +func (m *GetShardIteratorResponse) GetShardIterator() string { + if m != nil && m.ShardIterator != nil { + return *m.ShardIterator + } + return "" +} + +func (m *GetShardIteratorResponse) GetNextToken() string { + if m != nil && m.NextToken != nil { + return *m.NextToken + } + return "" +} + +type GetStreamRecordRequest struct { + ShardIterator *string `protobuf:"bytes,1,req,name=shard_iterator" json:"shard_iterator,omitempty"` + Limit *int32 `protobuf:"varint,2,opt,name=limit" json:"limit,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetStreamRecordRequest) Reset() { *m = GetStreamRecordRequest{} } +func (m *GetStreamRecordRequest) String() string { return proto.CompactTextString(m) } +func (*GetStreamRecordRequest) ProtoMessage() {} +func (*GetStreamRecordRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{57} } + +func (m *GetStreamRecordRequest) GetShardIterator() string { + if m != nil && m.ShardIterator != nil { + return *m.ShardIterator + } + return "" +} + +func (m *GetStreamRecordRequest) GetLimit() int32 { + if m != nil && m.Limit != nil { + return *m.Limit + } + return 0 +} + +type GetStreamRecordResponse struct { + StreamRecords []*GetStreamRecordResponse_StreamRecord `protobuf:"bytes,1,rep,name=stream_records" json:"stream_records,omitempty"` + NextShardIterator *string `protobuf:"bytes,2,opt,name=next_shard_iterator" json:"next_shard_iterator,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetStreamRecordResponse) Reset() { *m = GetStreamRecordResponse{} } +func (m *GetStreamRecordResponse) String() string { return proto.CompactTextString(m) } +func (*GetStreamRecordResponse) ProtoMessage() {} +func (*GetStreamRecordResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{58} } + +func (m *GetStreamRecordResponse) GetStreamRecords() []*GetStreamRecordResponse_StreamRecord { + if m != nil { + return m.StreamRecords + } + return nil +} + +func (m *GetStreamRecordResponse) GetNextShardIterator() string { + if m != nil && m.NextShardIterator != nil { + return *m.NextShardIterator + } + return "" +} + +type GetStreamRecordResponse_StreamRecord struct { + ActionType *ActionType `protobuf:"varint,1,req,name=action_type,enum=otsprotocol.ActionType" json:"action_type,omitempty"` + Record []byte `protobuf:"bytes,2,req,name=record" json:"record,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *GetStreamRecordResponse_StreamRecord) Reset() { *m = GetStreamRecordResponse_StreamRecord{} } +func (m *GetStreamRecordResponse_StreamRecord) String() string { return proto.CompactTextString(m) } +func (*GetStreamRecordResponse_StreamRecord) ProtoMessage() {} +func (*GetStreamRecordResponse_StreamRecord) Descriptor() ([]byte, []int) { + return fileDescriptor2, []int{58, 0} +} + +func (m *GetStreamRecordResponse_StreamRecord) GetActionType() ActionType { + if m != nil && m.ActionType != nil { + return *m.ActionType + } + return ActionType_PUT_ROW +} + +func (m *GetStreamRecordResponse_StreamRecord) GetRecord() []byte { + if m != nil { + return m.Record + } + return nil +} + +// +++++ ComputeSplitPointsBySize +++++ +type ComputeSplitPointsBySizeRequest struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + SplitSize *int64 `protobuf:"varint,2,req,name=split_size" json:"split_size,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ComputeSplitPointsBySizeRequest) Reset() { *m = ComputeSplitPointsBySizeRequest{} } +func (m *ComputeSplitPointsBySizeRequest) String() string { return proto.CompactTextString(m) } +func (*ComputeSplitPointsBySizeRequest) ProtoMessage() {} +func (*ComputeSplitPointsBySizeRequest) Descriptor() ([]byte, []int) { + return fileDescriptor2, []int{59} +} + +func (m *ComputeSplitPointsBySizeRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *ComputeSplitPointsBySizeRequest) GetSplitSize() int64 { + if m != nil && m.SplitSize != nil { + return *m.SplitSize + } + return 0 +} + +type ComputeSplitPointsBySizeResponse struct { + Consumed *ConsumedCapacity `protobuf:"bytes,1,req,name=consumed" json:"consumed,omitempty"` + Schema []*PrimaryKeySchema `protobuf:"bytes,2,rep,name=schema" json:"schema,omitempty"` + // * + // Split points between splits, in the increasing order + // + // A split is a consecutive range of primary keys, + // whose data size is about split_size specified in the request. + // The size could be hard to be precise. + // + // A split point is an array of primary-key column w.r.t. table schema, + // which is never longer than that of table schema. + // Tailing -inf will be omitted to reduce transmission payloads. + SplitPoints [][]byte `protobuf:"bytes,3,rep,name=split_points" json:"split_points,omitempty"` + Locations []*ComputeSplitPointsBySizeResponse_SplitLocation `protobuf:"bytes,4,rep,name=locations" json:"locations,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ComputeSplitPointsBySizeResponse) Reset() { *m = ComputeSplitPointsBySizeResponse{} } +func (m *ComputeSplitPointsBySizeResponse) String() string { return proto.CompactTextString(m) } +func (*ComputeSplitPointsBySizeResponse) ProtoMessage() {} +func (*ComputeSplitPointsBySizeResponse) Descriptor() ([]byte, []int) { + return fileDescriptor2, []int{60} +} + +func (m *ComputeSplitPointsBySizeResponse) GetConsumed() *ConsumedCapacity { + if m != nil { + return m.Consumed + } + return nil +} + +func (m *ComputeSplitPointsBySizeResponse) GetSchema() []*PrimaryKeySchema { + if m != nil { + return m.Schema + } + return nil +} + +func (m *ComputeSplitPointsBySizeResponse) GetSplitPoints() [][]byte { + if m != nil { + return m.SplitPoints + } + return nil +} + +func (m *ComputeSplitPointsBySizeResponse) GetLocations() []*ComputeSplitPointsBySizeResponse_SplitLocation { + if m != nil { + return m.Locations + } + return nil +} + +// * +// Locations where splits lies in. +// +// By the managed nature of TableStore, these locations are no more than hints. +// If a location is not suitable to be seen, an empty string will be placed. +type ComputeSplitPointsBySizeResponse_SplitLocation struct { + Location *string `protobuf:"bytes,1,req,name=location" json:"location,omitempty"` + Repeat *int64 `protobuf:"zigzag64,2,req,name=repeat" json:"repeat,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *ComputeSplitPointsBySizeResponse_SplitLocation) Reset() { + *m = ComputeSplitPointsBySizeResponse_SplitLocation{} +} +func (m *ComputeSplitPointsBySizeResponse_SplitLocation) String() string { + return proto.CompactTextString(m) +} +func (*ComputeSplitPointsBySizeResponse_SplitLocation) ProtoMessage() {} +func (*ComputeSplitPointsBySizeResponse_SplitLocation) Descriptor() ([]byte, []int) { + return fileDescriptor2, []int{60, 0} +} + +func (m *ComputeSplitPointsBySizeResponse_SplitLocation) GetLocation() string { + if m != nil && m.Location != nil { + return *m.Location + } + return "" +} + +func (m *ComputeSplitPointsBySizeResponse_SplitLocation) GetRepeat() int64 { + if m != nil && m.Repeat != nil { + return *m.Repeat + } + return 0 +} + +type DefinedColumnSchema struct { + Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"` + Type *DefinedColumnType `protobuf:"varint,2,req,name=type,enum=otsprotocol.DefinedColumnType" json:"type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DefinedColumnSchema) Reset() { *m = DefinedColumnSchema{} } +func (m *DefinedColumnSchema) String() string { return proto.CompactTextString(m) } +func (*DefinedColumnSchema) ProtoMessage() {} +func (*DefinedColumnSchema) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{61} } + +func (m *DefinedColumnSchema) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *DefinedColumnSchema) GetType() DefinedColumnType { + if m != nil && m.Type != nil { + return *m.Type + } + return DefinedColumnType_DCT_INTEGER +} + +type IndexMeta struct { + Name *string `protobuf:"bytes,1,req,name=name" json:"name,omitempty"` + PrimaryKey []string `protobuf:"bytes,2,rep,name=primary_key" json:"primary_key,omitempty"` + DefinedColumn []string `protobuf:"bytes,3,rep,name=defined_column" json:"defined_column,omitempty"` + IndexUpdateMode *IndexUpdateMode `protobuf:"varint,4,req,name=index_update_mode,enum=otsprotocol.IndexUpdateMode" json:"index_update_mode,omitempty"` + IndexType *IndexType `protobuf:"varint,5,req,name=index_type,enum=otsprotocol.IndexType" json:"index_type,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *IndexMeta) Reset() { *m = IndexMeta{} } +func (m *IndexMeta) String() string { return proto.CompactTextString(m) } +func (*IndexMeta) ProtoMessage() {} +func (*IndexMeta) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{62} } + +func (m *IndexMeta) GetName() string { + if m != nil && m.Name != nil { + return *m.Name + } + return "" +} + +func (m *IndexMeta) GetPrimaryKey() []string { + if m != nil { + return m.PrimaryKey + } + return nil +} + +func (m *IndexMeta) GetDefinedColumn() []string { + if m != nil { + return m.DefinedColumn + } + return nil +} + +func (m *IndexMeta) GetIndexUpdateMode() IndexUpdateMode { + if m != nil && m.IndexUpdateMode != nil { + return *m.IndexUpdateMode + } + return IndexUpdateMode_IUM_ASYNC_INDEX +} + +func (m *IndexMeta) GetIndexType() IndexType { + if m != nil && m.IndexType != nil { + return *m.IndexType + } + return IndexType_IT_GLOBAL_INDEX +} + +type CreateIndexRequest struct { + MainTableName *string `protobuf:"bytes,1,req,name=main_table_name" json:"main_table_name,omitempty"` + IndexMeta *IndexMeta `protobuf:"bytes,2,req,name=index_meta" json:"index_meta,omitempty"` + IncludeBaseData *bool `protobuf:"varint,3,opt,name=include_base_data" json:"include_base_data,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CreateIndexRequest) Reset() { *m = CreateIndexRequest{} } +func (m *CreateIndexRequest) String() string { return proto.CompactTextString(m) } +func (*CreateIndexRequest) ProtoMessage() {} +func (*CreateIndexRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{63} } + +func (m *CreateIndexRequest) GetMainTableName() string { + if m != nil && m.MainTableName != nil { + return *m.MainTableName + } + return "" +} + +func (m *CreateIndexRequest) GetIndexMeta() *IndexMeta { + if m != nil { + return m.IndexMeta + } + return nil +} + +func (m *CreateIndexRequest) GetIncludeBaseData() bool { + if m != nil && m.IncludeBaseData != nil { + return *m.IncludeBaseData + } + return false +} + +type CreateIndexResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CreateIndexResponse) Reset() { *m = CreateIndexResponse{} } +func (m *CreateIndexResponse) String() string { return proto.CompactTextString(m) } +func (*CreateIndexResponse) ProtoMessage() {} +func (*CreateIndexResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{64} } + +type DropIndexRequest struct { + MainTableName *string `protobuf:"bytes,1,req,name=main_table_name" json:"main_table_name,omitempty"` + IndexName *string `protobuf:"bytes,2,req,name=index_name" json:"index_name,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *DropIndexRequest) Reset() { *m = DropIndexRequest{} } +func (m *DropIndexRequest) String() string { return proto.CompactTextString(m) } +func (*DropIndexRequest) ProtoMessage() {} +func (*DropIndexRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{65} } + +func (m *DropIndexRequest) GetMainTableName() string { + if m != nil && m.MainTableName != nil { + return *m.MainTableName + } + return "" +} + +func (m *DropIndexRequest) GetIndexName() string { + if m != nil && m.IndexName != nil { + return *m.IndexName + } + return "" +} + +type DropIndexResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *DropIndexResponse) Reset() { *m = DropIndexResponse{} } +func (m *DropIndexResponse) String() string { return proto.CompactTextString(m) } +func (*DropIndexResponse) ProtoMessage() {} +func (*DropIndexResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{66} } + +// ########################################### LocalTransaction ########################################### +type StartLocalTransactionRequest struct { + TableName *string `protobuf:"bytes,1,req,name=table_name" json:"table_name,omitempty"` + Key []byte `protobuf:"bytes,2,req,name=key" json:"key,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *StartLocalTransactionRequest) Reset() { *m = StartLocalTransactionRequest{} } +func (m *StartLocalTransactionRequest) String() string { return proto.CompactTextString(m) } +func (*StartLocalTransactionRequest) ProtoMessage() {} +func (*StartLocalTransactionRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{67} } + +func (m *StartLocalTransactionRequest) GetTableName() string { + if m != nil && m.TableName != nil { + return *m.TableName + } + return "" +} + +func (m *StartLocalTransactionRequest) GetKey() []byte { + if m != nil { + return m.Key + } + return nil +} + +type StartLocalTransactionResponse struct { + TransactionId *string `protobuf:"bytes,1,req,name=transaction_id" json:"transaction_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *StartLocalTransactionResponse) Reset() { *m = StartLocalTransactionResponse{} } +func (m *StartLocalTransactionResponse) String() string { return proto.CompactTextString(m) } +func (*StartLocalTransactionResponse) ProtoMessage() {} +func (*StartLocalTransactionResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{68} } + +func (m *StartLocalTransactionResponse) GetTransactionId() string { + if m != nil && m.TransactionId != nil { + return *m.TransactionId + } + return "" +} + +type CommitTransactionRequest struct { + TransactionId *string `protobuf:"bytes,1,req,name=transaction_id" json:"transaction_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *CommitTransactionRequest) Reset() { *m = CommitTransactionRequest{} } +func (m *CommitTransactionRequest) String() string { return proto.CompactTextString(m) } +func (*CommitTransactionRequest) ProtoMessage() {} +func (*CommitTransactionRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{69} } + +func (m *CommitTransactionRequest) GetTransactionId() string { + if m != nil && m.TransactionId != nil { + return *m.TransactionId + } + return "" +} + +type CommitTransactionResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *CommitTransactionResponse) Reset() { *m = CommitTransactionResponse{} } +func (m *CommitTransactionResponse) String() string { return proto.CompactTextString(m) } +func (*CommitTransactionResponse) ProtoMessage() {} +func (*CommitTransactionResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{70} } + +type AbortTransactionRequest struct { + TransactionId *string `protobuf:"bytes,1,req,name=transaction_id" json:"transaction_id,omitempty"` + XXX_unrecognized []byte `json:"-"` +} + +func (m *AbortTransactionRequest) Reset() { *m = AbortTransactionRequest{} } +func (m *AbortTransactionRequest) String() string { return proto.CompactTextString(m) } +func (*AbortTransactionRequest) ProtoMessage() {} +func (*AbortTransactionRequest) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{71} } + +func (m *AbortTransactionRequest) GetTransactionId() string { + if m != nil && m.TransactionId != nil { + return *m.TransactionId + } + return "" +} + +type AbortTransactionResponse struct { + XXX_unrecognized []byte `json:"-"` +} + +func (m *AbortTransactionResponse) Reset() { *m = AbortTransactionResponse{} } +func (m *AbortTransactionResponse) String() string { return proto.CompactTextString(m) } +func (*AbortTransactionResponse) ProtoMessage() {} +func (*AbortTransactionResponse) Descriptor() ([]byte, []int) { return fileDescriptor2, []int{72} } + +func init() { + proto.RegisterType((*Error)(nil), "otsprotocol.Error") + proto.RegisterType((*PrimaryKeySchema)(nil), "otsprotocol.PrimaryKeySchema") + proto.RegisterType((*PartitionRange)(nil), "otsprotocol.PartitionRange") + proto.RegisterType((*TableOptions)(nil), "otsprotocol.TableOptions") + proto.RegisterType((*TableMeta)(nil), "otsprotocol.TableMeta") + proto.RegisterType((*Condition)(nil), "otsprotocol.Condition") + proto.RegisterType((*CapacityUnit)(nil), "otsprotocol.CapacityUnit") + proto.RegisterType((*ReservedThroughputDetails)(nil), "otsprotocol.ReservedThroughputDetails") + proto.RegisterType((*ReservedThroughput)(nil), "otsprotocol.ReservedThroughput") + proto.RegisterType((*ConsumedCapacity)(nil), "otsprotocol.ConsumedCapacity") + proto.RegisterType((*StreamSpecification)(nil), "otsprotocol.StreamSpecification") + proto.RegisterType((*StreamDetails)(nil), "otsprotocol.StreamDetails") + proto.RegisterType((*CreateTableRequest)(nil), "otsprotocol.CreateTableRequest") + proto.RegisterType((*CreateTableResponse)(nil), "otsprotocol.CreateTableResponse") + proto.RegisterType((*UpdateTableRequest)(nil), "otsprotocol.UpdateTableRequest") + proto.RegisterType((*UpdateTableResponse)(nil), "otsprotocol.UpdateTableResponse") + proto.RegisterType((*DescribeTableRequest)(nil), "otsprotocol.DescribeTableRequest") + proto.RegisterType((*DescribeTableResponse)(nil), "otsprotocol.DescribeTableResponse") + proto.RegisterType((*ListTableRequest)(nil), "otsprotocol.ListTableRequest") + proto.RegisterType((*ListTableResponse)(nil), "otsprotocol.ListTableResponse") + proto.RegisterType((*DeleteTableRequest)(nil), "otsprotocol.DeleteTableRequest") + proto.RegisterType((*DeleteTableResponse)(nil), "otsprotocol.DeleteTableResponse") + proto.RegisterType((*LoadTableRequest)(nil), "otsprotocol.LoadTableRequest") + proto.RegisterType((*LoadTableResponse)(nil), "otsprotocol.LoadTableResponse") + proto.RegisterType((*UnloadTableRequest)(nil), "otsprotocol.UnloadTableRequest") + proto.RegisterType((*UnloadTableResponse)(nil), "otsprotocol.UnloadTableResponse") + proto.RegisterType((*TimeRange)(nil), "otsprotocol.TimeRange") + proto.RegisterType((*ReturnContent)(nil), "otsprotocol.ReturnContent") + proto.RegisterType((*GetRowRequest)(nil), "otsprotocol.GetRowRequest") + proto.RegisterType((*GetRowResponse)(nil), "otsprotocol.GetRowResponse") + proto.RegisterType((*UpdateRowRequest)(nil), "otsprotocol.UpdateRowRequest") + proto.RegisterType((*UpdateRowResponse)(nil), "otsprotocol.UpdateRowResponse") + proto.RegisterType((*PutRowRequest)(nil), "otsprotocol.PutRowRequest") + proto.RegisterType((*PutRowResponse)(nil), "otsprotocol.PutRowResponse") + proto.RegisterType((*DeleteRowRequest)(nil), "otsprotocol.DeleteRowRequest") + proto.RegisterType((*DeleteRowResponse)(nil), "otsprotocol.DeleteRowResponse") + proto.RegisterType((*TableInBatchGetRowRequest)(nil), "otsprotocol.TableInBatchGetRowRequest") + proto.RegisterType((*BatchGetRowRequest)(nil), "otsprotocol.BatchGetRowRequest") + proto.RegisterType((*RowInBatchGetRowResponse)(nil), "otsprotocol.RowInBatchGetRowResponse") + proto.RegisterType((*TableInBatchGetRowResponse)(nil), "otsprotocol.TableInBatchGetRowResponse") + proto.RegisterType((*BatchGetRowResponse)(nil), "otsprotocol.BatchGetRowResponse") + proto.RegisterType((*RowInBatchWriteRowRequest)(nil), "otsprotocol.RowInBatchWriteRowRequest") + proto.RegisterType((*TableInBatchWriteRowRequest)(nil), "otsprotocol.TableInBatchWriteRowRequest") + proto.RegisterType((*BatchWriteRowRequest)(nil), "otsprotocol.BatchWriteRowRequest") + proto.RegisterType((*RowInBatchWriteRowResponse)(nil), "otsprotocol.RowInBatchWriteRowResponse") + proto.RegisterType((*TableInBatchWriteRowResponse)(nil), "otsprotocol.TableInBatchWriteRowResponse") + proto.RegisterType((*BatchWriteRowResponse)(nil), "otsprotocol.BatchWriteRowResponse") + proto.RegisterType((*GetRangeRequest)(nil), "otsprotocol.GetRangeRequest") + proto.RegisterType((*GetRangeResponse)(nil), "otsprotocol.GetRangeResponse") + proto.RegisterType((*ListStreamRequest)(nil), "otsprotocol.ListStreamRequest") + proto.RegisterType((*Stream)(nil), "otsprotocol.Stream") + proto.RegisterType((*ListStreamResponse)(nil), "otsprotocol.ListStreamResponse") + proto.RegisterType((*StreamShard)(nil), "otsprotocol.StreamShard") + proto.RegisterType((*DescribeStreamRequest)(nil), "otsprotocol.DescribeStreamRequest") + proto.RegisterType((*DescribeStreamResponse)(nil), "otsprotocol.DescribeStreamResponse") + proto.RegisterType((*GetShardIteratorRequest)(nil), "otsprotocol.GetShardIteratorRequest") + proto.RegisterType((*GetShardIteratorResponse)(nil), "otsprotocol.GetShardIteratorResponse") + proto.RegisterType((*GetStreamRecordRequest)(nil), "otsprotocol.GetStreamRecordRequest") + proto.RegisterType((*GetStreamRecordResponse)(nil), "otsprotocol.GetStreamRecordResponse") + proto.RegisterType((*GetStreamRecordResponse_StreamRecord)(nil), "otsprotocol.GetStreamRecordResponse.StreamRecord") + proto.RegisterType((*ComputeSplitPointsBySizeRequest)(nil), "otsprotocol.ComputeSplitPointsBySizeRequest") + proto.RegisterType((*ComputeSplitPointsBySizeResponse)(nil), "otsprotocol.ComputeSplitPointsBySizeResponse") + proto.RegisterType((*ComputeSplitPointsBySizeResponse_SplitLocation)(nil), "otsprotocol.ComputeSplitPointsBySizeResponse.SplitLocation") + proto.RegisterType((*DefinedColumnSchema)(nil), "otsprotocol.DefinedColumnSchema") + proto.RegisterType((*IndexMeta)(nil), "otsprotocol.IndexMeta") + proto.RegisterType((*CreateIndexRequest)(nil), "otsprotocol.CreateIndexRequest") + proto.RegisterType((*CreateIndexResponse)(nil), "otsprotocol.CreateIndexResponse") + proto.RegisterType((*DropIndexRequest)(nil), "otsprotocol.DropIndexRequest") + proto.RegisterType((*DropIndexResponse)(nil), "otsprotocol.DropIndexResponse") + proto.RegisterType((*StartLocalTransactionRequest)(nil), "otsprotocol.StartLocalTransactionRequest") + proto.RegisterType((*StartLocalTransactionResponse)(nil), "otsprotocol.StartLocalTransactionResponse") + proto.RegisterType((*CommitTransactionRequest)(nil), "otsprotocol.CommitTransactionRequest") + proto.RegisterType((*CommitTransactionResponse)(nil), "otsprotocol.CommitTransactionResponse") + proto.RegisterType((*AbortTransactionRequest)(nil), "otsprotocol.AbortTransactionRequest") + proto.RegisterType((*AbortTransactionResponse)(nil), "otsprotocol.AbortTransactionResponse") + proto.RegisterEnum("otsprotocol.PrimaryKeyType", PrimaryKeyType_name, PrimaryKeyType_value) + proto.RegisterEnum("otsprotocol.PrimaryKeyOption", PrimaryKeyOption_name, PrimaryKeyOption_value) + proto.RegisterEnum("otsprotocol.BloomFilterType", BloomFilterType_name, BloomFilterType_value) + proto.RegisterEnum("otsprotocol.TableStatus", TableStatus_name, TableStatus_value) + proto.RegisterEnum("otsprotocol.RowExistenceExpectation", RowExistenceExpectation_name, RowExistenceExpectation_value) + proto.RegisterEnum("otsprotocol.ReturnType", ReturnType_name, ReturnType_value) + proto.RegisterEnum("otsprotocol.OperationType", OperationType_name, OperationType_value) + proto.RegisterEnum("otsprotocol.Direction", Direction_name, Direction_value) + proto.RegisterEnum("otsprotocol.StreamStatus", StreamStatus_name, StreamStatus_value) + proto.RegisterEnum("otsprotocol.ActionType", ActionType_name, ActionType_value) + proto.RegisterEnum("otsprotocol.DefinedColumnType", DefinedColumnType_name, DefinedColumnType_value) + proto.RegisterEnum("otsprotocol.IndexUpdateMode", IndexUpdateMode_name, IndexUpdateMode_value) + proto.RegisterEnum("otsprotocol.IndexType", IndexType_name, IndexType_value) +} + +func init() { proto.RegisterFile("table_store.proto", fileDescriptor2) } + +var fileDescriptor2 = []byte{ + // 2751 bytes of a gzipped FileDescriptorProto + 0x1f, 0x8b, 0x08, 0x00, 0x00, 0x09, 0x6e, 0x88, 0x02, 0xff, 0xc4, 0x59, 0x5b, 0x6f, 0xe3, 0xc6, + 0xf5, 0x0f, 0x49, 0x5d, 0xac, 0xa3, 0x8b, 0x29, 0x6a, 0x6d, 0xcb, 0xf6, 0x26, 0x71, 0xf8, 0x4f, + 0x36, 0x5a, 0x65, 0xe3, 0x24, 0xfe, 0x27, 0xd9, 0x5c, 0x0a, 0x04, 0xb2, 0x24, 0xbb, 0xc2, 0xca, + 0x92, 0x23, 0xd3, 0x4d, 0xb6, 0x2f, 0x2c, 0x4d, 0xce, 0xda, 0xc4, 0x4a, 0xa4, 0x4a, 0x8e, 0xd6, + 0xf6, 0xbe, 0x16, 0x79, 0x2b, 0xd0, 0x0f, 0x50, 0xa0, 0xaf, 0x7d, 0x28, 0x50, 0xa0, 0x7d, 0x6a, + 0x3f, 0x40, 0x81, 0xbe, 0xe5, 0x3b, 0xf4, 0xad, 0x5f, 0xa2, 0x28, 0xe6, 0x42, 0x89, 0xa4, 0x28, + 0xcb, 0xbb, 0x49, 0xba, 0x6f, 0xe4, 0xcc, 0x9c, 0xdb, 0xef, 0x9c, 0x39, 0x73, 0xe6, 0x0c, 0x94, + 0xb1, 0x71, 0x36, 0x44, 0xba, 0x8f, 0x5d, 0x0f, 0xed, 0x8e, 0x3d, 0x17, 0xbb, 0x4a, 0xde, 0xc5, + 0x3e, 0xfd, 0x32, 0xdd, 0xa1, 0x7a, 0x0f, 0xd2, 0x6d, 0xcf, 0x73, 0x3d, 0xa5, 0x00, 0x29, 0xd3, + 0xb5, 0x50, 0x55, 0xd8, 0x11, 0x6b, 0x39, 0x65, 0x15, 0xb2, 0x23, 0xe4, 0xfb, 0xc6, 0x39, 0xaa, + 0x8a, 0x3b, 0x42, 0x2d, 0xa7, 0x3e, 0x07, 0xf9, 0xd8, 0xb3, 0x47, 0x86, 0x77, 0xfd, 0x08, 0x5d, + 0x9f, 0x98, 0x17, 0x68, 0x64, 0x10, 0x12, 0xc7, 0x18, 0x05, 0x24, 0xf7, 0x21, 0x85, 0xaf, 0xc7, + 0x64, 0xbd, 0x58, 0x2b, 0xed, 0x6d, 0xef, 0x86, 0xa4, 0xec, 0xce, 0x48, 0xb5, 0xeb, 0x31, 0x52, + 0xde, 0x87, 0x8c, 0x3b, 0xc6, 0xb6, 0xeb, 0x54, 0xa5, 0x1d, 0xa1, 0x56, 0xda, 0x7b, 0x7d, 0xc1, + 0xe2, 0x3e, 0x5d, 0xa4, 0x3e, 0x80, 0xd2, 0xb1, 0xe1, 0x61, 0x9b, 0xfc, 0x0c, 0x0c, 0xe7, 0x1c, + 0x29, 0x45, 0x48, 0x9f, 0xa1, 0x73, 0xdb, 0xa1, 0xa2, 0x0b, 0x4a, 0x1e, 0x24, 0xe4, 0x58, 0x54, + 0x72, 0x41, 0xfd, 0xb3, 0x00, 0x05, 0x8d, 0x18, 0xcd, 0xa8, 0x7d, 0xe5, 0x0e, 0x14, 0xb0, 0x3d, + 0x42, 0x3a, 0x76, 0xf5, 0xa1, 0xfd, 0x8c, 0xa8, 0x2b, 0xd4, 0xd2, 0x64, 0x74, 0x64, 0x5c, 0xe9, + 0xcf, 0x90, 0xe7, 0x93, 0x55, 0xd4, 0xcc, 0xb4, 0xf2, 0x10, 0xca, 0x67, 0x43, 0xd7, 0x1d, 0xe9, + 0x4f, 0xec, 0x21, 0x46, 0x9e, 0x4e, 0x2d, 0x62, 0x4a, 0xde, 0x8d, 0x28, 0xb9, 0x4f, 0x56, 0x1d, + 0xd0, 0x45, 0xd4, 0x24, 0x05, 0xe0, 0x6c, 0xe8, 0x9a, 0x4f, 0x75, 0xdf, 0x7e, 0x8e, 0xaa, 0x29, + 0xca, 0xec, 0x1d, 0x78, 0xdd, 0x42, 0xcf, 0x6c, 0x83, 0xa8, 0xa1, 0x9b, 0x68, 0x38, 0x0c, 0xa4, + 0xe9, 0xb6, 0xa3, 0xfb, 0xc8, 0xac, 0xa6, 0x77, 0x84, 0x9a, 0xa4, 0xfe, 0x5d, 0x80, 0x1c, 0x55, + 0xf8, 0x08, 0x61, 0x83, 0x30, 0x62, 0x2e, 0x0b, 0x41, 0xbb, 0x07, 0xf9, 0x31, 0x03, 0x45, 0x7f, + 0x8a, 0xae, 0xab, 0xe2, 0x8e, 0x54, 0xcb, 0x2f, 0x04, 0x8d, 0x3b, 0xe7, 0x33, 0x28, 0x59, 0xe8, + 0x89, 0xed, 0x20, 0x4b, 0x37, 0xdd, 0xe1, 0x64, 0x44, 0xb0, 0x26, 0x64, 0x3b, 0x11, 0xb2, 0x16, + 0x5b, 0xd2, 0xa4, 0x2b, 0x38, 0x65, 0x1d, 0xc0, 0x76, 0x2c, 0x74, 0xa5, 0x8f, 0x10, 0x36, 0xaa, + 0x29, 0x4a, 0xb5, 0x1e, 0xa1, 0xea, 0x90, 0x69, 0xa2, 0xad, 0x7a, 0x06, 0xb9, 0xa6, 0xeb, 0x58, + 0xd4, 0x35, 0xca, 0x97, 0x50, 0xf4, 0xdc, 0x4b, 0x1d, 0x5d, 0xd9, 0x3e, 0x46, 0x8e, 0xc9, 0xb4, + 0x2f, 0xed, 0xbd, 0x1d, 0xa1, 0x1d, 0xb8, 0x97, 0xed, 0x60, 0x41, 0xfb, 0x6a, 0x8c, 0x4c, 0x4c, + 0xf1, 0x51, 0xaa, 0x20, 0x33, 0x3d, 0x75, 0x33, 0x60, 0x48, 0x7d, 0x52, 0x50, 0xdf, 0x83, 0x42, + 0xd3, 0x18, 0x1b, 0xa6, 0x8d, 0xaf, 0x4f, 0x1d, 0x1b, 0x93, 0xb0, 0xf3, 0x90, 0x61, 0x71, 0x3f, + 0x16, 0x21, 0x7d, 0xe9, 0xd9, 0x98, 0xc5, 0x69, 0x5a, 0xfd, 0x4e, 0x80, 0xcd, 0x01, 0xf2, 0x91, + 0xf7, 0x0c, 0x59, 0xda, 0x85, 0xe7, 0x4e, 0xce, 0x2f, 0xc6, 0x13, 0xdc, 0x42, 0xd8, 0xb0, 0x87, + 0xbe, 0xf2, 0x21, 0x14, 0x4d, 0xce, 0x4a, 0x9f, 0x38, 0x36, 0xa6, 0x1a, 0xe6, 0xf7, 0x36, 0x23, + 0x1a, 0x46, 0x84, 0x6d, 0x81, 0x32, 0x34, 0x7c, 0xac, 0xdb, 0x8e, 0xe9, 0x21, 0xc3, 0x47, 0x3a, + 0x09, 0x25, 0x1a, 0x69, 0xd2, 0x74, 0xce, 0x42, 0xe1, 0x39, 0x89, 0x3a, 0xf5, 0x00, 0x94, 0x79, + 0x35, 0x5e, 0x5c, 0xbe, 0xda, 0x02, 0xb9, 0xe9, 0x3a, 0xfe, 0x64, 0x84, 0xac, 0x60, 0xfc, 0x25, + 0xb8, 0xb4, 0xa1, 0x72, 0x82, 0x3d, 0x64, 0x8c, 0x4e, 0xc6, 0xc8, 0xb4, 0x9f, 0xd8, 0x26, 0xc3, + 0x7c, 0x0d, 0x8a, 0xc8, 0xe1, 0xf9, 0x81, 0xcc, 0x52, 0x46, 0x2b, 0xca, 0x06, 0xac, 0xa2, 0xab, + 0xb1, 0xed, 0xb1, 0xc0, 0xe5, 0x06, 0x13, 0x70, 0x87, 0x50, 0x64, 0x6c, 0x02, 0x3c, 0x17, 0x30, + 0x28, 0x43, 0x8e, 0xfd, 0xeb, 0xb6, 0xc5, 0xf2, 0x47, 0x12, 0x4f, 0x89, 0xfa, 0xaf, 0x0a, 0x32, + 0x05, 0x91, 0xf3, 0xa1, 0x33, 0x29, 0x0a, 0xe1, 0x3f, 0x44, 0x50, 0x9a, 0x1e, 0x32, 0x30, 0xa2, + 0xbb, 0x63, 0x80, 0x7e, 0x3d, 0x41, 0x3e, 0x26, 0xe1, 0xc9, 0x36, 0x08, 0x0d, 0x4f, 0x66, 0x7a, + 0x34, 0x3c, 0x67, 0x9b, 0xe9, 0x67, 0x50, 0xf1, 0xb8, 0x17, 0x74, 0x3c, 0x75, 0x03, 0x75, 0x5f, + 0x7e, 0xef, 0xcd, 0x68, 0x5c, 0x26, 0x7a, 0x8b, 0x49, 0x62, 0xc9, 0xca, 0xa7, 0x1a, 0xc7, 0x71, + 0x8e, 0xa4, 0x9a, 0x0f, 0x00, 0xc6, 0x41, 0xa6, 0xf2, 0xf9, 0xd6, 0x89, 0x65, 0xc2, 0x68, 0x22, + 0xfb, 0x04, 0xf2, 0x1c, 0x29, 0x7f, 0xcc, 0x13, 0x42, 0x7c, 0x8b, 0x26, 0x39, 0xee, 0x3d, 0xc8, + 0xcf, 0xb6, 0xa8, 0x5f, 0xcd, 0xde, 0xb8, 0x47, 0xd7, 0xa0, 0x12, 0x81, 0xd1, 0x1f, 0xbb, 0x8e, + 0x8f, 0xd4, 0xef, 0x05, 0x50, 0x4e, 0xc7, 0x56, 0x1c, 0xde, 0xa4, 0xfc, 0xb3, 0x10, 0x46, 0xe1, + 0xa7, 0x81, 0x31, 0x86, 0x4a, 0xea, 0x76, 0xa8, 0xa8, 0xff, 0x14, 0xa0, 0x12, 0xb1, 0x88, 0x59, + 0xaa, 0x3c, 0x82, 0xed, 0x04, 0xf5, 0x75, 0x8b, 0x05, 0x31, 0x0f, 0xa1, 0x7b, 0x4b, 0xcc, 0x08, + 0xa5, 0x90, 0xa8, 0x35, 0x62, 0xc2, 0xe6, 0x8b, 0x58, 0xb3, 0x07, 0x25, 0x6e, 0x4d, 0x20, 0x91, + 0x01, 0xb0, 0x95, 0x60, 0x10, 0x97, 0xa2, 0xd6, 0xe1, 0x4e, 0x0b, 0xf9, 0xa6, 0x67, 0x9f, 0x2d, + 0xf5, 0x8e, 0xfa, 0x6f, 0x11, 0xd6, 0x62, 0x8b, 0xb9, 0xe1, 0x2f, 0xb2, 0x55, 0x96, 0x80, 0x24, + 0xfe, 0x30, 0x90, 0xa4, 0x65, 0x20, 0xed, 0x42, 0x21, 0xa8, 0x54, 0x0c, 0x3c, 0x21, 0x7b, 0x87, + 0x1c, 0x1d, 0xd5, 0x79, 0x82, 0x13, 0x3a, 0x9f, 0x00, 0x6a, 0x7a, 0x19, 0xa8, 0xe4, 0xc8, 0xf7, + 0x2f, 0x0c, 0xcf, 0xd2, 0xfd, 0xf1, 0xd0, 0xc6, 0x7e, 0x35, 0xb3, 0x23, 0xd5, 0x0a, 0xf1, 0xbd, + 0xb4, 0x72, 0xe3, 0x5e, 0x52, 0x40, 0xee, 0xda, 0x3e, 0x0e, 0xfb, 0x44, 0xad, 0x41, 0x39, 0x34, + 0xc6, 0xa1, 0xaf, 0x40, 0x7e, 0xe6, 0x28, 0x12, 0x63, 0x52, 0x2d, 0xa7, 0xd6, 0x40, 0x69, 0xa1, + 0x21, 0x5a, 0xbe, 0xe3, 0xc8, 0x9e, 0x8d, 0xac, 0xe4, 0x7b, 0xf6, 0x1e, 0xc8, 0x5d, 0xd7, 0xb0, + 0x96, 0x92, 0x57, 0xa0, 0x1c, 0x5a, 0xc7, 0x89, 0x6b, 0xa0, 0x9c, 0x3a, 0xc3, 0xdb, 0x90, 0xaf, + 0x41, 0x25, 0xb2, 0x92, 0x33, 0xf8, 0x39, 0xe4, 0x34, 0x7b, 0x84, 0x58, 0xe6, 0x52, 0x00, 0x7c, + 0x6c, 0x78, 0x98, 0x65, 0x6c, 0x72, 0x16, 0x4b, 0x8a, 0x0c, 0x2b, 0xc8, 0xb1, 0x66, 0x27, 0x86, + 0x44, 0x0e, 0x08, 0x9f, 0xef, 0xd1, 0xf0, 0xe9, 0xf8, 0x4b, 0x28, 0x0e, 0x10, 0x9e, 0x78, 0x4e, + 0xd3, 0x75, 0x30, 0x72, 0xb0, 0xf2, 0x00, 0xf2, 0x1e, 0x1d, 0x60, 0x15, 0x97, 0x40, 0x2b, 0xae, + 0x8d, 0x58, 0xb4, 0x91, 0x79, 0x5a, 0x6c, 0x6d, 0x93, 0x7c, 0x44, 0x57, 0xf3, 0x92, 0x81, 0x81, + 0x2c, 0x52, 0x90, 0x7f, 0x27, 0x42, 0xf1, 0x10, 0xe1, 0x81, 0x7b, 0x79, 0x53, 0x4a, 0xab, 0xc4, + 0x4b, 0x2a, 0x52, 0x47, 0xae, 0x43, 0x89, 0x31, 0xf4, 0x49, 0xb1, 0x78, 0x8e, 0x30, 0xad, 0x99, + 0x72, 0x74, 0x1f, 0x91, 0x0a, 0xd2, 0x23, 0x96, 0xf3, 0x74, 0x14, 0xdb, 0x47, 0x53, 0x5c, 0xe2, + 0x75, 0x65, 0x9a, 0x9e, 0x72, 0x5b, 0x50, 0x30, 0x0d, 0xf3, 0x02, 0xe9, 0xb4, 0x48, 0x24, 0xa1, + 0x27, 0xd4, 0x56, 0xbe, 0x48, 0x61, 0x6f, 0x82, 0x94, 0x12, 0x64, 0x58, 0xb5, 0x59, 0xcd, 0x92, + 0x7a, 0x87, 0x86, 0x29, 0x45, 0x96, 0xd7, 0x6d, 0x2b, 0xf4, 0x00, 0x55, 0x00, 0x08, 0xb6, 0x7c, + 0x2c, 0x47, 0xc7, 0x8a, 0x90, 0xc6, 0xee, 0x53, 0xe4, 0x54, 0x81, 0x12, 0xae, 0x43, 0x09, 0x7b, + 0x86, 0xe3, 0x1b, 0x26, 0x3d, 0x64, 0x6d, 0xab, 0x9a, 0xa7, 0xb5, 0xfb, 0x19, 0x94, 0x02, 0x40, + 0x78, 0x74, 0x7e, 0x00, 0x2b, 0x26, 0xaf, 0x2a, 0x78, 0x5a, 0x88, 0x56, 0x93, 0x73, 0x25, 0x47, + 0x1e, 0x24, 0xcf, 0xbd, 0xe4, 0x30, 0x29, 0x00, 0x0e, 0xba, 0xc2, 0x3a, 0x93, 0x2d, 0xd1, 0x22, + 0xed, 0x2f, 0x02, 0xc8, 0x2c, 0xf7, 0x2e, 0x01, 0x5e, 0x01, 0x20, 0x45, 0xa2, 0x79, 0x41, 0xb1, + 0x64, 0x0c, 0xef, 0x43, 0x6e, 0x56, 0xf4, 0x49, 0x09, 0x69, 0x6a, 0x56, 0x63, 0xee, 0x41, 0x69, + 0xea, 0x7a, 0x1a, 0x3a, 0xdc, 0x1d, 0x5b, 0x09, 0xb1, 0x12, 0x04, 0xd7, 0x3c, 0x2e, 0x69, 0x8a, + 0xcb, 0xd7, 0x50, 0x0e, 0xa9, 0xfc, 0x83, 0xa1, 0x21, 0x30, 0xfc, 0x51, 0x80, 0xe2, 0xf1, 0x64, + 0x59, 0xf0, 0x45, 0xd0, 0x7c, 0x45, 0xc6, 0xf7, 0xa0, 0x14, 0x28, 0xfa, 0xa3, 0x58, 0xfe, 0x57, + 0x01, 0x64, 0x96, 0xb2, 0x5e, 0x66, 0xe7, 0xbd, 0xba, 0x08, 0x08, 0xe9, 0xfc, 0xa3, 0xe0, 0xf0, + 0x1b, 0x11, 0x36, 0x69, 0xda, 0xec, 0x38, 0xfb, 0x06, 0x36, 0x2f, 0x5e, 0x22, 0x15, 0x91, 0x53, + 0x69, 0xba, 0xb5, 0x25, 0xfa, 0x3b, 0x9f, 0x99, 0x52, 0x09, 0x99, 0x29, 0xfd, 0x42, 0x99, 0x29, + 0x93, 0x98, 0x99, 0xb2, 0x89, 0x99, 0x69, 0x25, 0x31, 0x33, 0xe5, 0x12, 0x32, 0x13, 0x50, 0x60, + 0xbb, 0xa0, 0x24, 0x58, 0xff, 0x29, 0x64, 0xa8, 0xf5, 0xec, 0x3c, 0x8c, 0x97, 0x13, 0x0b, 0x51, + 0x53, 0xff, 0x20, 0x40, 0x75, 0xe0, 0x5e, 0xc6, 0xe6, 0xb8, 0xbb, 0x8a, 0x90, 0xb6, 0x7d, 0xdd, + 0x7d, 0xca, 0xef, 0x1e, 0x6f, 0x41, 0x1a, 0x79, 0x9e, 0xeb, 0xf1, 0xea, 0x54, 0x89, 0x88, 0x60, + 0xad, 0x8e, 0xb0, 0x83, 0x59, 0x29, 0x76, 0x3b, 0x07, 0xa7, 0x28, 0x08, 0xd1, 0xec, 0x97, 0xa6, + 0x4e, 0x47, 0xb0, 0x95, 0xa4, 0x3d, 0xd7, 0x30, 0xc9, 0xe9, 0xff, 0x0f, 0x29, 0xcf, 0xbd, 0xf4, + 0xf9, 0x5d, 0xfe, 0x9d, 0xf8, 0x15, 0x39, 0x91, 0x91, 0xda, 0x83, 0x4a, 0x12, 0xff, 0x87, 0x31, + 0x58, 0xdf, 0x5d, 0x0a, 0x2b, 0xe7, 0xf7, 0x37, 0x72, 0x59, 0x9e, 0x0a, 0xfb, 0x86, 0x5c, 0xa3, + 0x43, 0xde, 0xaa, 0xf1, 0x86, 0x0e, 0xbb, 0xc5, 0x47, 0xb7, 0x57, 0x7f, 0x8c, 0xd8, 0x55, 0x2e, + 0x68, 0x7e, 0xfc, 0x8f, 0x73, 0xba, 0x7a, 0x0e, 0xdb, 0x61, 0xc3, 0xe2, 0xba, 0x27, 0x41, 0xfe, + 0x71, 0x04, 0xf2, 0x7b, 0x0b, 0x20, 0x8f, 0x71, 0x52, 0x2f, 0xe0, 0x4e, 0xa2, 0x84, 0xcf, 0x62, + 0xa0, 0xd7, 0x16, 0x82, 0x1e, 0xa7, 0x9c, 0x4f, 0x46, 0xac, 0xc5, 0xf6, 0x5b, 0x01, 0xb6, 0x92, + 0xf4, 0x78, 0x35, 0x71, 0xae, 0xda, 0x70, 0x37, 0xd9, 0x8a, 0x1b, 0xa2, 0xfa, 0x93, 0x08, 0xc4, + 0xef, 0x2e, 0x85, 0x98, 0xc7, 0xe1, 0x00, 0xd6, 0x92, 0x65, 0x7c, 0x1e, 0x03, 0xf9, 0xfe, 0x2d, + 0x40, 0xe6, 0x3c, 0xff, 0x23, 0xc2, 0x2a, 0x09, 0x77, 0x12, 0x92, 0x37, 0x45, 0xc5, 0x7d, 0xc8, + 0x59, 0xb6, 0x87, 0x4c, 0xde, 0x70, 0x22, 0xa1, 0x1e, 0x8d, 0xd3, 0x56, 0x30, 0xfb, 0x13, 0x96, + 0x87, 0x45, 0x48, 0x0f, 0xed, 0x91, 0x8d, 0x79, 0x4e, 0xfe, 0x3f, 0xd8, 0xb6, 0x1d, 0x73, 0x38, + 0xf1, 0xed, 0x67, 0xf4, 0x42, 0xe4, 0x61, 0x3d, 0x7c, 0x42, 0x64, 0xe9, 0x06, 0x7b, 0x0b, 0x36, + 0xd1, 0x55, 0xb0, 0x88, 0x24, 0xe0, 0xf0, 0x92, 0x15, 0xba, 0x24, 0x9e, 0xdb, 0x73, 0x89, 0xb9, + 0x1d, 0x12, 0x73, 0x7b, 0x3e, 0x21, 0xb7, 0x17, 0xa2, 0x55, 0x67, 0x71, 0x41, 0xd5, 0x59, 0xa2, + 0xe1, 0xfc, 0x9d, 0x00, 0xf2, 0xcc, 0x01, 0x2f, 0x7b, 0xb6, 0x16, 0xa6, 0x11, 0x45, 0x0c, 0x7a, + 0x03, 0xd6, 0x69, 0xee, 0x9d, 0xc7, 0x44, 0x4a, 0xc8, 0xcd, 0x2c, 0x8e, 0xdf, 0x65, 0xd7, 0x33, + 0x76, 0x15, 0x5c, 0x14, 0x09, 0x44, 0xe1, 0x03, 0xc8, 0xb0, 0x45, 0xd1, 0xfe, 0xd5, 0xb4, 0x6c, + 0x0d, 0x11, 0x88, 0x74, 0x6c, 0x0d, 0x8a, 0xa6, 0x87, 0x22, 0x1d, 0x2d, 0xb1, 0x26, 0xa9, 0x5f, + 0x80, 0x12, 0x16, 0xc8, 0x2d, 0x7f, 0x1b, 0xb2, 0x8c, 0x67, 0x10, 0xcb, 0x95, 0x84, 0x9b, 0xaa, + 0x7a, 0x04, 0x79, 0xde, 0xd9, 0x20, 0x17, 0x55, 0x72, 0xa1, 0x62, 0x37, 0xd6, 0xa9, 0x1e, 0x65, + 0xc8, 0x8d, 0x0d, 0x0f, 0x39, 0x78, 0xd6, 0x5a, 0xdb, 0x84, 0x32, 0x1f, 0xf2, 0xed, 0xb3, 0xa1, + 0xed, 0x9c, 0x93, 0x29, 0x89, 0x9a, 0x64, 0xcc, 0x3a, 0x03, 0x51, 0xfb, 0x13, 0x2c, 0xdc, 0x81, + 0x6a, 0x3c, 0xe8, 0xa6, 0xb2, 0x99, 0xa0, 0x0a, 0xe4, 0xd9, 0x08, 0x8b, 0x55, 0xda, 0xbf, 0x53, + 0xff, 0x25, 0xc0, 0x7a, 0x5c, 0x06, 0x37, 0x39, 0x41, 0x48, 0x62, 0x6b, 0x51, 0xac, 0xa5, 0x63, + 0xf8, 0x4a, 0xc9, 0xf8, 0xa6, 0x68, 0xdb, 0xf5, 0x43, 0x28, 0x06, 0xdd, 0x21, 0xd6, 0x2b, 0x48, + 0xd3, 0x5d, 0xbb, 0x99, 0xd4, 0x1f, 0x62, 0xcd, 0x82, 0x1a, 0x64, 0xa8, 0xe2, 0xec, 0xca, 0x9f, + 0x8f, 0xb5, 0x15, 0xc2, 0x80, 0xaf, 0x41, 0x91, 0x05, 0x58, 0x60, 0x79, 0x96, 0xe2, 0xf8, 0x2b, + 0xd8, 0x38, 0x44, 0x98, 0x2e, 0xe9, 0x60, 0x72, 0xf2, 0xb9, 0xde, 0x0d, 0x48, 0x86, 0xbd, 0x26, + 0x06, 0x5e, 0x23, 0x06, 0xf8, 0xd8, 0x18, 0x8d, 0xd9, 0x15, 0x78, 0xb6, 0x8b, 0x52, 0x3c, 0xf8, + 0xaa, 0xf3, 0x12, 0x38, 0x8e, 0xeb, 0x50, 0xe2, 0xfc, 0xf8, 0xcc, 0x2c, 0x26, 0x43, 0xd1, 0xce, + 0x0e, 0x91, 0xaf, 0x60, 0x9d, 0xf0, 0xe1, 0x8e, 0x30, 0x5d, 0xcf, 0x0a, 0x1d, 0x3b, 0x89, 0x5c, + 0xa6, 0xb9, 0x87, 0xf5, 0x78, 0xbf, 0x17, 0x98, 0xad, 0x11, 0x0e, 0x5c, 0x91, 0xce, 0xb4, 0xe9, + 0xe2, 0xd1, 0x89, 0x20, 0x94, 0x3f, 0x8a, 0xe0, 0xb9, 0x80, 0x7a, 0x37, 0x3c, 0x48, 0xae, 0xf0, + 0x61, 0xa0, 0x03, 0x95, 0xa8, 0x11, 0x5b, 0x5d, 0x28, 0x44, 0x16, 0x3f, 0x80, 0x3c, 0xcf, 0x2e, + 0xa1, 0x82, 0x24, 0xda, 0x1d, 0x68, 0x98, 0xd3, 0x6a, 0xa4, 0x04, 0x19, 0xa6, 0x1e, 0x7f, 0x10, + 0xea, 0xc0, 0x9b, 0x4d, 0x77, 0x34, 0x9e, 0x60, 0x74, 0x32, 0x1e, 0xda, 0xf8, 0xd8, 0xb5, 0x1d, + 0xec, 0xef, 0x5f, 0x9f, 0xd8, 0xcf, 0xd1, 0x92, 0x8b, 0x2a, 0xed, 0x13, 0xb1, 0x17, 0x1d, 0xda, + 0xf1, 0x57, 0x7f, 0x2f, 0xc2, 0xce, 0x62, 0x5e, 0x2f, 0x9b, 0xe3, 0xde, 0x87, 0x8c, 0x4f, 0x9f, + 0x5e, 0x6e, 0xf7, 0xb2, 0x43, 0x32, 0x35, 0x55, 0x6c, 0x4c, 0xa5, 0xf3, 0x1b, 0x42, 0x0f, 0x72, + 0x43, 0x97, 0x35, 0x42, 0x83, 0xce, 0xf3, 0x97, 0x31, 0xb1, 0x37, 0xeb, 0xbd, 0x4b, 0x67, 0xba, + 0x9c, 0xc7, 0xd6, 0x47, 0x50, 0x8c, 0x0c, 0x90, 0xa8, 0x0e, 0x04, 0x70, 0x84, 0x28, 0xd0, 0x63, + 0x64, 0xb0, 0x86, 0xba, 0xa2, 0x7e, 0x0d, 0x95, 0xa4, 0xf7, 0xa4, 0xe8, 0x33, 0xe1, 0x83, 0xc8, + 0x33, 0xe1, 0x1b, 0x8b, 0x5f, 0xa3, 0x88, 0x2f, 0xd5, 0x3f, 0x09, 0x90, 0x9b, 0x76, 0xdf, 0x62, + 0x9c, 0x12, 0xee, 0x4d, 0x39, 0x12, 0xe5, 0x09, 0xcf, 0x5e, 0x39, 0xe5, 0x21, 0x94, 0x59, 0x97, + 0x6f, 0x42, 0x6f, 0xfc, 0xfa, 0xc8, 0xb5, 0x10, 0x6f, 0x32, 0xde, 0x9d, 0xef, 0xf5, 0xb1, 0xb6, + 0xc0, 0x91, 0x6b, 0xa1, 0xd9, 0x6b, 0x18, 0xd5, 0x3a, 0x9d, 0x50, 0x20, 0x50, 0x0a, 0xaa, 0x2d, + 0x0e, 0x1e, 0x2c, 0xe8, 0x50, 0x10, 0x5c, 0x1b, 0xb0, 0x3a, 0x32, 0x6c, 0x47, 0x9f, 0x8b, 0xb0, + 0xe8, 0x43, 0x9b, 0x98, 0x50, 0x23, 0xcf, 0x4c, 0xdf, 0x24, 0xfa, 0x9b, 0xc3, 0x89, 0x85, 0xf4, + 0x33, 0xc3, 0x47, 0xba, 0x65, 0x60, 0x83, 0x66, 0x92, 0x95, 0x59, 0x7f, 0x9f, 0x4b, 0xe5, 0x05, + 0xd0, 0x57, 0x20, 0xb7, 0x3c, 0x77, 0x7c, 0x3b, 0x55, 0x94, 0x40, 0x95, 0xd9, 0xf1, 0xa6, 0x56, + 0xa0, 0x1c, 0x62, 0x30, 0xe5, 0x7a, 0xf7, 0x84, 0x9c, 0x0d, 0x24, 0x2c, 0x86, 0xda, 0xec, 0xdc, + 0x5f, 0xd2, 0xee, 0x98, 0xde, 0xf4, 0xd5, 0x87, 0xf0, 0xfa, 0x02, 0x06, 0xb3, 0x6c, 0x17, 0xab, + 0x27, 0x58, 0x53, 0x72, 0x0f, 0xaa, 0x4d, 0x77, 0x34, 0xb2, 0x71, 0x82, 0xd4, 0x45, 0x34, 0xdb, + 0xb0, 0x99, 0x40, 0xc3, 0x4d, 0xf9, 0x08, 0x36, 0x1a, 0x67, 0xae, 0xf7, 0x22, 0xfc, 0xb6, 0xa0, + 0x3a, 0x4f, 0xc2, 0xd8, 0xd5, 0x3f, 0x81, 0x52, 0xec, 0x99, 0x3b, 0x0f, 0xd9, 0x4e, 0x4f, 0x6b, + 0x1f, 0xb6, 0x07, 0xb2, 0xa0, 0x00, 0x64, 0x4e, 0xb4, 0x41, 0xa7, 0x77, 0x28, 0x8b, 0xe4, 0x7b, + 0xbf, 0xd3, 0x6b, 0x0c, 0x1e, 0xcb, 0x52, 0xfd, 0x5e, 0xf8, 0x61, 0x9d, 0x75, 0xc3, 0x15, 0x05, + 0x4a, 0x8d, 0x53, 0xad, 0xaf, 0x77, 0x7a, 0xcd, 0x41, 0xfb, 0xa8, 0xdd, 0xd3, 0x64, 0xa1, 0xbe, + 0x0b, 0xab, 0xf1, 0x37, 0xe7, 0x15, 0x48, 0xf5, 0xfa, 0xbd, 0xb6, 0x2c, 0x90, 0xaf, 0x66, 0xbb, + 0xdb, 0x95, 0x45, 0x25, 0x0b, 0xd2, 0xa0, 0xff, 0x8d, 0x2c, 0xd5, 0xbf, 0x86, 0x7c, 0xb8, 0x5f, + 0x0e, 0x90, 0x69, 0x34, 0xb5, 0xce, 0x2f, 0xc8, 0xea, 0x02, 0xac, 0x74, 0x7a, 0xfc, 0x4f, 0x24, + 0x5a, 0x76, 0xfb, 0x8d, 0x16, 0xd1, 0x8c, 0x9c, 0x4a, 0xb9, 0xd3, 0x5e, 0xf0, 0x9b, 0x22, 0x2b, + 0x4f, 0x8f, 0x5b, 0x0d, 0x8d, 0xfc, 0xa5, 0xeb, 0x47, 0xb0, 0xb1, 0xe8, 0xf5, 0x16, 0x20, 0xd3, + 0x39, 0xec, 0xf5, 0x07, 0x6d, 0xf9, 0x35, 0x45, 0x86, 0x42, 0xfb, 0xdb, 0xe3, 0x76, 0x53, 0xd3, + 0xdb, 0xdf, 0x76, 0x4e, 0x34, 0x59, 0x50, 0xee, 0x80, 0xcc, 0x47, 0x7a, 0xfd, 0x60, 0x54, 0xac, + 0x7f, 0x0e, 0x10, 0xea, 0xe9, 0xe6, 0x21, 0x3b, 0x20, 0xf3, 0x3d, 0xc2, 0x22, 0x07, 0xe9, 0x81, + 0xa6, 0x1f, 0x3f, 0x92, 0x05, 0xa5, 0x02, 0xab, 0x03, 0x4d, 0x6f, 0x1c, 0x68, 0xed, 0x81, 0x7e, + 0xd4, 0x6f, 0x75, 0x0e, 0x1e, 0xcb, 0x62, 0xfd, 0x43, 0x28, 0x46, 0x6f, 0xa0, 0x59, 0x90, 0x8e, + 0x4f, 0x35, 0x06, 0x33, 0xd5, 0xb8, 0xcd, 0x60, 0x6e, 0xb5, 0xbb, 0x6d, 0xad, 0x4d, 0x61, 0xce, + 0xcd, 0x0a, 0xf9, 0x3c, 0x64, 0x0f, 0xfa, 0x83, 0x6f, 0x1a, 0x83, 0x96, 0xfc, 0x1a, 0xb1, 0x71, + 0xbf, 0xd1, 0x7c, 0x44, 0xff, 0x84, 0xfa, 0xa7, 0xc1, 0xd1, 0xc3, 0x71, 0xab, 0xc0, 0xea, 0x89, + 0x36, 0x68, 0x37, 0x8e, 0xf4, 0x76, 0xaf, 0xb1, 0xdf, 0x25, 0x40, 0x08, 0x4a, 0x19, 0x8a, 0x7c, + 0x30, 0x40, 0x91, 0x18, 0x13, 0x3a, 0x82, 0xf2, 0x90, 0x3d, 0x3e, 0xd5, 0x74, 0xe2, 0x09, 0x41, + 0x29, 0x01, 0x30, 0x95, 0xe8, 0xbf, 0x48, 0xfe, 0x99, 0x5a, 0x3a, 0xf3, 0x94, 0x09, 0xe5, 0xb9, + 0xc4, 0xa7, 0xac, 0x42, 0xbe, 0xd5, 0xd4, 0xf4, 0x59, 0xfc, 0x10, 0xaa, 0xa6, 0xa6, 0xb7, 0xfa, + 0xa7, 0xfb, 0x5d, 0x62, 0x1c, 0x5f, 0xb0, 0xdf, 0xef, 0x77, 0xdb, 0x8d, 0x9e, 0x2c, 0x05, 0x0b, + 0x78, 0x90, 0x51, 0xdf, 0xd1, 0x05, 0xdd, 0xfe, 0xbe, 0x9c, 0xad, 0x7f, 0x01, 0xab, 0xf1, 0xcc, + 0x56, 0x81, 0xd5, 0xce, 0xe9, 0x91, 0xde, 0x38, 0x79, 0xdc, 0x6b, 0xea, 0x9d, 0x5e, 0xab, 0xfd, + 0xad, 0xfc, 0x1a, 0x09, 0x3d, 0x32, 0x18, 0x1a, 0x13, 0xea, 0x1f, 0xf3, 0x1c, 0x4c, 0x15, 0x23, + 0x54, 0x9a, 0x7e, 0xd8, 0xed, 0xef, 0x37, 0xba, 0x11, 0x2a, 0x4d, 0xef, 0xf6, 0x9b, 0xd3, 0x31, + 0xe1, 0xbf, 0x01, 0x00, 0x00, 0xff, 0xff, 0x9a, 0x12, 0x13, 0xc3, 0x7a, 0x22, 0x00, 0x00, +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/table_store.proto b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/table_store.proto new file mode 100644 index 000000000000..a2fab70a18de --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol/table_store.proto @@ -0,0 +1,616 @@ +syntax = "proto2"; + +package otsprotocol; + +message Error { + required string code = 1; + optional string message = 2; +} + +enum PrimaryKeyType { + INTEGER = 1; + STRING = 2; + BINARY = 3; +} + +enum PrimaryKeyOption { + AUTO_INCREMENT = 1; +} + +message PrimaryKeySchema { + required string name = 1; + required PrimaryKeyType type = 2; + optional PrimaryKeyOption option = 3; +} + +message PartitionRange { + required bytes begin = 1; // encoded as SQLVariant + required bytes end = 2; // encoded as SQLVariant +} + +enum BloomFilterType { + NONE = 1; + CELL = 2; + ROW = 3; +} + +message TableOptions { + optional int32 time_to_live = 1; // 可以动态更改 + optional int32 max_versions = 2; // 可以动态更改 + optional BloomFilterType bloom_filter_type = 3; // 可以动态更改 + optional int32 block_size = 4; // 可以动态更改 + optional int64 deviation_cell_version_in_sec = 5; // 可以动态修改 +} + +message TableMeta { + required string table_name = 1; + repeated PrimaryKeySchema primary_key = 2; + repeated DefinedColumnSchema defined_column = 3; + repeated IndexMeta index_meta = 4; +} + +/** + * 表的状态变更只与用户的操作对应，内部的机器failover等状况不对应表的状态变更。 + * 有三个考虑： + * 一是一般场景下用户只会在做了对表的修改操作后才会去检查表的状态； + * 二是内部机器failover导致访问异常到用户能够查看到表的状态变更这两个时刻之间会有一段延迟，无法将表的不可服务状态与用户查看到的表的状态完全匹配上。 + * 三是内部机器failover后不能说是表的整个状态变更，而应该是partition的状态变更，对应表的状态就是PARTIAL_FAILOVER，这个partial的粒度无法体现，会让用户更加困惑。 + */ +enum TableStatus { + ACTIVE = 1; // 表处于可服务状态。 + INACTIVE = 2; // 用户通过UnloadTable将表禁用。 + LOADING = 3; // 表正在被创建，partition还未全部加载完毕；或者表刚从INACTIVE状态被Enable。 + UNLOADING = 4; // 表正在被删除（从delete table到partition完全unload的这段期间）或者表从ACTIVE状态被Unload。 + UPDATING = 5; // 表正在被更新（table属性变更、预留吞吐量变更）。 +} + +enum RowExistenceExpectation { + IGNORE = 0; + EXPECT_EXIST = 1; + EXPECT_NOT_EXIST = 2; +} + +message Condition { + required RowExistenceExpectation row_existence = 1; + optional bytes column_condition = 2; +} + +message CapacityUnit { + optional int32 read = 1; + optional int32 write = 2; +} + +message ReservedThroughputDetails { + required CapacityUnit capacity_unit = 1; // 表当前的预留吞吐量的值。 + required int64 last_increase_time = 2; // 最后一次上调预留吞吐量的时间。 + optional int64 last_decrease_time = 3; // 最后一次下调预留吞吐量的时间。 +} + +message ReservedThroughput { + required CapacityUnit capacity_unit = 1; +} + +message ConsumedCapacity { + required CapacityUnit capacity_unit = 1; +} + +message StreamSpecification { + required bool enable_stream = 1; + optional int32 expiration_time = 2; +} + +message StreamDetails { + required bool enable_stream = 1; + optional string stream_id = 2; + optional int32 expiration_time = 3; + optional int64 last_enable_time = 4; +} + +/* ############################################# CreateTable ############################################# */ +/** + * table_meta用于存储表中不可更改的schema属性，可以更改的ReservedThroughput和TableOptions独立出来，作为UpdateTable的参数。 + * 加入GlobalIndex和LocalIndex之后，结构会变为： + * message CreateTableRequest { + * required TableMeta table_meta = 1; + * required ReservedThroughput reserved_throughput = 2; + * required TableOptions table_options = 3; + * repeated LocalIndex local_indexes = 4; // LocalIndex不再单独包含ReservedThroughput和TableOptions，其与主表共享配置。 + * repeated GlobalIndex global_indexes = 5; // GlobalIndex内单独包含ReservedThroughput和TableOptions + * } + */ +message CreateTableRequest { + required TableMeta table_meta = 1; + required ReservedThroughput reserved_throughput = 2; // 未放在TableOptions内，原因是UpdateTableResponse中会返回ReservedThroughputDetails，而TableOptions没有类似的返回结构。 + optional TableOptions table_options = 3; + repeated PartitionRange partitions = 4; + optional StreamSpecification stream_spec = 5; + repeated IndexMeta index_metas = 7; +} + +message CreateTableResponse { +} + +/* ######################################################################################################### */ + + +/* ############################################# UpdateTable ############################################# */ +message UpdateTableRequest { + required string table_name = 1; + optional ReservedThroughput reserved_throughput = 2; + optional TableOptions table_options = 3; + optional StreamSpecification stream_spec = 4; +} + +message UpdateTableResponse { + required ReservedThroughputDetails reserved_throughput_details = 1; + required TableOptions table_options = 2; + optional StreamDetails stream_details = 3; +} +/* ######################################################################################################### */ + +/* ############################################# DescribeTable ############################################# */ +message DescribeTableRequest { + required string table_name = 1; +} + +message DescribeTableResponse { + required TableMeta table_meta = 1; + required ReservedThroughputDetails reserved_throughput_details = 2; + required TableOptions table_options = 3; + required TableStatus table_status = 4; + optional StreamDetails stream_details = 5; + repeated bytes shard_splits = 6; + repeated IndexMeta index_metas = 8; +} +/* ########################################################################################################### */ + +/* ############################################# ListTable ############################################# */ +message ListTableRequest { +} + +/** + * 当前只返回一个简单的名称列表，需要讨论是否有业务场景需要获取除了表名之外的其他信息。 + * 其他信息可以包含预留吞吐量以及表的状态，这个信息只能是一个粗略的信息，表的详细信息还是需要通过DescribeTable来获取。 + */ +message ListTableResponse { + repeated string table_names = 1; +} +/* ####################################################################################################### */ + +/* ############################################# DeleteTable ############################################# */ +message DeleteTableRequest { + required string table_name = 1; +} + +message DeleteTableResponse { +} +/* ######################################################################################################### */ + +/* ############################################# LoadTable ############################################# */ +message LoadTableRequest { + required string table_name = 1; +} + +message LoadTableResponse { +} +/* ######################################################################################################### */ + +/* ############################################# UnloadTable ############################################# */ +message UnloadTableRequest { + required string table_name = 1; +} + +message UnloadTableResponse { + +} +/* ########################################################################################################## */ + +/** + * 时间戳的取值最小值为0，最大值为INT64.MAX + * 1. 若要查询一个范围，则指定start_time和end_time + * 2. 若要查询一个特定时间戳，则指定specific_time + */ +message TimeRange { + optional int64 start_time = 1; + optional int64 end_time = 2; + optional int64 specific_time = 3; +} + +/* ############################################# GetRow ############################################# */ + +enum ReturnType { + RT_NONE = 0; + RT_PK = 1; + RT_AFTER_MODIFY = 2; +} + +message ReturnContent { + optional ReturnType return_type = 1; + repeated string return_column_names = 2; +} + +/** + * 1. 支持用户指定版本时间戳范围或者特定的版本时间来读取指定版本的列 + * 2. 目前暂不支持行内的断点 + */ +message GetRowRequest { + required string table_name = 1; + required bytes primary_key = 2; // encoded as InplaceRowChangeSet, but only has primary key + repeated string columns_to_get = 3; // 不指定则读出所有的列 + optional TimeRange time_range = 4; + optional int32 max_versions = 5; + optional bool cache_blocks = 6 [default = true]; // 本次读出的数据是否进入BlockCache + optional bytes filter = 7; + optional string start_column = 8; + optional string end_column = 9; + optional bytes token = 10; + optional string transaction_id = 11; +} + +message GetRowResponse { + required ConsumedCapacity consumed = 1; + required bytes row = 2; // encoded as InplaceRowChangeSet + optional bytes next_token = 3; +} +/* #################################################################################################### */ + +/* ############################################# UpdateRow ############################################# */ +message UpdateRowRequest { + required string table_name = 1; + required bytes row_change = 2; + required Condition condition = 3; + optional ReturnContent return_content = 4; + optional string transaction_id = 5; +} + +message UpdateRowResponse { + required ConsumedCapacity consumed = 1; + optional bytes row = 2; +} + +/* ####################################################################################################### */ + +/* ############################################# PutRow ############################################# */ + + +/** + * 这里允许用户为每列单独设置timestamp，而不是强制整行统一一个timestamp。 + * 原因是列都是用统一的结构，该结构本身是带timestamp的，其次强制统一timestamp增强了规范性但是丧失了灵活性，且该规范性没有明显的好处，反而带来了结构的复杂。 + */ +message PutRowRequest { + required string table_name = 1; + required bytes row = 2; // encoded as InplaceRowChangeSet + required Condition condition = 3; + optional ReturnContent return_content = 4; + optional string transaction_id = 5; +} + +message PutRowResponse { + required ConsumedCapacity consumed = 1; + optional bytes row = 2; +} +/* #################################################################################################### */ + +/* ############################################# DeleteRow ############################################# */ +/** + * OTS只支持删除该行的所有列所有版本，不支持： + * 1. 删除所有列的所有小于等于某个版本的所有版本 + */ +message DeleteRowRequest { + required string table_name = 1; + required bytes primary_key = 2; // encoded as InplaceRowChangeSet, but only has primary key + required Condition condition = 3; + optional ReturnContent return_content = 4; + optional string transaction_id = 5; +} + +message DeleteRowResponse { + required ConsumedCapacity consumed = 1; + optional bytes row = 2; +} +/* ####################################################################################################### */ + +/* ############################################# BatchGetRow ############################################# */ +/** + * HBase支持Batch操作的每行都拥有不同的查询参数，OTS不支持。 + */ +message TableInBatchGetRowRequest { + required string table_name = 1; + repeated bytes primary_key = 2; // encoded as InplaceRowChangeSet, but only has primary key + repeated bytes token = 3; + repeated string columns_to_get = 4; // 不指定则读出所有的列 + optional TimeRange time_range = 5; + optional int32 max_versions = 6; + optional bool cache_blocks = 7 [default = true]; // 本次读出的数据是否进入BlockCache + optional bytes filter = 8; + optional string start_column = 9; + optional string end_column = 10; +} + +message BatchGetRowRequest { + repeated TableInBatchGetRowRequest tables = 1; +} + +message RowInBatchGetRowResponse { + required bool is_ok = 1; + optional Error error = 2; + optional ConsumedCapacity consumed = 3; + optional bytes row = 4; // encoded as InplaceRowChangeSet + optional bytes next_token = 5; +} + +message TableInBatchGetRowResponse { + required string table_name = 1; + repeated RowInBatchGetRowResponse rows = 2; +} + +message BatchGetRowResponse { + repeated TableInBatchGetRowResponse tables = 1; +} +/* ######################################################################################################### */ + +/* ############################################# BatchWriteRow ############################################# */ + +enum OperationType { + PUT = 1; + UPDATE = 2; + DELETE = 3; +} + +message RowInBatchWriteRowRequest { + required OperationType type = 1; + required bytes row_change = 2; // encoded as InplaceRowChangeSet + required Condition condition = 3; + optional ReturnContent return_content = 4; +} + +message TableInBatchWriteRowRequest { + required string table_name = 1; + repeated RowInBatchWriteRowRequest rows = 2; +} + +message BatchWriteRowRequest { + repeated TableInBatchWriteRowRequest tables = 1; + optional string transaction_id = 2; +} + +message RowInBatchWriteRowResponse { + required bool is_ok = 1; + optional Error error = 2; + optional ConsumedCapacity consumed = 3; + optional bytes row = 4; +} + +message TableInBatchWriteRowResponse { + required string table_name = 1; + repeated RowInBatchWriteRowResponse rows = 2; +} + +message BatchWriteRowResponse { + repeated TableInBatchWriteRowResponse tables = 1; +} +/* ########################################################################################################### */ + +/* ############################################# GetRange ############################################# */ +enum Direction { + FORWARD = 0; + BACKWARD = 1; +} + +/** + * HBase支持以下参数： + * 1. TimeRange或指定time + * 2. Filter（根据列值或列名来过滤） + * 我们只支持给同版本的选择条件。 + */ +message GetRangeRequest { + required string table_name = 1; + required Direction direction = 2; + repeated string columns_to_get = 3; // 不指定则读出所有的列 + optional TimeRange time_range = 4; + optional int32 max_versions = 5; + optional int32 limit = 6; + required bytes inclusive_start_primary_key = 7; // encoded as InplaceRowChangeSet, but only has primary key + required bytes exclusive_end_primary_key = 8; // encoded as InplaceRowChangeSet, but only has primary key + optional bool cache_blocks = 9 [default = true]; // 本次读出的数据是否进入BlockCache + optional bytes filter = 10; + optional string start_column = 11; + optional string end_column = 12; + optional bytes token = 13; + optional string transaction_id = 14; +} + +message GetRangeResponse { + required ConsumedCapacity consumed = 1; + required bytes rows = 2; // encoded as InplaceRowChangeSet + optional bytes next_start_primary_key = 3; // 若为空，则代表数据全部读取完毕. encoded as InplaceRowChangeSet, but only has primary key + optional bytes next_token = 4; +} +/* ###################################################################################################### */ +/* ############################################# Stream ############################################# */ + +message ListStreamRequest { + optional string table_name = 1; +} + +message Stream { + required string stream_id = 1; + required string table_name = 2; + required int64 creation_time = 3; +} + +message ListStreamResponse { + repeated Stream streams = 1; +} + +message StreamShard { + required string shard_id = 1; + optional string parent_id = 2; + optional string parent_sibling_id = 3; +} + +enum StreamStatus { + STREAM_ENABLING = 1; + STREAM_ACTIVE = 2; +} + +message DescribeStreamRequest { + required string stream_id = 1; + optional string inclusive_start_shard_id = 2; + optional int32 shard_limit = 3; +} + +message DescribeStreamResponse { + required string stream_id = 1; + required int32 expiration_time = 2; + required string table_name = 3; + required int64 creation_time = 4; + required StreamStatus stream_status = 5; + repeated StreamShard shards = 6; + optional string next_shard_id = 7; +} + +message GetShardIteratorRequest { + required string stream_id = 1; + required string shard_id = 2; + optional int64 timestamp = 3; + optional string token = 4; +} + +message GetShardIteratorResponse { + required string shard_iterator = 1; + optional string next_token = 2; +} + +message GetStreamRecordRequest { + required string shard_iterator = 1; + optional int32 limit = 2; +} + +enum ActionType { + PUT_ROW = 1; + UPDATE_ROW = 2; + DELETE_ROW = 3; +} + +message GetStreamRecordResponse { + message StreamRecord { + required ActionType action_type = 1; + required bytes record = 2; + } + repeated StreamRecord stream_records = 1; + optional string next_shard_iterator = 2; +} + +/* +++++ ComputeSplitPointsBySize +++++ */ +message ComputeSplitPointsBySizeRequest { + required string table_name = 1; + required int64 split_size = 2; // in 100MB +} + +message ComputeSplitPointsBySizeResponse { + required ConsumedCapacity consumed = 1; + repeated PrimaryKeySchema schema = 2; + + /** + * Split points between splits, in the increasing order + * + * A split is a consecutive range of primary keys, + * whose data size is about split_size specified in the request. + * The size could be hard to be precise. + * + * A split point is an array of primary-key column w.r.t. table schema, + * which is never longer than that of table schema. + * Tailing -inf will be omitted to reduce transmission payloads. + */ + repeated bytes split_points = 3; + + /** + * Locations where splits lies in. + * + * By the managed nature of TableStore, these locations are no more than hints. + * If a location is not suitable to be seen, an empty string will be placed. + */ + message SplitLocation { + required string location = 1; + required sint64 repeat = 2; + } + repeated SplitLocation locations = 4; +} +/* -------------------------------------- */ + +enum DefinedColumnType { + DCT_INTEGER = 1; + DCT_DOUBLE = 2; + DCT_BOOLEAN = 3; + DCT_STRING = 4; + // field 5 is reserved for date type, not supported yet + // field 6 is reserved for decimal type, not supported yet + DCT_BLOB = 7; +} + +message DefinedColumnSchema { + required string name = 1; + required DefinedColumnType type = 2; +} + +enum IndexUpdateMode { + IUM_ASYNC_INDEX = 0; + IUM_SYNC_INDEX = 1; +} + +enum IndexType { + IT_GLOBAL_INDEX = 0; + IT_LOCAL_INDEX = 1; +} + +message IndexMeta { + required string name = 1; + repeated string primary_key = 2; + repeated string defined_column = 3; + required IndexUpdateMode index_update_mode = 4; + required IndexType index_type = 5; +} + +message CreateIndexRequest { + required string main_table_name = 1; + required IndexMeta index_meta = 2; + optional bool include_base_data = 3; +} + +message CreateIndexResponse { +} + +message DropIndexRequest { + required string main_table_name = 1; + required string index_name = 2; +} + +message DropIndexResponse { +} + +/* ########################################### LocalTransaction ########################################### */ +message StartLocalTransactionRequest { + required string table_name = 1; + required bytes key = 2; // encoded as SQLVariant +} + +message StartLocalTransactionResponse { + required string transaction_id = 1; +}; + +message CommitTransactionRequest { + required string transaction_id = 1; +} + +message CommitTransactionResponse { +}; + +message AbortTransactionRequest { + required string transaction_id = 1; +} + +message AbortTransactionResponse { +}; + +/* ######################################################################################################### */ \ No newline at end of file diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/plain_buffer.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/plain_buffer.go new file mode 100644 index 000000000000..681d3b08f09c --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/plain_buffer.go @@ -0,0 +1,473 @@ +package tablestore + +import ( + "bytes" + "encoding/binary" + "fmt" + "io" + "math" +) + +const ( + HEADER = 0x75 + + // tag type + TAG_ROW_PK = 0x1 + TAG_ROW_DATA = 0x2 + TAG_CELL = 0x3 + TAG_CELL_NAME = 0x4 + TAG_CELL_VALUE = 0x5 + TAG_CELL_TYPE = 0x6 + TAG_CELL_TIMESTAMP = 0x7 + TAG_DELETE_ROW_MARKER = 0x8 + TAG_ROW_CHECKSUM = 0x9 + TAG_CELL_CHECKSUM = 0x0A + TAG_EXTENSION = 0x0B + TAG_SEQ_INFO = 0x0C + TAG_SEQ_INFO_EPOCH = 0x0D + TAG_SEQ_INFO_TS = 0x0E + TAG_SEQ_INFO_ROW_INDEX = 0x0F + + // cell op type + DELETE_ALL_VERSION = 0x1 + DELETE_ONE_VERSION = 0x3 + INCREMENT = 0x4; + + // variant type + VT_INTEGER = 0x0 + VT_DOUBLE = 0x1 + VT_BOOLEAN = 0x2 + VT_STRING = 0x3 + + //public final static byte VT_NULL = 0x6; + VT_BLOB = 0x7 + VT_INF_MIN = 0x9 + VT_INF_MAX = 0xa + VT_AUTO_INCREMENT = 0xb + + LITTLE_ENDIAN_32_SIZE = 4 + LITTLE_ENDIAN_64_SIZE = 8 +) + +const spaceSize = 256 + +var crc8Table = make([]byte, spaceSize) + +func init() { + for i := 0; i < spaceSize; i++ { + x := byte(i) + for j := 8; j > 0; j-- { + if (x & 0x80) != 0 { + x = (x << 1) ^ 0x07 + } else { + x = (x << 1) ^ 0 + } + } + crc8Table[i] = x + } +} + +func crc8Byte(crc, in byte) byte { + return crc8Table[(crc^in)&0xff] +} + +func crc8Int32(crc byte, in int32) byte { + for i := 0; i < 4; i++ { + crc = crc8Byte(crc, byte((in & 0xff))) + in >>= 8 + } + + return crc +} + +func crc8Int64(crc byte, in int64) byte { + for i := 0; i < 8; i++ { + crc = crc8Byte(crc, byte((in & 0xff))) + in >>= 8 + } + + return crc +} + +func crc8Bytes(crc byte, in []byte) byte { + for i := 0; i < len(in); i++ { + crc = crc8Byte(crc, in[i]) + } + + return crc +} + +func writeRawByte(w io.Writer, value byte) { + w.Write([]byte{value}) +} + +/*func writeRawByteInt8(w io.Writer, value int) { + w.Write([]byte{byte(value)}) +}*/ + +func writeRawLittleEndian32(w io.Writer, value int32) { + w.Write([]byte{byte((value) & 0xFF)}) + w.Write([]byte{byte((value >> 8) & 0xFF)}) + w.Write([]byte{byte((value >> 16) & 0xFF)}) + w.Write([]byte{byte((value >> 24) & 0xFF)}) +} + +func writeRawLittleEndian64(w io.Writer, value int64) { + w.Write([]byte{byte((value) & 0xFF)}) + w.Write([]byte{byte((value >> 8) & 0xFF)}) + w.Write([]byte{byte((value >> 16) & 0xFF)}) + w.Write([]byte{byte((value >> 24) & 0xFF)}) + w.Write([]byte{byte((value >> 32) & 0xFF)}) + w.Write([]byte{byte((value >> 40) & 0xFF)}) + w.Write([]byte{byte((value >> 48) & 0xFF)}) + w.Write([]byte{byte((value >> 56) & 0xFF)}) +} + +func writeDouble(w io.Writer, value float64) { + writeRawLittleEndian64(w, int64(math.Float64bits(value))) +} + +func writeBoolean(w io.Writer, value bool) { + if value { + w.Write([]byte{byte(1)}) + } else { + w.Write([]byte{byte(0)}) + } +} + +func writeBytes(w io.Writer, value []byte) { + w.Write(value) +} + +func writeHeader(w io.Writer) { + writeRawLittleEndian32(w, HEADER) +} + +func writeTag(w io.Writer, tag byte) { + writeRawByte(w, tag) +} + +func writeCellName(w io.Writer, name []byte) { + writeTag(w, TAG_CELL_NAME) + writeRawLittleEndian32(w, int32(len(name))) + writeBytes(w, name) +} + +type PlainBufferCell struct { + cellName []byte + cellValue *ColumnValue + cellTimestamp int64 + cellType byte + ignoreValue bool + hasCellTimestamp bool + hasCellType bool +} + +func (cell *PlainBufferCell) writeCell(w io.Writer) { + writeTag(w, TAG_CELL) + writeCellName(w, cell.cellName) + if cell.ignoreValue == false { + cell.cellValue.writeCellValue(w) + } + + if cell.hasCellType { + writeTag(w, TAG_CELL_TYPE) + writeRawByte(w, cell.cellType) + } + + if cell.hasCellTimestamp { + writeTag(w, TAG_CELL_TIMESTAMP) + writeRawLittleEndian64(w, cell.cellTimestamp) + } + + writeTag(w, TAG_CELL_CHECKSUM) + writeRawByte(w, cell.getCheckSum(byte(0x0))) +} + +func (cell *PlainBufferCell) getCheckSum(crc byte) byte { + crc = crc8Bytes(crc, cell.cellName) + if cell.ignoreValue == false { + crc = cell.cellValue.getCheckSum(crc) + } + + if cell.hasCellTimestamp { + crc = crc8Int64(crc, cell.cellTimestamp) + } + if cell.hasCellType { + crc = crc8Byte(crc, cell.cellType) + } + return crc +} + +type PlainBufferRow struct { + primaryKey []*PlainBufferCell + cells []*PlainBufferCell + hasDeleteMarker bool + extension *RecordSequenceInfo // optional +} + +func (row *PlainBufferRow) writeRow(w io.Writer) { + /* pk */ + writeTag(w, TAG_ROW_PK) + for _, pk := range row.primaryKey { + pk.writeCell(w) + } + + if len(row.cells) > 0 { + writeTag(w, TAG_ROW_DATA) + for _, cell := range row.cells { + cell.writeCell(w) + } + } + + writeTag(w, TAG_ROW_CHECKSUM) + writeRawByte(w, row.getCheckSum(byte(0x0))) +} + +func (row *PlainBufferRow) writeRowWithHeader(w io.Writer) { + writeHeader(w) + row.writeRow(w) +} + +func (row *PlainBufferRow) getCheckSum(crc byte) byte { + for _, cell := range row.primaryKey { + crcCell := cell.getCheckSum(byte(0x0)) + crc = crc8Byte(crc, crcCell) + } + + for _, cell := range row.cells { + crcCell := cell.getCheckSum(byte(0x0)) + crc = crc8Byte(crc, crcCell) + } + + del := byte(0x0) + if row.hasDeleteMarker { + del = byte(0x1) + } + + crc = crc8Byte(crc, del) + + return crc +} + +func readRawByte(r *bytes.Reader) byte { + if r.Len() == 0 { + panic(errUnexpectIoEnd) + } + + b, _ := r.ReadByte() + + return b +} + +func readTag(r *bytes.Reader) int { + return int(readRawByte(r)) +} + +func readRawLittleEndian64(r *bytes.Reader) int64 { + if r.Len() < 8 { + panic(errUnexpectIoEnd) + } + + var v int64 + binary.Read(r, binary.LittleEndian, &v) + + return v +} + +func readRawLittleEndian32(r *bytes.Reader) int32 { + if r.Len() < 4 { + panic(errUnexpectIoEnd) + } + + var v int32 + binary.Read(r, binary.LittleEndian, &v) + + return v +} + +func readBoolean(r *bytes.Reader) bool { + return readRawByte(r) != 0 +} + +func readBytes(r *bytes.Reader, size int32) []byte { + if int32(r.Len()) < size { + panic(errUnexpectIoEnd) + } + v := make([]byte, size) + r.Read(v) + return v +} + +func readCellValue(r *bytes.Reader) *ColumnValue { + value := new(ColumnValue) + readRawLittleEndian32(r) + tp := readRawByte(r) + switch tp { + case VT_INTEGER: + value.Type = ColumnType_INTEGER + value.Value = readRawLittleEndian64(r) + case VT_DOUBLE: + value.Type = ColumnType_DOUBLE + value.Value = math.Float64frombits(uint64(readRawLittleEndian64(r))) + case VT_BOOLEAN: + value.Type = ColumnType_BOOLEAN + value.Value = readBoolean(r) + case VT_STRING: + value.Type = ColumnType_STRING + value.Value = string(readBytes(r, readRawLittleEndian32(r))) + case VT_BLOB: + value.Type = ColumnType_BINARY + value.Value = []byte(readBytes(r, readRawLittleEndian32(r))) + } + return value +} + +func readCell(r *bytes.Reader) *PlainBufferCell { + cell := new(PlainBufferCell) + tag := readTag(r) + if tag != TAG_CELL_NAME { + panic(errTag) + } + + cell.cellName = readBytes(r, readRawLittleEndian32(r)) + tag = readTag(r) + + if tag == TAG_CELL_VALUE { + cell.cellValue = readCellValue(r) + tag = readTag(r) + } + if tag == TAG_CELL_TYPE { + readRawByte(r) + tag = readTag(r) + } + + if tag == TAG_CELL_TIMESTAMP { + cell.cellTimestamp = readRawLittleEndian64(r) + tag = readTag(r) + } + + if tag == TAG_CELL_CHECKSUM { + readRawByte(r) + } else { + panic(errNoChecksum) + } + + return cell +} + +func readRowPk(r *bytes.Reader) []*PlainBufferCell { + primaryKeyColumns := make([]*PlainBufferCell, 0, 4) + + tag := readTag(r) + for tag == TAG_CELL { + primaryKeyColumns = append(primaryKeyColumns, readCell(r)) + tag = readTag(r) + } + + r.Seek(-1, 1) + + return primaryKeyColumns +} + +func readRowData(r *bytes.Reader) []*PlainBufferCell { + columns := make([]*PlainBufferCell, 0, 10) + + tag := readTag(r) + for tag == TAG_CELL { + columns = append(columns, readCell(r)) + tag = readTag(r) + } + + r.Seek(-1, 1) + + return columns +} + +func readRow(r *bytes.Reader) *PlainBufferRow { + row := new(PlainBufferRow) + tag := readTag(r) + if tag == TAG_ROW_PK { + row.primaryKey = readRowPk(r) + tag = readTag(r) + } + + if tag == TAG_ROW_DATA { + row.cells = readRowData(r) + tag = readTag(r) + } + + if tag == TAG_DELETE_ROW_MARKER { + row.hasDeleteMarker = true + tag = readTag(r) + } + + if tag == TAG_EXTENSION { + row.extension = readRowExtension(r) + tag = readTag(r) + } + + if tag == TAG_ROW_CHECKSUM { + readRawByte(r) + } else { + panic(errNoChecksum) + } + return row +} + +func readRowsWithHeader(r *bytes.Reader) (rows []*PlainBufferRow, err error) { + defer func() { + if err2 := recover(); err2 != nil { + if _, ok := err2.(error); ok { + err = err2.(error) + } + return + } + }() + + // TODO: panic + if readRawLittleEndian32(r) != HEADER { + return nil, fmt.Errorf("Invalid header from plain buffer") + } + + rows = make([]*PlainBufferRow, 0, 10) + + for r.Len() > 0 { + rows = append(rows, readRow(r)) + } + + return rows, nil +} + +func readRowExtension(r *bytes.Reader) *RecordSequenceInfo { + readRawLittleEndian32(r) // useless + tag := readTag(r) + if tag != TAG_SEQ_INFO { + panic(errTag) + } + + readRawLittleEndian32(r) // useless + tag = readTag(r) + if tag != TAG_SEQ_INFO_EPOCH { + panic(errTag) + } + epoch := readRawLittleEndian32(r) + + tag = readTag(r) + if tag != TAG_SEQ_INFO_TS { + panic(errTag) + } + ts := readRawLittleEndian64(r) + + tag = readTag(r) + if tag != TAG_SEQ_INFO_ROW_INDEX { + panic(errTag) + } + rowIndex := readRawLittleEndian32(r) + + ext := RecordSequenceInfo{} + ext.Epoch = epoch + ext.Timestamp = ts + ext.RowIndex = rowIndex + return &ext +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/collapse.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/collapse.go new file mode 100644 index 000000000000..60b19cba0325 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/collapse.go @@ -0,0 +1,14 @@ +package search + +import "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + +type Collapse struct { + FieldName string +} + +func (c *Collapse) ProtoBuffer() (*otsprotocol.Collapse, error) { + pb := &otsprotocol.Collapse{ + FieldName: &c.FieldName, + } + return pb, nil +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query.go new file mode 100644 index 000000000000..bcd62bbbe26f --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query.go @@ -0,0 +1,85 @@ +package search + +import "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + +type QueryType int + +const ( + QueryType_None QueryType = 0 + QueryType_MatchQuery QueryType = 1 + QueryType_MatchPhraseQuery QueryType = 2 + QueryType_TermQuery QueryType = 3 + QueryType_RangeQuery QueryType = 4 + QueryType_PrefixQuery QueryType = 5 + QueryType_BoolQuery QueryType = 6 + QueryType_ConstScoreQuery QueryType = 7 + QueryType_FunctionScoreQuery QueryType = 8 + QueryType_NestedQuery QueryType = 9 + QueryType_WildcardQuery QueryType = 10 + QueryType_MatchAllQuery QueryType = 11 + QueryType_GeoBoundingBoxQuery QueryType = 12 + QueryType_GeoDistanceQuery QueryType = 13 + QueryType_GeoPolygonQuery QueryType = 14 + QueryType_TermsQuery QueryType = 15 +) + +func (q QueryType) Enum() *QueryType { + newQuery := q + return &newQuery +} + +func (q QueryType) ToPB() *otsprotocol.QueryType { + switch q { + case QueryType_None: + return nil + case QueryType_MatchQuery: + return otsprotocol.QueryType_MATCH_QUERY.Enum() + case QueryType_MatchPhraseQuery: + return otsprotocol.QueryType_MATCH_PHRASE_QUERY.Enum() + case QueryType_TermQuery: + return otsprotocol.QueryType_TERM_QUERY.Enum() + case QueryType_RangeQuery: + return otsprotocol.QueryType_RANGE_QUERY.Enum() + case QueryType_PrefixQuery: + return otsprotocol.QueryType_PREFIX_QUERY.Enum() + case QueryType_BoolQuery: + return otsprotocol.QueryType_BOOL_QUERY.Enum() + case QueryType_ConstScoreQuery: + return otsprotocol.QueryType_CONST_SCORE_QUERY.Enum() + case QueryType_FunctionScoreQuery: + return otsprotocol.QueryType_FUNCTION_SCORE_QUERY.Enum() + case QueryType_NestedQuery: + return otsprotocol.QueryType_NESTED_QUERY.Enum() + case QueryType_WildcardQuery: + return otsprotocol.QueryType_WILDCARD_QUERY.Enum() + case QueryType_MatchAllQuery: + return otsprotocol.QueryType_MATCH_ALL_QUERY.Enum() + case QueryType_GeoBoundingBoxQuery: + return otsprotocol.QueryType_GEO_BOUNDING_BOX_QUERY.Enum() + case QueryType_GeoDistanceQuery: + return otsprotocol.QueryType_GEO_DISTANCE_QUERY.Enum() + case QueryType_GeoPolygonQuery: + return otsprotocol.QueryType_GEO_POLYGON_QUERY.Enum() + case QueryType_TermsQuery: + return otsprotocol.QueryType_TERMS_QUERY.Enum() + default: + panic("unexpected") + } +} + +type Query interface { + Type() QueryType + Serialize() ([]byte, error) + ProtoBuffer() (*otsprotocol.Query, error) +} + +func BuildPBForQuery(q Query) (*otsprotocol.Query, error) { + query := &otsprotocol.Query{} + query.Type = q.Type().ToPB() + data, err := q.Serialize() + if err != nil { + return nil, err + } + query.Query = data + return query, nil +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_bool.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_bool.go new file mode 100644 index 000000000000..230d2e00f39e --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_bool.go @@ -0,0 +1,75 @@ +package search + +import ( + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" +) + +type BoolQuery struct { + MustQueries []Query + MustNotQueries []Query + FilterQueries []Query + ShouldQueries []Query + MinimumShouldMatch *int32 +} + +func (q *BoolQuery) Type() QueryType { + return QueryType_BoolQuery +} + +func (q *BoolQuery) Serialize() ([]byte, error) { + query := &otsprotocol.BoolQuery{} + if q.MustQueries != nil { + pbMustQs := make([]*otsprotocol.Query, 0) + for _, mustQ := range q.MustQueries { + pbQ, err := mustQ.ProtoBuffer() + if err != nil { + return nil, err + } + pbMustQs = append(pbMustQs, pbQ) + } + query.MustQueries = pbMustQs + } + if q.MustNotQueries != nil { + pbMustNotQs := make([]*otsprotocol.Query, 0) + for _, mustNotQ := range q.MustNotQueries { + pbQ, err := mustNotQ.ProtoBuffer() + if err != nil { + return nil, err + } + pbMustNotQs = append(pbMustNotQs, pbQ) + } + query.MustNotQueries = pbMustNotQs + } + if q.FilterQueries != nil { + pbFilterQs := make([]*otsprotocol.Query, 0) + for _, filterQ := range q.FilterQueries { + pbQ, err := filterQ.ProtoBuffer() + if err != nil { + return nil, err + } + pbFilterQs = append(pbFilterQs, pbQ) + } + query.FilterQueries = pbFilterQs + } + if q.ShouldQueries != nil { + pbShouldQs := make([]*otsprotocol.Query, 0) + for _, shouldQ := range q.ShouldQueries { + pbQ, err := shouldQ.ProtoBuffer() + if err != nil { + return nil, err + } + pbShouldQs = append(pbShouldQs, pbQ) + } + query.ShouldQueries = pbShouldQs + } + if (q.MinimumShouldMatch != nil) { + query.MinimumShouldMatch = q.MinimumShouldMatch + } + data, err := proto.Marshal(query) + return data, err +} + +func (q *BoolQuery) ProtoBuffer() (*otsprotocol.Query, error) { + return BuildPBForQuery(q) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_const_score.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_const_score.go new file mode 100644 index 000000000000..124d826281c3 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_const_score.go @@ -0,0 +1,29 @@ +package search + +import ( + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" +) + +type ConstScoreQuery struct { + Filter Query +} + +func (q *ConstScoreQuery) Type() QueryType { + return QueryType_ConstScoreQuery +} + +func (q *ConstScoreQuery) Serialize() ([]byte, error) { + query := &otsprotocol.ConstScoreQuery{} + pbQ, err := q.Filter.ProtoBuffer() + if err != nil { + return nil, err + } + query.Filter = pbQ + data, err := proto.Marshal(query) + return data, err +} + +func (q *ConstScoreQuery) ProtoBuffer() (*otsprotocol.Query, error) { + return BuildPBForQuery(q) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_function_score.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_function_score.go new file mode 100644 index 000000000000..c1115305ebf8 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_function_score.go @@ -0,0 +1,49 @@ +package search + +import ( + "errors" + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" +) + +type FieldValueFactor struct { + FieldName string +} + +func (f *FieldValueFactor) ProtoBuffer() (*otsprotocol.FieldValueFactor, error) { + pb := &otsprotocol.FieldValueFactor{} + pb.FieldName = &f.FieldName + return pb, nil +} + +type FunctionScoreQuery struct { + Query Query + FieldValueFactor *FieldValueFactor +} + +func (q *FunctionScoreQuery) Type() QueryType { + return QueryType_FunctionScoreQuery +} + +func (q *FunctionScoreQuery) Serialize() ([]byte, error) { + if q.Query == nil || q.FieldValueFactor == nil { + return nil, errors.New("FunctionScoreQuery: Query or FieldValueFactor is nil") + } + query := &otsprotocol.FunctionScoreQuery{} + pbQ, err := q.Query.ProtoBuffer() + if err != nil { + return nil, err + } + query.Query = pbQ + pbF, err := q.FieldValueFactor.ProtoBuffer() + if err != nil { + return nil, err + } + query.FieldValueFactor = pbF + data, err := proto.Marshal(query) + return data, err +} + +func (q *FunctionScoreQuery) ProtoBuffer() (*otsprotocol.Query, error) { + return BuildPBForQuery(q) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_geo_bounding_box.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_geo_bounding_box.go new file mode 100644 index 000000000000..9dcbfe81012a --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_geo_bounding_box.go @@ -0,0 +1,29 @@ +package search + +import ( + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" +) + +type GeoBoundingBoxQuery struct { + FieldName string + TopLeft string + BottomRight string +} + +func (q *GeoBoundingBoxQuery) Type() QueryType { + return QueryType_GeoBoundingBoxQuery +} + +func (q *GeoBoundingBoxQuery) Serialize() ([]byte, error) { + query := &otsprotocol.GeoBoundingBoxQuery{} + query.FieldName = &q.FieldName + query.TopLeft = &q.TopLeft + query.BottomRight = &q.BottomRight + data, err := proto.Marshal(query) + return data, err +} + +func (q *GeoBoundingBoxQuery) ProtoBuffer() (*otsprotocol.Query, error) { + return BuildPBForQuery(q) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_geo_distance.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_geo_distance.go new file mode 100644 index 000000000000..5906cb692b90 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_geo_distance.go @@ -0,0 +1,29 @@ +package search + +import ( + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" +) + +type GeoDistanceQuery struct { + FieldName string + CenterPoint string + DistanceInMeter float64 +} + +func (q *GeoDistanceQuery) Type() QueryType { + return QueryType_GeoDistanceQuery +} + +func (q *GeoDistanceQuery) Serialize() ([]byte, error) { + query := &otsprotocol.GeoDistanceQuery{} + query.FieldName = &q.FieldName + query.CenterPoint = &q.CenterPoint + query.Distance = &q.DistanceInMeter + data, err := proto.Marshal(query) + return data, err +} + +func (q *GeoDistanceQuery) ProtoBuffer() (*otsprotocol.Query, error) { + return BuildPBForQuery(q) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_geo_polygon.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_geo_polygon.go new file mode 100644 index 000000000000..f38efe7aa118 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_geo_polygon.go @@ -0,0 +1,27 @@ +package search + +import ( + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" +) + +type GeoPolygonQuery struct { + FieldName string + Points []string +} + +func (q *GeoPolygonQuery) Type() QueryType { + return QueryType_GeoPolygonQuery +} + +func (q *GeoPolygonQuery) Serialize() ([]byte, error) { + query := &otsprotocol.GeoPolygonQuery{} + query.FieldName = &q.FieldName + query.Points = q.Points + data, err := proto.Marshal(query) + return data, err +} + +func (q *GeoPolygonQuery) ProtoBuffer() (*otsprotocol.Query, error) { + return BuildPBForQuery(q) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_match.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_match.go new file mode 100644 index 000000000000..d02f85c00c62 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_match.go @@ -0,0 +1,68 @@ +package search + +import ( + "errors" + "fmt" + + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" +) + +type QueryOperator int8 + +const ( + QueryOperator_OR QueryOperator = 0 + QueryOperator_AND QueryOperator = 1 +) + +func (x QueryOperator) Enum() *QueryOperator { + p := new(QueryOperator) + *p = x + return p +} + +func (o *QueryOperator) ProtoBuffer() (*otsprotocol.QueryOperator, error) { + if o == nil { + return nil, errors.New("query operator is nil") + } + if *o == QueryOperator_OR { + return otsprotocol.QueryOperator_OR.Enum(), nil + } else if *o == QueryOperator_AND { + return otsprotocol.QueryOperator_AND.Enum(), nil + } else { + return nil, errors.New("unknown query operator: " + fmt.Sprintf("%#v", *o)) + } +} + +type MatchQuery struct { + FieldName string + Text string + MinimumShouldMatch *int32 + Operator *QueryOperator +} + +func (q *MatchQuery) Type() QueryType { + return QueryType_MatchQuery +} + +func (q *MatchQuery) Serialize() ([]byte, error) { + query := &otsprotocol.MatchQuery{} + query.FieldName = &q.FieldName + query.Text = &q.Text + if q.MinimumShouldMatch != nil { + query.MinimumShouldMatch = q.MinimumShouldMatch + } + if q.Operator != nil { + pbOperator, err := q.Operator.ProtoBuffer() + if err != nil { + return nil, err + } + query.Operator = pbOperator + } + data, err := proto.Marshal(query) + return data, err +} + +func (q *MatchQuery) ProtoBuffer() (*otsprotocol.Query, error) { + return BuildPBForQuery(q) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_match_phrase.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_match_phrase.go new file mode 100644 index 000000000000..fc4511bdef46 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_match_phrase.go @@ -0,0 +1,27 @@ +package search + +import ( + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" +) + +type MatchPhraseQuery struct { + FieldName string + Text string +} + +func (q *MatchPhraseQuery) Type() QueryType { + return QueryType_MatchPhraseQuery +} + +func (q *MatchPhraseQuery) Serialize() ([]byte, error) { + query := &otsprotocol.MatchPhraseQuery{} + query.FieldName = &q.FieldName + query.Text = &q.Text + data, err := proto.Marshal(query) + return data, err +} + +func (q *MatchPhraseQuery) ProtoBuffer() (*otsprotocol.Query, error) { + return BuildPBForQuery(q) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_matchall.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_matchall.go new file mode 100644 index 000000000000..778dbecdc928 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_matchall.go @@ -0,0 +1,23 @@ +package search + +import ( + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" +) + +type MatchAllQuery struct { +} + +func (q *MatchAllQuery) Type() QueryType { + return QueryType_MatchAllQuery +} + +func (q *MatchAllQuery) Serialize() ([]byte, error) { + query := &otsprotocol.MatchAllQuery{} + data, err := proto.Marshal(query) + return data, err +} + +func (q *MatchAllQuery) ProtoBuffer() (*otsprotocol.Query, error) { + return BuildPBForQuery(q) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_nested.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_nested.go new file mode 100644 index 000000000000..15a9bad2210c --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_nested.go @@ -0,0 +1,54 @@ +package search + +import ( + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" +) + +type ScoreModeType int + +const ( + ScoreMode_None ScoreModeType = 1 + ScoreMode_Avg ScoreModeType = 2 + ScoreMode_Max ScoreModeType = 3 + ScoreMode_Total ScoreModeType = 4 + ScoreMode_Min ScoreModeType = 5 +) + +type NestedQuery struct { + Path string + Query Query + ScoreMode ScoreModeType +} + +func (q *NestedQuery) Type() QueryType { + return QueryType_NestedQuery +} + +func (q *NestedQuery) Serialize() ([]byte, error) { + query := &otsprotocol.NestedQuery{} + pbQ, err := q.Query.ProtoBuffer() + if err != nil { + return nil, err + } + query.Query = pbQ + query.Path = &q.Path + switch q.ScoreMode { + case ScoreMode_None: + query.ScoreMode = otsprotocol.ScoreMode_SCORE_MODE_NONE.Enum() + case ScoreMode_Avg: + query.ScoreMode = otsprotocol.ScoreMode_SCORE_MODE_AVG.Enum() + case ScoreMode_Max: + query.ScoreMode = otsprotocol.ScoreMode_SCORE_MODE_MAX.Enum() + case ScoreMode_Min: + query.ScoreMode = otsprotocol.ScoreMode_SCORE_MODE_MIN.Enum() + case ScoreMode_Total: + query.ScoreMode = otsprotocol.ScoreMode_SCORE_MODE_TOTAL.Enum() + } + data, err := proto.Marshal(query) + return data, err +} + +func (q *NestedQuery) ProtoBuffer() (*otsprotocol.Query, error) { + return BuildPBForQuery(q) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_prefix.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_prefix.go new file mode 100644 index 000000000000..a94d0cdb634e --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_prefix.go @@ -0,0 +1,27 @@ +package search + +import ( + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" +) + +type PrefixQuery struct { + FieldName string + Prefix string +} + +func (q *PrefixQuery) Type() QueryType { + return QueryType_PrefixQuery +} + +func (q *PrefixQuery) Serialize() ([]byte, error) { + query := &otsprotocol.PrefixQuery{} + query.FieldName = &q.FieldName + query.Prefix = &q.Prefix + data, err := proto.Marshal(query) + return data, err +} + +func (q *PrefixQuery) ProtoBuffer() (*otsprotocol.Query, error) { + return BuildPBForQuery(q) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_range.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_range.go new file mode 100644 index 000000000000..28e3353bba3e --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_range.go @@ -0,0 +1,75 @@ +package search + +import ( + "errors" + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" +) + +type RangeQuery struct { + FieldName string + From interface{} + To interface{} + IncludeLower bool + IncludeUpper bool +} + +func (q *RangeQuery) GT(value interface{}) { + q.from(value, false) +} + +func (q *RangeQuery) GTE(value interface{}) { + q.from(value, true) +} + +func (q *RangeQuery) LT(value interface{}) { + q.to(value, false) +} + +func (q *RangeQuery) LTE(value interface{}) { + q.to(value, true) +} + +func (q *RangeQuery) from(value interface{}, includeLower bool) { + q.From = value + q.IncludeLower = includeLower +} + +func (q *RangeQuery) to(value interface{}, includeUpper bool) { + q.To = value + q.IncludeUpper = includeUpper +} + +func (q *RangeQuery) Type() QueryType { + return QueryType_RangeQuery +} + +func (q *RangeQuery) Serialize() ([]byte, error) { + if q.FieldName == "" { + return nil, errors.New("RangeQuery: fieldName not set.") + } + query := &otsprotocol.RangeQuery{} + query.FieldName = &q.FieldName + if q.From != nil { + vFrom, err := ToVariantValue(q.From) + if err != nil { + return nil, err + } + query.RangeFrom = ([]byte)(vFrom) + } + if q.To != nil { + vTo, err := ToVariantValue(q.To) + if err != nil { + return nil, err + } + query.RangeTo = ([]byte)(vTo) + } + query.IncludeLower = &q.IncludeLower + query.IncludeUpper = &q.IncludeUpper + data, err := proto.Marshal(query) + return data, err +} + +func (q *RangeQuery) ProtoBuffer() (*otsprotocol.Query, error) { + return BuildPBForQuery(q) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_term.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_term.go new file mode 100644 index 000000000000..1aac71808922 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_term.go @@ -0,0 +1,31 @@ +package search + +import ( + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" +) + +type TermQuery struct { + FieldName string + Term interface{} +} + +func (q *TermQuery) Type() QueryType { + return QueryType_TermQuery +} + +func (q *TermQuery) Serialize() ([]byte, error) { + term := &otsprotocol.TermQuery{} + term.FieldName = &q.FieldName + vt, err := ToVariantValue(q.Term) + if err != nil { + return nil, err + } + term.Term = []byte(vt) + data, err := proto.Marshal(term) + return data, err +} + +func (q *TermQuery) ProtoBuffer() (*otsprotocol.Query, error) { + return BuildPBForQuery(q) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_terms.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_terms.go new file mode 100644 index 000000000000..1401ff48f4e1 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_terms.go @@ -0,0 +1,35 @@ +package search + +import ( + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" +) + +type TermsQuery struct { + FieldName string + Terms []interface{} +} + +func (q *TermsQuery) Type() QueryType { + return QueryType_TermsQuery +} + +func (q *TermsQuery) Serialize() ([]byte, error) { + term := &otsprotocol.TermsQuery{} + term.FieldName = &q.FieldName + term.Terms = make([][]byte, 0) + + for _, value := range q.Terms { + vt, err := ToVariantValue(value) + if err != nil { + return nil, err + } + term.Terms = append(term.Terms, []byte(vt)) + } + data, err := proto.Marshal(term) + return data, err +} + +func (q *TermsQuery) ProtoBuffer() (*otsprotocol.Query, error) { + return BuildPBForQuery(q) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_wildcard.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_wildcard.go new file mode 100644 index 000000000000..f885ca6e941a --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/query_wildcard.go @@ -0,0 +1,27 @@ +package search + +import ( + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" +) + +type WildcardQuery struct { + FieldName string + Value string +} + +func (q *WildcardQuery) Type() QueryType { + return QueryType_WildcardQuery +} + +func (q *WildcardQuery) Serialize() ([]byte, error) { + query := &otsprotocol.WildcardQuery{} + query.FieldName = &q.FieldName + query.Value = &q.Value + data, err := proto.Marshal(query) + return data, err +} + +func (q *WildcardQuery) ProtoBuffer() (*otsprotocol.Query, error) { + return BuildPBForQuery(q) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/search_query.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/search_query.go new file mode 100644 index 000000000000..9bc47ebe0a0a --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/search_query.go @@ -0,0 +1,101 @@ +package search + +import ( + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" +) + +type SearchQuery interface { + Serialize() ([]byte, error) +} + +type searchQuery struct { + Offset int32 + Limit int32 + Query Query + Collapse *Collapse + Sort *Sort + GetTotalCount bool + Token []byte +} + +func NewSearchQuery() *searchQuery { + return &searchQuery{ + Offset: -1, + Limit: -1, + GetTotalCount: false, + } +} + +func (s *searchQuery) SetOffset(offset int32) *searchQuery { + s.Offset = offset + return s +} + +func (s *searchQuery) SetLimit(limit int32) *searchQuery { + s.Limit = limit + return s +} + +func (s *searchQuery) SetQuery(query Query) *searchQuery { + s.Query = query + return s +} + +func (s *searchQuery) SetCollapse(collapse *Collapse) *searchQuery { + s.Collapse = collapse + return s +} + +func (s *searchQuery) SetSort(sort *Sort) *searchQuery { + s.Sort = sort + return s +} + +func (s *searchQuery) SetGetTotalCount(getTotalCount bool) *searchQuery { + s.GetTotalCount = getTotalCount + return s +} + +func (s *searchQuery) SetToken(token []byte) *searchQuery { + s.Token = token + s.Sort = nil + return s +} + +func (s *searchQuery) Serialize() ([]byte, error) { + search_query := &otsprotocol.SearchQuery{} + if s.Offset >= 0 { + search_query.Offset = &s.Offset + } + if s.Limit >= 0 { + search_query.Limit = &s.Limit + } + if s.Query != nil { + pbQuery, err := s.Query.ProtoBuffer() + if err != nil { + return nil, err + } + search_query.Query = pbQuery + } + if s.Collapse != nil { + pbCollapse, err := s.Collapse.ProtoBuffer() + if err != nil { + return nil, err + } + search_query.Collapse = pbCollapse + } + if s.Sort != nil { + pbSort, err := s.Sort.ProtoBuffer() + if err != nil { + return nil, err + } + search_query.Sort = pbSort + } + search_query.GetTotalCount = &s.GetTotalCount + if s.Token != nil && len(s.Token) > 0 { + search_query.Token = s.Token + } + data, err := proto.Marshal(search_query) + return data, err +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort.go new file mode 100644 index 000000000000..3b3e4a1136a7 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort.go @@ -0,0 +1,27 @@ +package search + +import ( + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" +) + +type Sorter interface { + ProtoBuffer() (*otsprotocol.Sorter, error) +} + +type Sort struct { + Sorters []Sorter +} + +func (s *Sort) ProtoBuffer() (*otsprotocol.Sort, error) { + pbSort := &otsprotocol.Sort{} + pbSortors := make([]*otsprotocol.Sorter, 0) + for _, fs := range s.Sorters { + pbFs, err := fs.ProtoBuffer() + if err != nil { + return nil, err + } + pbSortors = append(pbSortors, pbFs) + } + pbSort.Sorter = pbSortors + return pbSort, nil +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_field.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_field.go new file mode 100644 index 000000000000..c4272a86deab --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_field.go @@ -0,0 +1,67 @@ +package search + +import "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + +type NestedFilter struct { + Path string + Filter Query +} + +func (f *NestedFilter) ProtoBuffer() (*otsprotocol.NestedFilter, error) { + pbF := &otsprotocol.NestedFilter{ + Path: &f.Path, + } + pbQ, err := f.Filter.ProtoBuffer() + if err != nil { + return nil, err + } + pbF.Filter = pbQ + return pbF, err +} + +type FieldSort struct { + FieldName string + Order *SortOrder + Mode *SortMode + NestedFilter *NestedFilter +} + +func NewFieldSort(fieldName string, order SortOrder) *FieldSort { + return &FieldSort{ + FieldName: fieldName, + Order: order.Enum(), + } +} + +func (s *FieldSort) ProtoBuffer() (*otsprotocol.Sorter, error) { + pbFieldSort := &otsprotocol.FieldSort{ + FieldName: &s.FieldName, + } + if s.Order != nil { + pbOrder, err := s.Order.ProtoBuffer() + if err != nil { + return nil, err + } + pbFieldSort.Order = pbOrder + } + if s.Mode != nil { + pbMode, err := s.Mode.ProtoBuffer() + if err != nil { + return nil, err + } + if pbMode != nil { + pbFieldSort.Mode = pbMode + } + } + if s.NestedFilter != nil { + pbFilter, err := s.NestedFilter.ProtoBuffer() + if err != nil { + return nil, err + } + pbFieldSort.NestedFilter = pbFilter + } + pbSorter := &otsprotocol.Sorter{ + FieldSort: pbFieldSort, + } + return pbSorter, nil +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_geo_distance.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_geo_distance.go new file mode 100644 index 000000000000..de4b07c3029b --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_geo_distance.go @@ -0,0 +1,77 @@ +package search + +import ( + "errors" + "fmt" + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" +) + +type GeoDistanceType int8 + +const ( + GeoDistanceType_ARC GeoDistanceType = 0 + GeoDistanceType_PLANE GeoDistanceType = 0 +) + +func (t *GeoDistanceType) ProtoBuffer() (*otsprotocol.GeoDistanceType, error) { + if t == nil { + return nil, errors.New("type is nil") + } + if *t == GeoDistanceType_ARC { + return otsprotocol.GeoDistanceType_GEO_DISTANCE_ARC.Enum(), nil + } else if *t == GeoDistanceType_PLANE { + return otsprotocol.GeoDistanceType_GEO_DISTANCE_PLANE.Enum(), nil + } else { + return nil, errors.New("unknown distance type: " + fmt.Sprintf("%#v", *t)) + } +} + +type GeoDistanceSort struct { + FieldName string + Points []string + Order *SortOrder + Mode *SortMode + GeoDistanceType *GeoDistanceType + NestedFilter *NestedFilter +} + +func (s *GeoDistanceSort) ProtoBuffer() (*otsprotocol.Sorter, error) { + pbGeoDistanceSort := &otsprotocol.GeoDistanceSort{ + FieldName: &s.FieldName, + Points: s.Points, + } + if s.Order != nil { + pbOrder, err := s.Order.ProtoBuffer() + if err != nil { + return nil, err + } + pbGeoDistanceSort.Order = pbOrder + } + if s.Mode != nil { + pbMode, err := s.Mode.ProtoBuffer() + if err != nil { + return nil, err + } + if pbMode != nil { + pbGeoDistanceSort.Mode = pbMode + } + } + if s.GeoDistanceType != nil { + pbGeoDisType, err := s.GeoDistanceType.ProtoBuffer() + if err != nil { + return nil, err + } + pbGeoDistanceSort.DistanceType = pbGeoDisType + } + if s.NestedFilter != nil { + pbFilter, err := s.NestedFilter.ProtoBuffer() + if err != nil { + return nil, err + } + pbGeoDistanceSort.NestedFilter = pbFilter + } + pbSorter := &otsprotocol.Sorter{ + GeoDistanceSort: pbGeoDistanceSort, + } + return pbSorter, nil +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_mode.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_mode.go new file mode 100644 index 000000000000..4b04ac1bed63 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_mode.go @@ -0,0 +1,36 @@ +package search + +import ( + "errors" + "fmt" + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" +) + +type SortMode int8 + +const ( + SortMode_Min SortMode = 0 + SortMode_Max SortMode = 1 + SortMode_Avg SortMode = 2 +) + +func (x SortMode) Enum() *SortMode { + p := new(SortMode) + *p = x + return p +} + +func (m *SortMode) ProtoBuffer() (*otsprotocol.SortMode, error) { + if m == nil { + return nil, errors.New("sort mode is nil") + } + if *m == SortMode_Min { + return otsprotocol.SortMode_SORT_MODE_MIN.Enum(), nil + } else if *m == SortMode_Max { + return otsprotocol.SortMode_SORT_MODE_MAX.Enum(), nil + } else if *m == SortMode_Avg { + return otsprotocol.SortMode_SORT_MODE_AVG.Enum(), nil + } else { + return nil, errors.New("unknown sort mode: " + fmt.Sprintf("%#v", *m)) + } +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_order.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_order.go new file mode 100644 index 000000000000..b936bfe7c909 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_order.go @@ -0,0 +1,47 @@ +package search + +import ( + "errors" + "fmt" + + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" +) + +type SortOrder int8 + +const ( + SortOrder_ASC SortOrder = 0 + SortOrder_DESC SortOrder = 1 +) + +func (x SortOrder) Enum() *SortOrder { + p := new(SortOrder) + *p = x + return p +} + +func (o *SortOrder) ProtoBuffer() (*otsprotocol.SortOrder, error) { + if o == nil { + return nil, errors.New("sort order is nil") + } + if *o == SortOrder_ASC { + return otsprotocol.SortOrder_SORT_ORDER_ASC.Enum(), nil + } else if *o == SortOrder_DESC { + return otsprotocol.SortOrder_SORT_ORDER_DESC.Enum(), nil + } else { + return nil, errors.New("unknown sort order: " + fmt.Sprintf("%#v", *o)) + } +} + +func ParseSortOrder(order *otsprotocol.SortOrder) *SortOrder { + if order == nil { + return nil + } + if *order == otsprotocol.SortOrder_SORT_ORDER_ASC { + return SortOrder_ASC.Enum() + } else if *order == otsprotocol.SortOrder_SORT_ORDER_DESC { + return SortOrder_DESC.Enum() + } else { + return nil + } +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_primary_key.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_primary_key.go new file mode 100644 index 000000000000..4a54a3522689 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_primary_key.go @@ -0,0 +1,28 @@ +package search + +import "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + +type PrimaryKeySort struct { + Order *SortOrder +} + +func NewPrimaryKeySort() *PrimaryKeySort { + return &PrimaryKeySort{ + Order: SortOrder_ASC.Enum(), + } +} + +func (s *PrimaryKeySort) ProtoBuffer() (*otsprotocol.Sorter, error) { + pbPrimaryKeySort := &otsprotocol.PrimaryKeySort{} + if s.Order != nil { + pbOrder, err := s.Order.ProtoBuffer() + if err != nil { + return nil, err + } + pbPrimaryKeySort.Order = pbOrder + } + pbSorter := &otsprotocol.Sorter{ + PkSort: pbPrimaryKeySort, + } + return pbSorter, nil +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_score.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_score.go new file mode 100644 index 000000000000..00eef31db379 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/sort_score.go @@ -0,0 +1,28 @@ +package search + +import "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + +type ScoreSort struct { + Order *SortOrder +} + +func NewScoreSort() *ScoreSort { + return &ScoreSort{ + Order: SortOrder_DESC.Enum(), + } +} + +func (s *ScoreSort) ProtoBuffer() (*otsprotocol.Sorter, error) { + pbScoreSort := &otsprotocol.ScoreSort{} + if s.Order != nil { + pbOrder, err := s.Order.ProtoBuffer() + if err != nil { + return nil, err + } + pbScoreSort.Order = pbOrder + } + pbSorter := &otsprotocol.Sorter{ + ScoreSort: pbScoreSort, + } + return pbSorter, nil +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/variant_types.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/variant_types.go new file mode 100644 index 000000000000..7ec743f7b14f --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search/variant_types.go @@ -0,0 +1,74 @@ +package search + +import ( + "encoding/binary" + "errors" + "math" + "reflect" +) + +type VariantValue []byte +type VariantType byte + +const ( + // variant type + VT_INTEGER VariantType = 0x0 + VT_DOUBLE VariantType = 0x1 + VT_BOOLEAN VariantType = 0x2 + VT_STRING VariantType = 0x3 +) + +func ToVariantValue(value interface{}) (VariantValue, error) { + t := reflect.TypeOf(value) + switch t.Kind() { + case reflect.String: + return VTString(value.(string)), nil + case reflect.Int: + return VTInteger(int64(value.(int))), nil + case reflect.Int64: + return VTInteger(value.(int64)), nil + case reflect.Float64: + return VTDouble(value.(float64)), nil + case reflect.Bool: + return VTBoolean(value.(bool)), nil + default: + return nil, errors.New("interface{} type must be string/int64/float64.") + } +} + +func (v *VariantValue) GetType() VariantType { + return VariantType(([]byte)(*v)[0]) +} + +func VTInteger(v int64) VariantValue { + buf := make([]byte, 9) + buf[0] = byte(VT_INTEGER) + binary.LittleEndian.PutUint64(buf[1:9], uint64(v)) + return (VariantValue)(buf) +} + +func VTDouble(v float64) VariantValue { + buf := make([]byte, 9) + buf[0] = byte(VT_DOUBLE) + binary.LittleEndian.PutUint64(buf[1:9], math.Float64bits(v)) + return (VariantValue)(buf) +} + +func VTString(v string) VariantValue { + buf := make([]byte, 5+len(v)) + buf[0] = byte(VT_STRING) + binary.LittleEndian.PutUint32(buf[1:5], uint32(len(v))) + copy(buf[5:], v) + return (VariantValue)(buf) +} + +func VTBoolean(b bool) VariantValue { + buf := make([]byte, 2) + buf[0] = byte(VT_BOOLEAN) + if b { + buf[1] = 1 + } else { + buf[1] = 0 + } + return (VariantValue)(buf) +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search_api.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search_api.go new file mode 100644 index 000000000000..29e0c1ec91ea --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search_api.go @@ -0,0 +1,136 @@ +package tablestore + +import ( + "bytes" + "errors" + "fmt" + + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" +) + +func (tableStoreClient *TableStoreClient) CreateSearchIndex(request *CreateSearchIndexRequest) (*CreateSearchIndexResponse, error) { + req := new(otsprotocol.CreateSearchIndexRequest) + req.TableName = proto.String(request.TableName) + req.IndexName = proto.String(request.IndexName) + var err error + req.Schema, err = convertToPbSchema(request.IndexSchema) + if err != nil { + return nil, err + } + resp := new(otsprotocol.CreateSearchIndexRequest) + response := &CreateSearchIndexResponse{} + if err := tableStoreClient.doRequestWithRetry(createSearchIndexUri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + return response, nil +} + +func (tableStoreClient *TableStoreClient) DeleteSearchIndex(request *DeleteSearchIndexRequest) (*DeleteSearchIndexResponse, error) { + req := new(otsprotocol.DeleteSearchIndexRequest) + req.TableName = proto.String(request.TableName) + req.IndexName = proto.String(request.IndexName) + + resp := new(otsprotocol.DeleteSearchIndexResponse) + response := &DeleteSearchIndexResponse{} + if err := tableStoreClient.doRequestWithRetry(deleteSearchIndexUri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + return response, nil +} + +func (tableStoreClient *TableStoreClient) ListSearchIndex(request *ListSearchIndexRequest) (*ListSearchIndexResponse, error) { + req := new(otsprotocol.ListSearchIndexRequest) + req.TableName = proto.String(request.TableName) + + resp := new(otsprotocol.ListSearchIndexResponse) + response := &ListSearchIndexResponse{} + if err := tableStoreClient.doRequestWithRetry(listSearchIndexUri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + indexs := make([]*IndexInfo, 0) + for _, info := range resp.Indices { + indexs = append(indexs, &IndexInfo{ + TableName: *info.TableName, + IndexName: *info.IndexName, + }) + } + response.IndexInfo = indexs + return response, nil +} + +func (tableStoreClient *TableStoreClient) DescribeSearchIndex(request *DescribeSearchIndexRequest) (*DescribeSearchIndexResponse, error) { + req := new(otsprotocol.DescribeSearchIndexRequest) + req.TableName = proto.String(request.TableName) + req.IndexName = proto.String(request.IndexName) + + resp := new(otsprotocol.DescribeSearchIndexResponse) + response := &DescribeSearchIndexResponse{} + if err := tableStoreClient.doRequestWithRetry(describeSearchIndexUri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + schema, err := parseFromPbSchema(resp.Schema) + if err != nil { + return nil, err + } + response.Schema = schema + if resp.SyncStat != nil { + response.SyncStat = &SyncStat{ + CurrentSyncTimestamp: resp.SyncStat.CurrentSyncTimestamp, + } + syncPhase := resp.SyncStat.SyncPhase + if syncPhase == nil { + return nil, errors.New("missing [SyncPhase] in DescribeSearchIndexResponse") + } else if *syncPhase == otsprotocol.SyncPhase_FULL { + response.SyncStat.SyncPhase = SyncPhase_FULL + } else if *syncPhase == otsprotocol.SyncPhase_INCR { + response.SyncStat.SyncPhase = SyncPhase_INCR + } else { + return nil, errors.New(fmt.Sprintf("unknown SyncPhase: %v", syncPhase)) + } + } + return response, nil +} + +func (tableStoreClient *TableStoreClient) Search(request *SearchRequest) (*SearchResponse, error) { + req, err := request.ProtoBuffer() + if err != nil { + return nil, err + } + resp := new(otsprotocol.SearchResponse) + response := &SearchResponse{} + if err := tableStoreClient.doRequestWithRetry(searchUri, req, resp, &response.ResponseInfo); err != nil { + return nil, err + } + response.TotalCount = *resp.TotalHits + + rows := make([]*PlainBufferRow, 0) + for _, buf := range resp.Rows { + row, err := readRowsWithHeader(bytes.NewReader(buf)) + if err != nil { + return nil, err + } + rows = append(rows, row[0]) + } + + for _, row := range rows { + currentRow := &Row{} + currentPk := new(PrimaryKey) + for _, pk := range row.primaryKey { + pkColumn := &PrimaryKeyColumn{ColumnName: string(pk.cellName), Value: pk.cellValue.Value} + currentPk.PrimaryKeys = append(currentPk.PrimaryKeys, pkColumn) + } + currentRow.PrimaryKey = currentPk + for _, cell := range row.cells { + dataColumn := &AttributeColumn{ColumnName: string(cell.cellName), Value: cell.cellValue.Value, Timestamp: cell.cellTimestamp} + currentRow.Columns = append(currentRow.Columns, dataColumn) + } + response.Rows = append(response.Rows, currentRow) + } + + response.IsAllSuccess = *resp.IsAllSucceeded + if resp.NextToken != nil && len(resp.NextToken) > 0 { + response.NextToken = resp.NextToken + } + return response, nil +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search_model.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search_model.go new file mode 100644 index 000000000000..6ec022e5f234 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search_model.go @@ -0,0 +1,327 @@ +package tablestore + +import ( + "encoding/json" + "errors" + + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search" + "github.com/golang/protobuf/proto" +) + +type ColumnsToGet struct { + Columns []string + ReturnAll bool +} + +type SearchRequest struct { + TableName string + IndexName string + SearchQuery search.SearchQuery + ColumnsToGet *ColumnsToGet + RoutingValues []*PrimaryKey +} + +func (r *SearchRequest) SetTableName(tableName string) *SearchRequest { + r.TableName = tableName + return r +} + +func (r *SearchRequest) SetIndexName(indexName string) *SearchRequest { + r.IndexName = indexName + return r +} + +func (r *SearchRequest) SetSearchQuery(searchQuery search.SearchQuery) *SearchRequest { + r.SearchQuery = searchQuery + return r +} + +func (r *SearchRequest) SetColumnsToGet(columnToGet *ColumnsToGet) *SearchRequest { + r.ColumnsToGet = columnToGet + return r +} + +func (r *SearchRequest) SetRoutingValues(routingValues []*PrimaryKey) *SearchRequest { + r.RoutingValues = routingValues + return r +} + +func (r *SearchRequest) AddRoutingValue(routingValue *PrimaryKey) *SearchRequest { + r.RoutingValues = append(r.RoutingValues, routingValue) + return r +} + +func (r *SearchRequest) ProtoBuffer() (*otsprotocol.SearchRequest, error) { + req := &otsprotocol.SearchRequest{} + req.TableName = &r.TableName + req.IndexName = &r.IndexName + query, err := r.SearchQuery.Serialize() + if err != nil { + return nil, err + } + req.SearchQuery = query + pbColumns := &otsprotocol.ColumnsToGet{} + pbColumns.ReturnType = otsprotocol.ColumnReturnType_RETURN_NONE.Enum() + if r.ColumnsToGet != nil { + if r.ColumnsToGet.ReturnAll { + pbColumns.ReturnType = otsprotocol.ColumnReturnType_RETURN_ALL.Enum() + } else if len(r.ColumnsToGet.Columns) > 0 { + pbColumns.ReturnType = otsprotocol.ColumnReturnType_RETURN_SPECIFIED.Enum() + pbColumns.ColumnNames = r.ColumnsToGet.Columns + } + } + req.ColumnsToGet = pbColumns + if r.RoutingValues != nil { + for _, routingValue := range r.RoutingValues { + req.RoutingValues = append(req.RoutingValues, routingValue.Build(false)) + } + } + return req, err +} + +type SearchResponse struct { + TotalCount int64 + Rows []*Row + IsAllSuccess bool + NextToken []byte + ResponseInfo +} + +func convertFieldSchemaToPBFieldSchema(fieldSchemas []*FieldSchema) []*otsprotocol.FieldSchema { + var schemas []*otsprotocol.FieldSchema + for _, value := range fieldSchemas { + field := new(otsprotocol.FieldSchema) + + field.FieldName = proto.String(*value.FieldName) + field.FieldType = otsprotocol.FieldType(int32(value.FieldType)).Enum() + + if value.Index != nil { + field.Index = proto.Bool(*value.Index) + } else if value.FieldType != FieldType_NESTED { + field.Index = proto.Bool(true) + } + if value.IndexOptions != nil { + field.IndexOptions = otsprotocol.IndexOptions(int32(*value.IndexOptions)).Enum() + } + if value.Analyzer != nil { + field.Analyzer = proto.String(string(*value.Analyzer)) + } + if value.EnableSortAndAgg != nil { + field.DocValues = proto.Bool(*value.EnableSortAndAgg) + } + if value.Store != nil { + field.Store = proto.Bool(*value.Store) + } else if value.FieldType != FieldType_NESTED { + if *field.FieldType == otsprotocol.FieldType_TEXT { + field.Store = proto.Bool(false) + } else { + field.Store = proto.Bool(true) + } + } + if value.IsArray != nil { + field.IsArray = proto.Bool(*value.IsArray) + } + if value.FieldType == FieldType_NESTED { + field.FieldSchemas = convertFieldSchemaToPBFieldSchema(value.FieldSchemas) + } + + schemas = append(schemas, field) + } + + return schemas +} + +func convertToPbSchema(schema *IndexSchema) (*otsprotocol.IndexSchema, error) { + indexSchema := new(otsprotocol.IndexSchema) + indexSchema.FieldSchemas = convertFieldSchemaToPBFieldSchema(schema.FieldSchemas) + indexSchema.IndexSetting = new(otsprotocol.IndexSetting) + var defaultNumberOfShards int32 = 1 + indexSchema.IndexSetting.NumberOfShards = &defaultNumberOfShards + if schema.IndexSetting != nil { + indexSchema.IndexSetting.RoutingFields = schema.IndexSetting.RoutingFields + } + if schema.IndexSort != nil { + pbSort, err := schema.IndexSort.ProtoBuffer() + if err != nil { + return nil, err + } + indexSchema.IndexSort = pbSort + } + return indexSchema, nil +} + +func parseFieldSchemaFromPb(pbFieldSchemas []*otsprotocol.FieldSchema) []*FieldSchema { + var schemas []*FieldSchema + for _, value := range pbFieldSchemas { + field := new(FieldSchema) + field.FieldName = value.FieldName + field.FieldType = FieldType(*value.FieldType) + field.Index = value.Index + if value.IndexOptions != nil { + indexOption := IndexOptions(*value.IndexOptions) + field.IndexOptions = &indexOption + } + field.Analyzer = (*Analyzer)(value.Analyzer) + field.EnableSortAndAgg = value.DocValues + field.Store = value.Store + field.IsArray = value.IsArray + if field.FieldType == FieldType_NESTED { + field.FieldSchemas = parseFieldSchemaFromPb(value.FieldSchemas) + } + schemas = append(schemas, field) + } + return schemas +} + +func parseIndexSortFromPb(pbIndexSort *otsprotocol.Sort) (*search.Sort, error) { + indexSort := &search.Sort{ + Sorters: make([]search.Sorter, 0), + } + for _, sorter := range pbIndexSort.GetSorter() { + if sorter.GetFieldSort() != nil { + fieldSort := &search.FieldSort{ + FieldName: *sorter.GetFieldSort().FieldName, + Order: search.ParseSortOrder(sorter.GetFieldSort().Order), + } + indexSort.Sorters = append(indexSort.Sorters, fieldSort) + } else if sorter.GetPkSort() != nil { + pkSort := &search.PrimaryKeySort{ + Order: search.ParseSortOrder(sorter.GetPkSort().Order), + } + indexSort.Sorters = append(indexSort.Sorters, pkSort) + } else { + return nil, errors.New("unknown index sort type") + } + } + return indexSort, nil +} + +func parseFromPbSchema(pbSchema *otsprotocol.IndexSchema) (*IndexSchema, error) { + schema := &IndexSchema{ + IndexSetting: &IndexSetting{ + RoutingFields: pbSchema.IndexSetting.RoutingFields, + }, + } + schema.FieldSchemas = parseFieldSchemaFromPb(pbSchema.GetFieldSchemas()) + indexSort, err := parseIndexSortFromPb(pbSchema.GetIndexSort()) + if err != nil { + return nil, err + } + schema.IndexSort = indexSort + return schema, nil +} + +type IndexSchema struct { + IndexSetting *IndexSetting + FieldSchemas []*FieldSchema + IndexSort *search.Sort +} + +type FieldType int32 + +const ( + FieldType_LONG FieldType = 1 + FieldType_DOUBLE FieldType = 2 + FieldType_BOOLEAN FieldType = 3 + FieldType_KEYWORD FieldType = 4 + FieldType_TEXT FieldType = 5 + FieldType_NESTED FieldType = 6 + FieldType_GEO_POINT FieldType = 7 +) + +type IndexOptions int32 + +const ( + IndexOptions_DOCS IndexOptions = 1 + IndexOptions_FREQS IndexOptions = 2 + IndexOptions_POSITIONS IndexOptions = 3 + IndexOptions_OFFSETS IndexOptions = 4 +) + +type Analyzer string + +const ( + Analyzer_SingleWord Analyzer = "single_word" + Analyzer_MaxWord Analyzer = "max_word" +) + +type FieldSchema struct { + FieldName *string + FieldType FieldType + Index *bool + IndexOptions *IndexOptions + Analyzer *Analyzer + EnableSortAndAgg *bool + Store *bool + IsArray *bool + FieldSchemas []*FieldSchema +} + +func (fs *FieldSchema) String() string { + out, err := json.Marshal(fs) + if err != nil { + panic(err) + } + return string(out) +} + +type IndexSetting struct { + RoutingFields []string +} + +type CreateSearchIndexRequest struct { + TableName string + IndexName string + IndexSchema *IndexSchema +} + +type CreateSearchIndexResponse struct { + ResponseInfo ResponseInfo +} + +type DescribeSearchIndexRequest struct { + TableName string + IndexName string +} + +type SyncPhase int32 + +const ( + SyncPhase_FULL SyncPhase = 1 + SyncPhase_INCR SyncPhase = 2 +) + +type SyncStat struct { + SyncPhase SyncPhase + CurrentSyncTimestamp *int64 +} + +type DescribeSearchIndexResponse struct { + Schema *IndexSchema + SyncStat *SyncStat + ResponseInfo ResponseInfo +} + +type ListSearchIndexRequest struct { + TableName string +} + +type IndexInfo struct { + TableName string + IndexName string +} + +type ListSearchIndexResponse struct { + IndexInfo []*IndexInfo + ResponseInfo ResponseInfo +} + +type DeleteSearchIndexRequest struct { + TableName string + IndexName string +} + +type DeleteSearchIndexResponse struct { + ResponseInfo ResponseInfo +} diff --git a/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/util.go b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/util.go new file mode 100644 index 000000000000..cedcce71c832 --- /dev/null +++ b/vendor/github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/util.go @@ -0,0 +1,982 @@ +package tablestore + +import ( + "bytes" + "fmt" + "github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol" + "github.com/golang/protobuf/proto" + "io" + "io/ioutil" + "math" + "net/http" + "reflect" + "sort" +) + +const ( + maxTableNameLength = 100 + maxPrimaryKeyLength = 255 + maxPrimaryKeyNum = 4 + maxMultiDeleteRows = 100 +) + +type ColumnType int32 + +const ( + ColumnType_STRING ColumnType = 1 + ColumnType_INTEGER ColumnType = 2 + ColumnType_BOOLEAN ColumnType = 3 + ColumnType_DOUBLE ColumnType = 4 + ColumnType_BINARY ColumnType = 5 +) + +const ( + Version = "1.0" + ApiVersion = "2015-12-31" + xOtsDateFormat = "2006-01-02T15:04:05.123Z" + xOtsInstanceName = "x-ots-instancename" + xOtsRequestId = "x-ots-requestid" +) + +type ColumnValue struct { + Type ColumnType + Value interface{} +} + +func (cv *ColumnValue) writeCellValue(w io.Writer) { + writeTag(w, TAG_CELL_VALUE) + if cv == nil { + writeRawLittleEndian32(w, 1) + writeRawByte(w, VT_AUTO_INCREMENT) + return + } + + switch cv.Type { + case ColumnType_STRING: + v := cv.Value.(string) + + writeRawLittleEndian32(w, int32(LITTLE_ENDIAN_32_SIZE+1+len(v))) // length + type + value + writeRawByte(w, VT_STRING) + writeRawLittleEndian32(w, int32(len(v))) + writeBytes(w, []byte(v)) + + case ColumnType_INTEGER: + v := cv.Value.(int64) + writeRawLittleEndian32(w, int32(LITTLE_ENDIAN_64_SIZE+1)) + writeRawByte(w, VT_INTEGER) + writeRawLittleEndian64(w, v) + case ColumnType_BOOLEAN: + v := cv.Value.(bool) + writeRawLittleEndian32(w, 2) + writeRawByte(w, VT_BOOLEAN) + writeBoolean(w, v) + + case ColumnType_DOUBLE: + v := cv.Value.(float64) + + writeRawLittleEndian32(w, LITTLE_ENDIAN_64_SIZE+1) + writeRawByte(w, VT_DOUBLE) + writeDouble(w, v) + + case ColumnType_BINARY: + v := cv.Value.([]byte) + + writeRawLittleEndian32(w, int32(LITTLE_ENDIAN_32_SIZE+1+len(v))) // length + type + value + writeRawByte(w, VT_BLOB) + writeRawLittleEndian32(w, int32(len(v))) + writeBytes(w, v) + } +} + +func (cv *ColumnValue) writeCellValueWithoutLengthPrefix() []byte { + var b bytes.Buffer + w := &b + switch cv.Type { + case ColumnType_STRING: + v := cv.Value.(string) + + writeRawByte(w, VT_STRING) + writeRawLittleEndian32(w, int32(len(v))) + writeBytes(w, []byte(v)) + + case ColumnType_INTEGER: + v := cv.Value.(int64) + writeRawByte(w, VT_INTEGER) + writeRawLittleEndian64(w, v) + case ColumnType_BOOLEAN: + v := cv.Value.(bool) + writeRawByte(w, VT_BOOLEAN) + writeBoolean(w, v) + + case ColumnType_DOUBLE: + v := cv.Value.(float64) + + writeRawByte(w, VT_DOUBLE) + writeDouble(w, v) + + case ColumnType_BINARY: + v := cv.Value.([]byte) + + writeRawByte(w, VT_BLOB) + writeRawLittleEndian32(w, int32(len(v))) + writeBytes(w, v) + } + + return b.Bytes() +} + +func (cv *ColumnValue) getCheckSum(crc byte) byte { + if cv == nil { + return crc8Byte(crc, VT_AUTO_INCREMENT) + } + + switch cv.Type { + case ColumnType_STRING: + v := cv.Value.(string) + crc = crc8Byte(crc, VT_STRING) + crc = crc8Int32(crc, int32(len(v))) + crc = crc8Bytes(crc, []byte(v)) + case ColumnType_INTEGER: + v := cv.Value.(int64) + crc = crc8Byte(crc, VT_INTEGER) + crc = crc8Int64(crc, v) + case ColumnType_BOOLEAN: + v := cv.Value.(bool) + crc = crc8Byte(crc, VT_BOOLEAN) + if v { + crc = crc8Byte(crc, 0x1) + } else { + crc = crc8Byte(crc, 0x0) + } + + case ColumnType_DOUBLE: + v := cv.Value.(float64) + crc = crc8Byte(crc, VT_DOUBLE) + crc = crc8Int64(crc, int64(math.Float64bits(v))) + case ColumnType_BINARY: + v := cv.Value.([]byte) + crc = crc8Byte(crc, VT_BLOB) + crc = crc8Int32(crc, int32(len(v))) + crc = crc8Bytes(crc, v) + } + + return crc +} + +type Column struct { + Name []byte + Value ColumnValue + Type byte + Timestamp int64 + HasType bool + HasTimestamp bool + IgnoreValue bool +} + +func NewColumn(name []byte, value interface{}) *Column { + + v := &Column{} + v.Name = name + + if value != nil { + t := reflect.TypeOf(value) + switch t.Kind() { + case reflect.String: + v.Value.Type = ColumnType_STRING + + case reflect.Int64: + v.Value.Type = ColumnType_INTEGER + + case reflect.Bool: + v.Value.Type = ColumnType_BOOLEAN + + case reflect.Float64: + v.Value.Type = ColumnType_DOUBLE + + case reflect.Slice: + v.Value.Type = ColumnType_BINARY + default: + panic(errInvalidInput) + } + + v.Value.Value = value + } + + return v +} + +func (c *Column) toPlainBufferCell(ignoreValue bool) *PlainBufferCell { + cell := &PlainBufferCell{} + cell.cellName = c.Name + cell.ignoreValue = ignoreValue + if ignoreValue == false { + cell.cellValue = &c.Value + } + + if c.HasType { + cell.hasCellType = c.HasType + cell.cellType = byte(c.Type) + } + + if c.HasTimestamp { + cell.hasCellTimestamp = c.HasTimestamp + cell.cellTimestamp = c.Timestamp + } + + return cell +} + +type PrimaryKeyColumnInner struct { + Name []byte + Type otsprotocol.PrimaryKeyType + Value interface{} +} + +func NewPrimaryKeyColumnINF_MAX(name []byte) *PrimaryKeyColumnInner { + v := &PrimaryKeyColumnInner{} + v.Name = name + v.Type = 0 + v.Value = "INF_MAX" + + return v +} + +func NewPrimaryKeyColumnINF_MIN(name []byte) *PrimaryKeyColumnInner { + v := &PrimaryKeyColumnInner{} + v.Name = name + v.Type = 0 + v.Value = "INF_MIN" + + return v +} + +func NewPrimaryKeyColumnAuto_Increment(name []byte) *PrimaryKeyColumnInner { + v := &PrimaryKeyColumnInner{} + v.Name = name + v.Type = 0 + v.Value = "AUTO_INCRMENT" + return v +} + +func NewPrimaryKeyColumn(name []byte, value interface{}, option PrimaryKeyOption) *PrimaryKeyColumnInner { + + if option == NONE { + v := &PrimaryKeyColumnInner{} + v.Name = name + + t := reflect.TypeOf(value) + switch t.Kind() { + case reflect.String: + v.Type = otsprotocol.PrimaryKeyType_STRING + + case reflect.Int64: + v.Type = otsprotocol.PrimaryKeyType_INTEGER + + case reflect.Slice: + v.Type = otsprotocol.PrimaryKeyType_BINARY + + default: + panic(errInvalidInput) + } + + v.Value = value + + return v + } else if option == AUTO_INCREMENT { + return NewPrimaryKeyColumnAuto_Increment(name) + } else if option == MIN { + return NewPrimaryKeyColumnINF_MIN(name) + } else { + return NewPrimaryKeyColumnINF_MAX(name) + } +} + +func (pkc *PrimaryKeyColumnInner) toColumnValue() *ColumnValue { + switch pkc.Type { + case otsprotocol.PrimaryKeyType_INTEGER: + return &ColumnValue{ColumnType_INTEGER, pkc.Value} + case otsprotocol.PrimaryKeyType_STRING: + return &ColumnValue{ColumnType_STRING, pkc.Value} + case otsprotocol.PrimaryKeyType_BINARY: + return &ColumnValue{ColumnType_BINARY, pkc.Value} + } + + return nil +} + +func (pkc *PrimaryKeyColumnInner) toPlainBufferCell() *PlainBufferCell { + cell := &PlainBufferCell{} + cell.cellName = pkc.Name + cell.cellValue = pkc.toColumnValue() + return cell +} + +func (pkc *PrimaryKeyColumnInner) isInfMin() bool { + if pkc.Type == 0 && pkc.Value.(string) == "INF_MIN" { + return true + } + + return false +} + +func (pkc *PrimaryKeyColumnInner) isInfMax() bool { + if pkc.Type == 0 && pkc.Value.(string) == "INF_MAX" { + return true + } + + return false +} + +func (pkc *PrimaryKeyColumnInner) isAutoInc() bool { + if pkc.Type == 0 && pkc.Value.(string) == "AUTO_INCRMENT" { + return true + } + return false +} + +func (pkc *PrimaryKeyColumnInner) getCheckSum(crc byte) byte { + if pkc.isInfMin() { + return crc8Byte(crc, VT_INF_MIN) + } + if pkc.isInfMax() { + return crc8Byte(crc, VT_INF_MAX) + } + if pkc.isAutoInc() { + return crc8Byte(crc, VT_AUTO_INCREMENT) + } + + return pkc.toColumnValue().getCheckSum(crc) +} + +func (pkc *PrimaryKeyColumnInner) writePrimaryKeyColumn(w io.Writer) { + writeTag(w, TAG_CELL) + writeCellName(w, []byte(pkc.Name)) + if pkc.isInfMin() { + writeTag(w, TAG_CELL_VALUE) + writeRawLittleEndian32(w, 1) + writeRawByte(w, VT_INF_MIN) + return + } + if pkc.isInfMax() { + writeTag(w, TAG_CELL_VALUE) + writeRawLittleEndian32(w, 1) + writeRawByte(w, VT_INF_MAX) + return + } + if pkc.isAutoInc() { + writeTag(w, TAG_CELL_VALUE) + writeRawLittleEndian32(w, 1) + writeRawByte(w, VT_AUTO_INCREMENT) + return + } + pkc.toColumnValue().writeCellValue(w) +} + +type PrimaryKey2 struct { + primaryKey []*PrimaryKeyColumnInner +} + +func (pk *PrimaryKey) Build(isDelete bool) []byte { + var b bytes.Buffer + writeHeader(&b) + writeTag(&b, TAG_ROW_PK) + + rowChecksum := byte(0x0) + var cellChecksum byte + + for _, column := range pk.PrimaryKeys { + primaryKeyColumn := NewPrimaryKeyColumn([]byte(column.ColumnName), column.Value, column.PrimaryKeyOption) + + cellChecksum = crc8Bytes(byte(0x0), []byte(primaryKeyColumn.Name)) + cellChecksum = primaryKeyColumn.getCheckSum(cellChecksum) + rowChecksum = crc8Byte(rowChecksum, cellChecksum) + primaryKeyColumn.writePrimaryKeyColumn(&b) + + writeTag(&b, TAG_CELL_CHECKSUM) + writeRawByte(&b, cellChecksum) + } + + // 没有deleteMarker, 要与0x0做crc. + if isDelete { + writeTag(&b, TAG_DELETE_ROW_MARKER) + rowChecksum = crc8Byte(rowChecksum, byte(0x1)) + } else { + rowChecksum = crc8Byte(rowChecksum, byte(0x0)) + } + writeTag(&b, TAG_ROW_CHECKSUM) + writeRawByte(&b, rowChecksum) + + return b.Bytes() +} + +type RowPutChange struct { + primaryKey []*PrimaryKeyColumnInner + columnsToPut []*Column +} + +type RowUpdateChange struct { + primaryKey []*PrimaryKeyColumnInner + columnsToUpdate []*Column +} + +func (rpc *RowPutChange) Build() []byte { + pkCells := make([]*PlainBufferCell, len(rpc.primaryKey)) + for i, pkc := range rpc.primaryKey { + pkCells[i] = pkc.toPlainBufferCell() + } + + cells := make([]*PlainBufferCell, len(rpc.columnsToPut)) + for i, c := range rpc.columnsToPut { + cells[i] = c.toPlainBufferCell(false) + } + + row := &PlainBufferRow{ + primaryKey: pkCells, + cells: cells} + var b bytes.Buffer + row.writeRowWithHeader(&b) + + return b.Bytes() +} + +func (ruc *RowUpdateChange) Build() []byte { + pkCells := make([]*PlainBufferCell, len(ruc.primaryKey)) + for i, pkc := range ruc.primaryKey { + pkCells[i] = pkc.toPlainBufferCell() + } + + cells := make([]*PlainBufferCell, len(ruc.columnsToUpdate)) + for i, c := range ruc.columnsToUpdate { + cells[i] = c.toPlainBufferCell(c.IgnoreValue) + } + + row := &PlainBufferRow{ + primaryKey: pkCells, + cells: cells} + var b bytes.Buffer + row.writeRowWithHeader(&b) + + return b.Bytes() +} + +const ( + MaxValue = "_get_range_max" + MinValue = "_get_range_min" +) + +func (comparatorType *ComparatorType) ConvertToPbComparatorType() otsprotocol.ComparatorType { + switch *comparatorType { + case CT_EQUAL: + return otsprotocol.ComparatorType_CT_EQUAL + case CT_NOT_EQUAL: + return otsprotocol.ComparatorType_CT_NOT_EQUAL + case CT_GREATER_THAN: + return otsprotocol.ComparatorType_CT_GREATER_THAN + case CT_GREATER_EQUAL: + return otsprotocol.ComparatorType_CT_GREATER_EQUAL + case CT_LESS_THAN: + return otsprotocol.ComparatorType_CT_LESS_THAN + default: + return otsprotocol.ComparatorType_CT_LESS_EQUAL + } +} + +func (columnType DefinedColumnType) ConvertToPbDefinedColumnType() otsprotocol.DefinedColumnType { + switch columnType { + case DefinedColumn_INTEGER: + return otsprotocol.DefinedColumnType_DCT_INTEGER + case DefinedColumn_DOUBLE: + return otsprotocol.DefinedColumnType_DCT_DOUBLE + case DefinedColumn_BOOLEAN: + return otsprotocol.DefinedColumnType_DCT_BOOLEAN + case DefinedColumn_STRING: + return otsprotocol.DefinedColumnType_DCT_STRING + default: + return otsprotocol.DefinedColumnType_DCT_BLOB + } +} + +func (loType *LogicalOperator) ConvertToPbLoType() otsprotocol.LogicalOperator { + switch *loType { + case LO_NOT: + return otsprotocol.LogicalOperator_LO_NOT + case LO_AND: + return otsprotocol.LogicalOperator_LO_AND + default: + return otsprotocol.LogicalOperator_LO_OR + } +} + +func ConvertToPbCastType(variantType VariantType) *otsprotocol.VariantType { + switch variantType { + case Variant_INTEGER: + return otsprotocol.VariantType_VT_INTEGER.Enum() + case Variant_DOUBLE: + return otsprotocol.VariantType_VT_DOUBLE.Enum() + case Variant_STRING: + return otsprotocol.VariantType_VT_STRING.Enum() + default: + panic("invalid VariantType") + } +} + +func NewValueTransferRule(regex string, vt VariantType) *ValueTransferRule{ + return &ValueTransferRule{Regex: regex, Cast_type: vt} +} + +func NewSingleColumnValueRegexFilter(columnName string, comparator ComparatorType, rule *ValueTransferRule, value interface{}) *SingleColumnCondition { + return &SingleColumnCondition{ColumnName: &columnName, Comparator: &comparator, ColumnValue: value, TransferRule: rule} +} + +func NewSingleColumnValueFilter(condition *SingleColumnCondition) *otsprotocol.SingleColumnValueFilter { + filter := new(otsprotocol.SingleColumnValueFilter) + + comparatorType := condition.Comparator.ConvertToPbComparatorType() + filter.Comparator = &comparatorType + filter.ColumnName = condition.ColumnName + col := NewColumn([]byte(*condition.ColumnName), condition.ColumnValue) + filter.ColumnValue = col.toPlainBufferCell(false).cellValue.writeCellValueWithoutLengthPrefix() + filter.FilterIfMissing = proto.Bool(condition.FilterIfMissing) + filter.LatestVersionOnly = proto.Bool(condition.LatestVersionOnly) + if condition.TransferRule != nil { + filter.ValueTransRule = &otsprotocol.ValueTransferRule{ Regex: proto.String(condition.TransferRule.Regex), CastType: ConvertToPbCastType(condition.TransferRule.Cast_type) } + } + return filter +} + +func NewCompositeFilter(filters []ColumnFilter, lo LogicalOperator) *otsprotocol.CompositeColumnValueFilter { + ccvfilter := new(otsprotocol.CompositeColumnValueFilter) + combinator := lo.ConvertToPbLoType() + ccvfilter.Combinator = &combinator + for _, cf := range filters { + filter := cf.ToFilter() + ccvfilter.SubFilters = append(ccvfilter.SubFilters, filter) + } + + return ccvfilter +} + +func NewPaginationFilter(filter *PaginationFilter) *otsprotocol.ColumnPaginationFilter { + pageFilter := new(otsprotocol.ColumnPaginationFilter) + pageFilter.Offset = proto.Int32(filter.Offset) + pageFilter.Limit = proto.Int32(filter.Limit) + return pageFilter +} + +func (otsClient *TableStoreClient) postReq(req *http.Request, url string) ([]byte, error, string) { + resp, err := otsClient.httpClient.Do(req) + if err != nil { + return nil, err, "" + } + defer resp.Body.Close() + + reqId := getRequestId(resp) + body, err := ioutil.ReadAll(resp.Body) + if err != nil { + return nil, err, reqId + } + + if (resp.StatusCode >= 200 && resp.StatusCode < 300) == false { + var retErr *OtsError + perr := new(otsprotocol.Error) + errUm := proto.Unmarshal(body, perr) + if errUm != nil { + retErr = rawHttpToOtsError(resp.StatusCode, body, reqId) + } else { + retErr = pbErrToOtsError(perr, reqId) + } + return nil, retErr, reqId + } + + return body, nil, reqId +} + +func rawHttpToOtsError(code int, body []byte, reqId string) *OtsError { + oerr := &OtsError{ + Message: string(body), + RequestId: reqId, + } + if code >= 500 && code < 600 { + oerr.Code = SERVER_UNAVAILABLE + } else { + oerr.Code = OTS_CLIENT_UNKNOWN + } + return oerr +} + +func pbErrToOtsError(pbErr *otsprotocol.Error, reqId string) *OtsError { + return &OtsError{ + Code: pbErr.GetCode(), + Message: pbErr.GetMessage(), + RequestId: reqId, + } +} + +func getRequestId(response *http.Response) string { + if response == nil || response.Header == nil { + return "" + } + + return response.Header.Get(xOtsRequestId) +} + +func buildRowPutChange(primarykey *PrimaryKey, columns []AttributeColumn) *RowPutChange { + row := new(RowPutChange) + row.primaryKey = make([]*PrimaryKeyColumnInner, len(primarykey.PrimaryKeys)) + for i, p := range primarykey.PrimaryKeys { + row.primaryKey[i] = NewPrimaryKeyColumn([]byte(p.ColumnName), p.Value, p.PrimaryKeyOption) + } + + row.columnsToPut = make([]*Column, len(columns)) + for i, p := range columns { + row.columnsToPut[i] = NewColumn([]byte(p.ColumnName), p.Value) + if p.Timestamp != 0 { + row.columnsToPut[i].HasTimestamp = true + row.columnsToPut[i].Timestamp = p.Timestamp + } + } + + return row +} + +func buildRowUpdateChange(primarykey *PrimaryKey, columns []ColumnToUpdate) *RowUpdateChange { + row := new(RowUpdateChange) + row.primaryKey = make([]*PrimaryKeyColumnInner, len(primarykey.PrimaryKeys)) + for i, p := range primarykey.PrimaryKeys { + row.primaryKey[i] = NewPrimaryKeyColumn([]byte(p.ColumnName), p.Value, p.PrimaryKeyOption) + } + + row.columnsToUpdate = make([]*Column, len(columns)) + for i, p := range columns { + row.columnsToUpdate[i] = NewColumn([]byte(p.ColumnName), p.Value) + row.columnsToUpdate[i].HasTimestamp = p.HasTimestamp + row.columnsToUpdate[i].HasType = p.HasType + row.columnsToUpdate[i].Type = p.Type + row.columnsToUpdate[i].Timestamp = p.Timestamp + row.columnsToUpdate[i].IgnoreValue = p.IgnoreValue + } + + return row +} + +func (condition *RowCondition) buildCondition() *otsprotocol.RowExistenceExpectation { + switch condition.RowExistenceExpectation { + case RowExistenceExpectation_IGNORE: + return otsprotocol.RowExistenceExpectation_IGNORE.Enum() + case RowExistenceExpectation_EXPECT_EXIST: + return otsprotocol.RowExistenceExpectation_EXPECT_EXIST.Enum() + case RowExistenceExpectation_EXPECT_NOT_EXIST: + return otsprotocol.RowExistenceExpectation_EXPECT_NOT_EXIST.Enum() + } + + panic(errInvalidInput) +} + +// build primary key for create table, put row, delete row and update row +// value only support int64,string,[]byte or you will get panic +func buildPrimaryKey(primaryKeyName string, value interface{}) *PrimaryKeyColumn { + // Todo: validate the input + return &PrimaryKeyColumn{ColumnName: primaryKeyName, Value: value, PrimaryKeyOption: NONE} +} + +// value only support int64,string,bool,float64,[]byte. other type will get panic +func (rowchange *PutRowChange) AddColumn(columnName string, value interface{}) { + // Todo: validate the input + column := &AttributeColumn{ColumnName: columnName, Value: value} + rowchange.Columns = append(rowchange.Columns, *column) +} + +func (rowchange *PutRowChange) SetReturnPk() { + rowchange.ReturnType = ReturnType(ReturnType_RT_PK) +} + +func (rowchange *UpdateRowChange) SetReturnIncrementValue() { + rowchange.ReturnType = ReturnType(ReturnType_RT_AFTER_MODIFY) +} + +func (rowchange *UpdateRowChange) AppendIncrementColumnToReturn(name string) { + rowchange.ColumnNamesToReturn = append(rowchange.ColumnNamesToReturn, name) +} + +// value only support int64,string,bool,float64,[]byte. other type will get panic +func (rowchange *PutRowChange) AddColumnWithTimestamp(columnName string, value interface{}, timestamp int64) { + // Todo: validate the input + column := &AttributeColumn{ColumnName: columnName, Value: value} + column.Timestamp = timestamp + rowchange.Columns = append(rowchange.Columns, *column) +} + +func (pk *PrimaryKey) AddPrimaryKeyColumn(primaryKeyName string, value interface{}) { + pk.PrimaryKeys = append(pk.PrimaryKeys, buildPrimaryKey(primaryKeyName, value)) +} + +func (pk *PrimaryKey) AddPrimaryKeyColumnWithAutoIncrement(primaryKeyName string) { + pk.PrimaryKeys = append(pk.PrimaryKeys, &PrimaryKeyColumn{ColumnName: primaryKeyName, PrimaryKeyOption: AUTO_INCREMENT}) +} + +func (pk *PrimaryKey) AddPrimaryKeyColumnWithMinValue(primaryKeyName string) { + pk.PrimaryKeys = append(pk.PrimaryKeys, &PrimaryKeyColumn{ColumnName: primaryKeyName, PrimaryKeyOption: MIN}) +} + +// Only used for range query +func (pk *PrimaryKey) AddPrimaryKeyColumnWithMaxValue(primaryKeyName string) { + pk.PrimaryKeys = append(pk.PrimaryKeys, &PrimaryKeyColumn{ColumnName: primaryKeyName, PrimaryKeyOption: MAX}) +} + +func (rowchange *PutRowChange) SetCondition(rowExistenceExpectation RowExistenceExpectation) { + rowchange.Condition = &RowCondition{RowExistenceExpectation: rowExistenceExpectation} +} + +func (rowchange *DeleteRowChange) SetCondition(rowExistenceExpectation RowExistenceExpectation) { + rowchange.Condition = &RowCondition{RowExistenceExpectation: rowExistenceExpectation} +} + +func (Criteria *SingleRowQueryCriteria) SetFilter(filter ColumnFilter) { + Criteria.Filter = filter +} + +func (Criteria *MultiRowQueryCriteria) SetFilter(filter ColumnFilter) { + Criteria.Filter = filter +} + +func NewSingleColumnCondition(columnName string, comparator ComparatorType, value interface{}) *SingleColumnCondition { + return &SingleColumnCondition{ColumnName: &columnName, Comparator: &comparator, ColumnValue: value} +} + +func NewCompositeColumnCondition(lo LogicalOperator) *CompositeColumnValueFilter { + return &CompositeColumnValueFilter{Operator: lo} +} + +func (rowchange *PutRowChange) SetColumnCondition(condition ColumnFilter) { + rowchange.Condition.ColumnCondition = condition +} + +func (rowchange *UpdateRowChange) SetCondition(rowExistenceExpectation RowExistenceExpectation) { + rowchange.Condition = &RowCondition{RowExistenceExpectation: rowExistenceExpectation} +} + +func (rowchange *UpdateRowChange) SetColumnCondition(condition ColumnFilter) { + rowchange.Condition.ColumnCondition = condition +} + +func (rowchange *DeleteRowChange) SetColumnCondition(condition ColumnFilter) { + rowchange.Condition.ColumnCondition = condition +} + +func (meta *TableMeta) AddPrimaryKeyColumn(name string, keyType PrimaryKeyType) { + meta.SchemaEntry = append(meta.SchemaEntry, &PrimaryKeySchema{Name: &name, Type: &keyType}) +} + +func (meta *TableMeta) AddPrimaryKeyColumnOption(name string, keyType PrimaryKeyType, keyOption PrimaryKeyOption) { + meta.SchemaEntry = append(meta.SchemaEntry, &PrimaryKeySchema{Name: &name, Type: &keyType, Option: &keyOption}) +} + +// value only support int64,string,bool,float64,[]byte. other type will get panic +func (rowchange *UpdateRowChange) PutColumn(columnName string, value interface{}) { + // Todo: validate the input + column := &ColumnToUpdate{ColumnName: columnName, Value: value} + rowchange.Columns = append(rowchange.Columns, *column) +} + +func (rowchange *UpdateRowChange) DeleteColumn(columnName string) { + // Todo: validate the input + column := &ColumnToUpdate{ColumnName: columnName, Value: nil, Type: DELETE_ALL_VERSION, HasType: true, IgnoreValue: true} + rowchange.Columns = append(rowchange.Columns, *column) +} + +func (rowchange *UpdateRowChange) DeleteColumnWithTimestamp(columnName string, timestamp int64) { + // Todo: validate the input + column := &ColumnToUpdate{ColumnName: columnName, Value: nil, Type: DELETE_ONE_VERSION, HasType: true, HasTimestamp: true, Timestamp: timestamp, IgnoreValue: true} + rowchange.Columns = append(rowchange.Columns, *column) +} + +func (rowchange *UpdateRowChange) IncrementColumn(columnName string, value int64) { + // Todo: validate the input + column := &ColumnToUpdate{ColumnName: columnName, Value: value, Type: INCREMENT, HasType: true, IgnoreValue: false} + rowchange.Columns = append(rowchange.Columns, *column) +} + +func (rowchange *DeleteRowChange) Serialize() []byte { + return rowchange.PrimaryKey.Build(true) +} + +func (rowchange *PutRowChange) Serialize() []byte { + row := buildRowPutChange(rowchange.PrimaryKey, rowchange.Columns) + return row.Build() +} + +func (rowchange *UpdateRowChange) Serialize() []byte { + row := buildRowUpdateChange(rowchange.PrimaryKey, rowchange.Columns) + return row.Build() +} + +func (rowchange *DeleteRowChange) GetTableName() string { + return rowchange.TableName +} + +func (rowchange *PutRowChange) GetTableName() string { + return rowchange.TableName +} + +func (rowchange *UpdateRowChange) GetTableName() string { + return rowchange.TableName +} + +func (rowchange *DeleteRowChange) getOperationType() otsprotocol.OperationType { + return otsprotocol.OperationType_DELETE +} + +func (rowchange *PutRowChange) getOperationType() otsprotocol.OperationType { + return otsprotocol.OperationType_PUT +} + +func (rowchange *UpdateRowChange) getOperationType() otsprotocol.OperationType { + return otsprotocol.OperationType_UPDATE +} + +func (rowchange *DeleteRowChange) getCondition() *otsprotocol.Condition { + condition := new(otsprotocol.Condition) + condition.RowExistence = rowchange.Condition.buildCondition() + if rowchange.Condition.ColumnCondition != nil { + condition.ColumnCondition = rowchange.Condition.ColumnCondition.Serialize() + } + return condition +} + +func (rowchange *UpdateRowChange) getCondition() *otsprotocol.Condition { + condition := new(otsprotocol.Condition) + condition.RowExistence = rowchange.Condition.buildCondition() + if rowchange.Condition.ColumnCondition != nil { + condition.ColumnCondition = rowchange.Condition.ColumnCondition.Serialize() + } + return condition +} + +func (rowchange *PutRowChange) getCondition() *otsprotocol.Condition { + condition := new(otsprotocol.Condition) + condition.RowExistence = rowchange.Condition.buildCondition() + if rowchange.Condition.ColumnCondition != nil { + condition.ColumnCondition = rowchange.Condition.ColumnCondition.Serialize() + } + return condition +} + +func (request *BatchWriteRowRequest) AddRowChange(change RowChange) { + if request.RowChangesGroupByTable == nil { + request.RowChangesGroupByTable = make(map[string][]RowChange) + } + request.RowChangesGroupByTable[change.GetTableName()] = append(request.RowChangesGroupByTable[change.GetTableName()], change) +} + +func (direction Direction) ToDirection() otsprotocol.Direction { + if direction == FORWARD { + return otsprotocol.Direction_FORWARD + } else { + return otsprotocol.Direction_BACKWARD + } +} + +func (columnMap *ColumnMap) GetRange(start int, count int) ([]*AttributeColumn, error) { + columns := []*AttributeColumn{} + + end := start + count + if len(columnMap.columnsKey) < end { + return nil, fmt.Errorf("invalid arugment") + } + + for i := start; i < end; i++ { + subColumns := columnMap.Columns[columnMap.columnsKey[i]] + for _, column := range subColumns { + columns = append(columns, column) + } + } + + return columns, nil +} + +func (response *GetRowResponse) GetColumnMap() *ColumnMap { + if response == nil { + return nil + } + if response.columnMap != nil { + return response.columnMap + } else { + response.columnMap = &ColumnMap{} + response.columnMap.Columns = make(map[string][]*AttributeColumn) + + if len(response.Columns) == 0 { + return response.columnMap + } else { + for _, column := range response.Columns { + if _, ok := response.columnMap.Columns[column.ColumnName]; ok { + response.columnMap.Columns[column.ColumnName] = append(response.columnMap.Columns[column.ColumnName], column) + } else { + response.columnMap.columnsKey = append(response.columnMap.columnsKey, column.ColumnName) + value := []*AttributeColumn{} + value = append(value, column) + response.columnMap.Columns[column.ColumnName] = value + } + } + + sort.Strings(response.columnMap.columnsKey) + return response.columnMap + } + } +} + +func Assert(cond bool, msg string) { + if !cond { + panic(msg) + } +} + +func (meta *TableMeta) AddDefinedColumn(name string, definedType DefinedColumnType) { + meta.DefinedColumns = append(meta.DefinedColumns, &DefinedColumnSchema{Name: name, ColumnType: definedType}) +} + +func (meta *IndexMeta) AddDefinedColumn(name string) { + meta.DefinedColumns = append(meta.DefinedColumns, name) +} + +func (meta *IndexMeta) AddPrimaryKeyColumn(name string) { + meta.Primarykey = append(meta.Primarykey, name) +} + +func (request *CreateTableRequest) AddIndexMeta(meta *IndexMeta) { + request.IndexMetas = append(request.IndexMetas, meta) +} + +func (meta *IndexMeta) ConvertToPbIndexMeta() *otsprotocol.IndexMeta { + return &otsprotocol.IndexMeta { + Name: &meta.IndexName, + PrimaryKey: meta.Primarykey, + DefinedColumn: meta.DefinedColumns, + IndexUpdateMode: otsprotocol.IndexUpdateMode_IUM_ASYNC_INDEX.Enum(), + IndexType: otsprotocol.IndexType_IT_GLOBAL_INDEX.Enum(), + } +} + +func ConvertPbIndexTypeToIndexType(indexType *otsprotocol.IndexType) IndexType { + switch *indexType { + case otsprotocol.IndexType_IT_GLOBAL_INDEX: + return IT_GLOBAL_INDEX + default: + return IT_LOCAL_INDEX + } +} +func ConvertPbIndexMetaToIndexMeta(meta *otsprotocol.IndexMeta) *IndexMeta { + indexmeta := &IndexMeta { + IndexName: *meta.Name, + IndexType: ConvertPbIndexTypeToIndexType(meta.IndexType), + } + + for _, pk := range meta.PrimaryKey { + indexmeta.Primarykey = append(indexmeta.Primarykey, pk) + } + + for _, col := range meta.DefinedColumn { + indexmeta.DefinedColumns = append(indexmeta.DefinedColumns, col) + } + + return indexmeta +} diff --git a/vendor/github.com/pmezard/go-difflib/LICENSE b/vendor/github.com/pmezard/go-difflib/LICENSE deleted file mode 100644 index c67dad612a3d..000000000000 --- a/vendor/github.com/pmezard/go-difflib/LICENSE +++ /dev/null @@ -1,27 +0,0 @@ -Copyright (c) 2013, Patrick Mezard -All rights reserved. - -Redistribution and use in source and binary forms, with or without -modification, are permitted provided that the following conditions are -met: - - Redistributions of source code must retain the above copyright -notice, this list of conditions and the following disclaimer. - Redistributions in binary form must reproduce the above copyright -notice, this list of conditions and the following disclaimer in the -documentation and/or other materials provided with the distribution. - The names of its contributors may not be used to endorse or promote -products derived from this software without specific prior written -permission. - -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS -IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED -TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED -TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF -LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING -NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS -SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/vendor/github.com/pmezard/go-difflib/difflib/difflib.go b/vendor/github.com/pmezard/go-difflib/difflib/difflib.go deleted file mode 100644 index 003e99fadb4f..000000000000 --- a/vendor/github.com/pmezard/go-difflib/difflib/difflib.go +++ /dev/null @@ -1,772 +0,0 @@ -// Package difflib is a partial port of Python difflib module. -// -// It provides tools to compare sequences of strings and generate textual diffs. -// -// The following class and functions have been ported: -// -// - SequenceMatcher -// -// - unified_diff -// -// - context_diff -// -// Getting unified diffs was the main goal of the port. Keep in mind this code -// is mostly suitable to output text differences in a human friendly way, there -// are no guarantees generated diffs are consumable by patch(1). -package difflib - -import ( - "bufio" - "bytes" - "fmt" - "io" - "strings" -) - -func min(a, b int) int { - if a < b { - return a - } - return b -} - -func max(a, b int) int { - if a > b { - return a - } - return b -} - -func calculateRatio(matches, length int) float64 { - if length > 0 { - return 2.0 * float64(matches) / float64(length) - } - return 1.0 -} - -type Match struct { - A int - B int - Size int -} - -type OpCode struct { - Tag byte - I1 int - I2 int - J1 int - J2 int -} - -// SequenceMatcher compares sequence of strings. The basic -// algorithm predates, and is a little fancier than, an algorithm -// published in the late 1980's by Ratcliff and Obershelp under the -// hyperbolic name "gestalt pattern matching". The basic idea is to find -// the longest contiguous matching subsequence that contains no "junk" -// elements (R-O doesn't address junk). The same idea is then applied -// recursively to the pieces of the sequences to the left and to the right -// of the matching subsequence. This does not yield minimal edit -// sequences, but does tend to yield matches that "look right" to people. -// -// SequenceMatcher tries to compute a "human-friendly diff" between two -// sequences. Unlike e.g. UNIX(tm) diff, the fundamental notion is the -// longest *contiguous* & junk-free matching subsequence. That's what -// catches peoples' eyes. The Windows(tm) windiff has another interesting -// notion, pairing up elements that appear uniquely in each sequence. -// That, and the method here, appear to yield more intuitive difference -// reports than does diff. This method appears to be the least vulnerable -// to synching up on blocks of "junk lines", though (like blank lines in -// ordinary text files, or maybe "

" lines in HTML files). That may be -// because this is the only method of the 3 that has a *concept* of -// "junk" . -// -// Timing: Basic R-O is cubic time worst case and quadratic time expected -// case. SequenceMatcher is quadratic time for the worst case and has -// expected-case behavior dependent in a complicated way on how many -// elements the sequences have in common; best case time is linear. -type SequenceMatcher struct { - a []string - b []string - b2j map[string][]int - IsJunk func(string) bool - autoJunk bool - bJunk map[string]struct{} - matchingBlocks []Match - fullBCount map[string]int - bPopular map[string]struct{} - opCodes []OpCode -} - -func NewMatcher(a, b []string) *SequenceMatcher { - m := SequenceMatcher{autoJunk: true} - m.SetSeqs(a, b) - return &m -} - -func NewMatcherWithJunk(a, b []string, autoJunk bool, - isJunk func(string) bool) *SequenceMatcher { - - m := SequenceMatcher{IsJunk: isJunk, autoJunk: autoJunk} - m.SetSeqs(a, b) - return &m -} - -// Set two sequences to be compared. -func (m *SequenceMatcher) SetSeqs(a, b []string) { - m.SetSeq1(a) - m.SetSeq2(b) -} - -// Set the first sequence to be compared. The second sequence to be compared is -// not changed. -// -// SequenceMatcher computes and caches detailed information about the second -// sequence, so if you want to compare one sequence S against many sequences, -// use .SetSeq2(s) once and call .SetSeq1(x) repeatedly for each of the other -// sequences. -// -// See also SetSeqs() and SetSeq2(). -func (m *SequenceMatcher) SetSeq1(a []string) { - if &a == &m.a { - return - } - m.a = a - m.matchingBlocks = nil - m.opCodes = nil -} - -// Set the second sequence to be compared. The first sequence to be compared is -// not changed. -func (m *SequenceMatcher) SetSeq2(b []string) { - if &b == &m.b { - return - } - m.b = b - m.matchingBlocks = nil - m.opCodes = nil - m.fullBCount = nil - m.chainB() -} - -func (m *SequenceMatcher) chainB() { - // Populate line -> index mapping - b2j := map[string][]int{} - for i, s := range m.b { - indices := b2j[s] - indices = append(indices, i) - b2j[s] = indices - } - - // Purge junk elements - m.bJunk = map[string]struct{}{} - if m.IsJunk != nil { - junk := m.bJunk - for s, _ := range b2j { - if m.IsJunk(s) { - junk[s] = struct{}{} - } - } - for s, _ := range junk { - delete(b2j, s) - } - } - - // Purge remaining popular elements - popular := map[string]struct{}{} - n := len(m.b) - if m.autoJunk && n >= 200 { - ntest := n/100 + 1 - for s, indices := range b2j { - if len(indices) > ntest { - popular[s] = struct{}{} - } - } - for s, _ := range popular { - delete(b2j, s) - } - } - m.bPopular = popular - m.b2j = b2j -} - -func (m *SequenceMatcher) isBJunk(s string) bool { - _, ok := m.bJunk[s] - return ok -} - -// Find longest matching block in a[alo:ahi] and b[blo:bhi]. -// -// If IsJunk is not defined: -// -// Return (i,j,k) such that a[i:i+k] is equal to b[j:j+k], where -// alo <= i <= i+k <= ahi -// blo <= j <= j+k <= bhi -// and for all (i',j',k') meeting those conditions, -// k >= k' -// i <= i' -// and if i == i', j <= j' -// -// In other words, of all maximal matching blocks, return one that -// starts earliest in a, and of all those maximal matching blocks that -// start earliest in a, return the one that starts earliest in b. -// -// If IsJunk is defined, first the longest matching block is -// determined as above, but with the additional restriction that no -// junk element appears in the block. Then that block is extended as -// far as possible by matching (only) junk elements on both sides. So -// the resulting block never matches on junk except as identical junk -// happens to be adjacent to an "interesting" match. -// -// If no blocks match, return (alo, blo, 0). -func (m *SequenceMatcher) findLongestMatch(alo, ahi, blo, bhi int) Match { - // CAUTION: stripping common prefix or suffix would be incorrect. - // E.g., - // ab - // acab - // Longest matching block is "ab", but if common prefix is - // stripped, it's "a" (tied with "b"). UNIX(tm) diff does so - // strip, so ends up claiming that ab is changed to acab by - // inserting "ca" in the middle. That's minimal but unintuitive: - // "it's obvious" that someone inserted "ac" at the front. - // Windiff ends up at the same place as diff, but by pairing up - // the unique 'b's and then matching the first two 'a's. - besti, bestj, bestsize := alo, blo, 0 - - // find longest junk-free match - // during an iteration of the loop, j2len[j] = length of longest - // junk-free match ending with a[i-1] and b[j] - j2len := map[int]int{} - for i := alo; i != ahi; i++ { - // look at all instances of a[i] in b; note that because - // b2j has no junk keys, the loop is skipped if a[i] is junk - newj2len := map[int]int{} - for _, j := range m.b2j[m.a[i]] { - // a[i] matches b[j] - if j < blo { - continue - } - if j >= bhi { - break - } - k := j2len[j-1] + 1 - newj2len[j] = k - if k > bestsize { - besti, bestj, bestsize = i-k+1, j-k+1, k - } - } - j2len = newj2len - } - - // Extend the best by non-junk elements on each end. In particular, - // "popular" non-junk elements aren't in b2j, which greatly speeds - // the inner loop above, but also means "the best" match so far - // doesn't contain any junk *or* popular non-junk elements. - for besti > alo && bestj > blo && !m.isBJunk(m.b[bestj-1]) && - m.a[besti-1] == m.b[bestj-1] { - besti, bestj, bestsize = besti-1, bestj-1, bestsize+1 - } - for besti+bestsize < ahi && bestj+bestsize < bhi && - !m.isBJunk(m.b[bestj+bestsize]) && - m.a[besti+bestsize] == m.b[bestj+bestsize] { - bestsize += 1 - } - - // Now that we have a wholly interesting match (albeit possibly - // empty!), we may as well suck up the matching junk on each - // side of it too. Can't think of a good reason not to, and it - // saves post-processing the (possibly considerable) expense of - // figuring out what to do with it. In the case of an empty - // interesting match, this is clearly the right thing to do, - // because no other kind of match is possible in the regions. - for besti > alo && bestj > blo && m.isBJunk(m.b[bestj-1]) && - m.a[besti-1] == m.b[bestj-1] { - besti, bestj, bestsize = besti-1, bestj-1, bestsize+1 - } - for besti+bestsize < ahi && bestj+bestsize < bhi && - m.isBJunk(m.b[bestj+bestsize]) && - m.a[besti+bestsize] == m.b[bestj+bestsize] { - bestsize += 1 - } - - return Match{A: besti, B: bestj, Size: bestsize} -} - -// Return list of triples describing matching subsequences. -// -// Each triple is of the form (i, j, n), and means that -// a[i:i+n] == b[j:j+n]. The triples are monotonically increasing in -// i and in j. It's also guaranteed that if (i, j, n) and (i', j', n') are -// adjacent triples in the list, and the second is not the last triple in the -// list, then i+n != i' or j+n != j'. IOW, adjacent triples never describe -// adjacent equal blocks. -// -// The last triple is a dummy, (len(a), len(b), 0), and is the only -// triple with n==0. -func (m *SequenceMatcher) GetMatchingBlocks() []Match { - if m.matchingBlocks != nil { - return m.matchingBlocks - } - - var matchBlocks func(alo, ahi, blo, bhi int, matched []Match) []Match - matchBlocks = func(alo, ahi, blo, bhi int, matched []Match) []Match { - match := m.findLongestMatch(alo, ahi, blo, bhi) - i, j, k := match.A, match.B, match.Size - if match.Size > 0 { - if alo < i && blo < j { - matched = matchBlocks(alo, i, blo, j, matched) - } - matched = append(matched, match) - if i+k < ahi && j+k < bhi { - matched = matchBlocks(i+k, ahi, j+k, bhi, matched) - } - } - return matched - } - matched := matchBlocks(0, len(m.a), 0, len(m.b), nil) - - // It's possible that we have adjacent equal blocks in the - // matching_blocks list now. - nonAdjacent := []Match{} - i1, j1, k1 := 0, 0, 0 - for _, b := range matched { - // Is this block adjacent to i1, j1, k1? - i2, j2, k2 := b.A, b.B, b.Size - if i1+k1 == i2 && j1+k1 == j2 { - // Yes, so collapse them -- this just increases the length of - // the first block by the length of the second, and the first - // block so lengthened remains the block to compare against. - k1 += k2 - } else { - // Not adjacent. Remember the first block (k1==0 means it's - // the dummy we started with), and make the second block the - // new block to compare against. - if k1 > 0 { - nonAdjacent = append(nonAdjacent, Match{i1, j1, k1}) - } - i1, j1, k1 = i2, j2, k2 - } - } - if k1 > 0 { - nonAdjacent = append(nonAdjacent, Match{i1, j1, k1}) - } - - nonAdjacent = append(nonAdjacent, Match{len(m.a), len(m.b), 0}) - m.matchingBlocks = nonAdjacent - return m.matchingBlocks -} - -// Return list of 5-tuples describing how to turn a into b. -// -// Each tuple is of the form (tag, i1, i2, j1, j2). The first tuple -// has i1 == j1 == 0, and remaining tuples have i1 == the i2 from the -// tuple preceding it, and likewise for j1 == the previous j2. -// -// The tags are characters, with these meanings: -// -// 'r' (replace): a[i1:i2] should be replaced by b[j1:j2] -// -// 'd' (delete): a[i1:i2] should be deleted, j1==j2 in this case. -// -// 'i' (insert): b[j1:j2] should be inserted at a[i1:i1], i1==i2 in this case. -// -// 'e' (equal): a[i1:i2] == b[j1:j2] -func (m *SequenceMatcher) GetOpCodes() []OpCode { - if m.opCodes != nil { - return m.opCodes - } - i, j := 0, 0 - matching := m.GetMatchingBlocks() - opCodes := make([]OpCode, 0, len(matching)) - for _, m := range matching { - // invariant: we've pumped out correct diffs to change - // a[:i] into b[:j], and the next matching block is - // a[ai:ai+size] == b[bj:bj+size]. So we need to pump - // out a diff to change a[i:ai] into b[j:bj], pump out - // the matching block, and move (i,j) beyond the match - ai, bj, size := m.A, m.B, m.Size - tag := byte(0) - if i < ai && j < bj { - tag = 'r' - } else if i < ai { - tag = 'd' - } else if j < bj { - tag = 'i' - } - if tag > 0 { - opCodes = append(opCodes, OpCode{tag, i, ai, j, bj}) - } - i, j = ai+size, bj+size - // the list of matching blocks is terminated by a - // sentinel with size 0 - if size > 0 { - opCodes = append(opCodes, OpCode{'e', ai, i, bj, j}) - } - } - m.opCodes = opCodes - return m.opCodes -} - -// Isolate change clusters by eliminating ranges with no changes. -// -// Return a generator of groups with up to n lines of context. -// Each group is in the same format as returned by GetOpCodes(). -func (m *SequenceMatcher) GetGroupedOpCodes(n int) [][]OpCode { - if n < 0 { - n = 3 - } - codes := m.GetOpCodes() - if len(codes) == 0 { - codes = []OpCode{OpCode{'e', 0, 1, 0, 1}} - } - // Fixup leading and trailing groups if they show no changes. - if codes[0].Tag == 'e' { - c := codes[0] - i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2 - codes[0] = OpCode{c.Tag, max(i1, i2-n), i2, max(j1, j2-n), j2} - } - if codes[len(codes)-1].Tag == 'e' { - c := codes[len(codes)-1] - i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2 - codes[len(codes)-1] = OpCode{c.Tag, i1, min(i2, i1+n), j1, min(j2, j1+n)} - } - nn := n + n - groups := [][]OpCode{} - group := []OpCode{} - for _, c := range codes { - i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2 - // End the current group and start a new one whenever - // there is a large range with no changes. - if c.Tag == 'e' && i2-i1 > nn { - group = append(group, OpCode{c.Tag, i1, min(i2, i1+n), - j1, min(j2, j1+n)}) - groups = append(groups, group) - group = []OpCode{} - i1, j1 = max(i1, i2-n), max(j1, j2-n) - } - group = append(group, OpCode{c.Tag, i1, i2, j1, j2}) - } - if len(group) > 0 && !(len(group) == 1 && group[0].Tag == 'e') { - groups = append(groups, group) - } - return groups -} - -// Return a measure of the sequences' similarity (float in [0,1]). -// -// Where T is the total number of elements in both sequences, and -// M is the number of matches, this is 2.0*M / T. -// Note that this is 1 if the sequences are identical, and 0 if -// they have nothing in common. -// -// .Ratio() is expensive to compute if you haven't already computed -// .GetMatchingBlocks() or .GetOpCodes(), in which case you may -// want to try .QuickRatio() or .RealQuickRation() first to get an -// upper bound. -func (m *SequenceMatcher) Ratio() float64 { - matches := 0 - for _, m := range m.GetMatchingBlocks() { - matches += m.Size - } - return calculateRatio(matches, len(m.a)+len(m.b)) -} - -// Return an upper bound on ratio() relatively quickly. -// -// This isn't defined beyond that it is an upper bound on .Ratio(), and -// is faster to compute. -func (m *SequenceMatcher) QuickRatio() float64 { - // viewing a and b as multisets, set matches to the cardinality - // of their intersection; this counts the number of matches - // without regard to order, so is clearly an upper bound - if m.fullBCount == nil { - m.fullBCount = map[string]int{} - for _, s := range m.b { - m.fullBCount[s] = m.fullBCount[s] + 1 - } - } - - // avail[x] is the number of times x appears in 'b' less the - // number of times we've seen it in 'a' so far ... kinda - avail := map[string]int{} - matches := 0 - for _, s := range m.a { - n, ok := avail[s] - if !ok { - n = m.fullBCount[s] - } - avail[s] = n - 1 - if n > 0 { - matches += 1 - } - } - return calculateRatio(matches, len(m.a)+len(m.b)) -} - -// Return an upper bound on ratio() very quickly. -// -// This isn't defined beyond that it is an upper bound on .Ratio(), and -// is faster to compute than either .Ratio() or .QuickRatio(). -func (m *SequenceMatcher) RealQuickRatio() float64 { - la, lb := len(m.a), len(m.b) - return calculateRatio(min(la, lb), la+lb) -} - -// Convert range to the "ed" format -func formatRangeUnified(start, stop int) string { - // Per the diff spec at http://www.unix.org/single_unix_specification/ - beginning := start + 1 // lines start numbering with one - length := stop - start - if length == 1 { - return fmt.Sprintf("%d", beginning) - } - if length == 0 { - beginning -= 1 // empty ranges begin at line just before the range - } - return fmt.Sprintf("%d,%d", beginning, length) -} - -// Unified diff parameters -type UnifiedDiff struct { - A []string // First sequence lines - FromFile string // First file name - FromDate string // First file time - B []string // Second sequence lines - ToFile string // Second file name - ToDate string // Second file time - Eol string // Headers end of line, defaults to LF - Context int // Number of context lines -} - -// Compare two sequences of lines; generate the delta as a unified diff. -// -// Unified diffs are a compact way of showing line changes and a few -// lines of context. The number of context lines is set by 'n' which -// defaults to three. -// -// By default, the diff control lines (those with ---, +++, or @@) are -// created with a trailing newline. This is helpful so that inputs -// created from file.readlines() result in diffs that are suitable for -// file.writelines() since both the inputs and outputs have trailing -// newlines. -// -// For inputs that do not have trailing newlines, set the lineterm -// argument to "" so that the output will be uniformly newline free. -// -// The unidiff format normally has a header for filenames and modification -// times. Any or all of these may be specified using strings for -// 'fromfile', 'tofile', 'fromfiledate', and 'tofiledate'. -// The modification times are normally expressed in the ISO 8601 format. -func WriteUnifiedDiff(writer io.Writer, diff UnifiedDiff) error { - buf := bufio.NewWriter(writer) - defer buf.Flush() - wf := func(format string, args ...interface{}) error { - _, err := buf.WriteString(fmt.Sprintf(format, args...)) - return err - } - ws := func(s string) error { - _, err := buf.WriteString(s) - return err - } - - if len(diff.Eol) == 0 { - diff.Eol = "\n" - } - - started := false - m := NewMatcher(diff.A, diff.B) - for _, g := range m.GetGroupedOpCodes(diff.Context) { - if !started { - started = true - fromDate := "" - if len(diff.FromDate) > 0 { - fromDate = "\t" + diff.FromDate - } - toDate := "" - if len(diff.ToDate) > 0 { - toDate = "\t" + diff.ToDate - } - if diff.FromFile != "" || diff.ToFile != "" { - err := wf("--- %s%s%s", diff.FromFile, fromDate, diff.Eol) - if err != nil { - return err - } - err = wf("+++ %s%s%s", diff.ToFile, toDate, diff.Eol) - if err != nil { - return err - } - } - } - first, last := g[0], g[len(g)-1] - range1 := formatRangeUnified(first.I1, last.I2) - range2 := formatRangeUnified(first.J1, last.J2) - if err := wf("@@ -%s +%s @@%s", range1, range2, diff.Eol); err != nil { - return err - } - for _, c := range g { - i1, i2, j1, j2 := c.I1, c.I2, c.J1, c.J2 - if c.Tag == 'e' { - for _, line := range diff.A[i1:i2] { - if err := ws(" " + line); err != nil { - return err - } - } - continue - } - if c.Tag == 'r' || c.Tag == 'd' { - for _, line := range diff.A[i1:i2] { - if err := ws("-" + line); err != nil { - return err - } - } - } - if c.Tag == 'r' || c.Tag == 'i' { - for _, line := range diff.B[j1:j2] { - if err := ws("+" + line); err != nil { - return err - } - } - } - } - } - return nil -} - -// Like WriteUnifiedDiff but returns the diff a string. -func GetUnifiedDiffString(diff UnifiedDiff) (string, error) { - w := &bytes.Buffer{} - err := WriteUnifiedDiff(w, diff) - return string(w.Bytes()), err -} - -// Convert range to the "ed" format. -func formatRangeContext(start, stop int) string { - // Per the diff spec at http://www.unix.org/single_unix_specification/ - beginning := start + 1 // lines start numbering with one - length := stop - start - if length == 0 { - beginning -= 1 // empty ranges begin at line just before the range - } - if length <= 1 { - return fmt.Sprintf("%d", beginning) - } - return fmt.Sprintf("%d,%d", beginning, beginning+length-1) -} - -type ContextDiff UnifiedDiff - -// Compare two sequences of lines; generate the delta as a context diff. -// -// Context diffs are a compact way of showing line changes and a few -// lines of context. The number of context lines is set by diff.Context -// which defaults to three. -// -// By default, the diff control lines (those with *** or ---) are -// created with a trailing newline. -// -// For inputs that do not have trailing newlines, set the diff.Eol -// argument to "" so that the output will be uniformly newline free. -// -// The context diff format normally has a header for filenames and -// modification times. Any or all of these may be specified using -// strings for diff.FromFile, diff.ToFile, diff.FromDate, diff.ToDate. -// The modification times are normally expressed in the ISO 8601 format. -// If not specified, the strings default to blanks. -func WriteContextDiff(writer io.Writer, diff ContextDiff) error { - buf := bufio.NewWriter(writer) - defer buf.Flush() - var diffErr error - wf := func(format string, args ...interface{}) { - _, err := buf.WriteString(fmt.Sprintf(format, args...)) - if diffErr == nil && err != nil { - diffErr = err - } - } - ws := func(s string) { - _, err := buf.WriteString(s) - if diffErr == nil && err != nil { - diffErr = err - } - } - - if len(diff.Eol) == 0 { - diff.Eol = "\n" - } - - prefix := map[byte]string{ - 'i': "+ ", - 'd': "- ", - 'r': "! ", - 'e': " ", - } - - started := false - m := NewMatcher(diff.A, diff.B) - for _, g := range m.GetGroupedOpCodes(diff.Context) { - if !started { - started = true - fromDate := "" - if len(diff.FromDate) > 0 { - fromDate = "\t" + diff.FromDate - } - toDate := "" - if len(diff.ToDate) > 0 { - toDate = "\t" + diff.ToDate - } - if diff.FromFile != "" || diff.ToFile != "" { - wf("*** %s%s%s", diff.FromFile, fromDate, diff.Eol) - wf("--- %s%s%s", diff.ToFile, toDate, diff.Eol) - } - } - - first, last := g[0], g[len(g)-1] - ws("***************" + diff.Eol) - - range1 := formatRangeContext(first.I1, last.I2) - wf("*** %s ****%s", range1, diff.Eol) - for _, c := range g { - if c.Tag == 'r' || c.Tag == 'd' { - for _, cc := range g { - if cc.Tag == 'i' { - continue - } - for _, line := range diff.A[cc.I1:cc.I2] { - ws(prefix[cc.Tag] + line) - } - } - break - } - } - - range2 := formatRangeContext(first.J1, last.J2) - wf("--- %s ----%s", range2, diff.Eol) - for _, c := range g { - if c.Tag == 'r' || c.Tag == 'i' { - for _, cc := range g { - if cc.Tag == 'd' { - continue - } - for _, line := range diff.B[cc.J1:cc.J2] { - ws(prefix[cc.Tag] + line) - } - } - break - } - } - } - return diffErr -} - -// Like WriteContextDiff but returns the diff a string. -func GetContextDiffString(diff ContextDiff) (string, error) { - w := &bytes.Buffer{} - err := WriteContextDiff(w, diff) - return string(w.Bytes()), err -} - -// Split a string on "\n" while preserving them. The output can be used -// as input for UnifiedDiff and ContextDiff structures. -func SplitLines(s string) []string { - lines := strings.SplitAfter(s, "\n") - lines[len(lines)-1] += "\n" - return lines -} diff --git a/vendor/github.com/pmezard/go-difflib/difflib/difflib_test.go b/vendor/github.com/pmezard/go-difflib/difflib/difflib_test.go deleted file mode 100644 index d72511962074..000000000000 --- a/vendor/github.com/pmezard/go-difflib/difflib/difflib_test.go +++ /dev/null @@ -1,426 +0,0 @@ -package difflib - -import ( - "bytes" - "fmt" - "math" - "reflect" - "strings" - "testing" -) - -func assertAlmostEqual(t *testing.T, a, b float64, places int) { - if math.Abs(a-b) > math.Pow10(-places) { - t.Errorf("%.7f != %.7f", a, b) - } -} - -func assertEqual(t *testing.T, a, b interface{}) { - if !reflect.DeepEqual(a, b) { - t.Errorf("%v != %v", a, b) - } -} - -func splitChars(s string) []string { - chars := make([]string, 0, len(s)) - // Assume ASCII inputs - for i := 0; i != len(s); i++ { - chars = append(chars, string(s[i])) - } - return chars -} - -func TestSequenceMatcherRatio(t *testing.T) { - s := NewMatcher(splitChars("abcd"), splitChars("bcde")) - assertEqual(t, s.Ratio(), 0.75) - assertEqual(t, s.QuickRatio(), 0.75) - assertEqual(t, s.RealQuickRatio(), 1.0) -} - -func TestGetOptCodes(t *testing.T) { - a := "qabxcd" - b := "abycdf" - s := NewMatcher(splitChars(a), splitChars(b)) - w := &bytes.Buffer{} - for _, op := range s.GetOpCodes() { - fmt.Fprintf(w, "%s a[%d:%d], (%s) b[%d:%d] (%s)\n", string(op.Tag), - op.I1, op.I2, a[op.I1:op.I2], op.J1, op.J2, b[op.J1:op.J2]) - } - result := string(w.Bytes()) - expected := `d a[0:1], (q) b[0:0] () -e a[1:3], (ab) b[0:2] (ab) -r a[3:4], (x) b[2:3] (y) -e a[4:6], (cd) b[3:5] (cd) -i a[6:6], () b[5:6] (f) -` - if expected != result { - t.Errorf("unexpected op codes: \n%s", result) - } -} - -func TestGroupedOpCodes(t *testing.T) { - a := []string{} - for i := 0; i != 39; i++ { - a = append(a, fmt.Sprintf("%02d", i)) - } - b := []string{} - b = append(b, a[:8]...) - b = append(b, " i") - b = append(b, a[8:19]...) - b = append(b, " x") - b = append(b, a[20:22]...) - b = append(b, a[27:34]...) - b = append(b, " y") - b = append(b, a[35:]...) - s := NewMatcher(a, b) - w := &bytes.Buffer{} - for _, g := range s.GetGroupedOpCodes(-1) { - fmt.Fprintf(w, "group\n") - for _, op := range g { - fmt.Fprintf(w, " %s, %d, %d, %d, %d\n", string(op.Tag), - op.I1, op.I2, op.J1, op.J2) - } - } - result := string(w.Bytes()) - expected := `group - e, 5, 8, 5, 8 - i, 8, 8, 8, 9 - e, 8, 11, 9, 12 -group - e, 16, 19, 17, 20 - r, 19, 20, 20, 21 - e, 20, 22, 21, 23 - d, 22, 27, 23, 23 - e, 27, 30, 23, 26 -group - e, 31, 34, 27, 30 - r, 34, 35, 30, 31 - e, 35, 38, 31, 34 -` - if expected != result { - t.Errorf("unexpected op codes: \n%s", result) - } -} - -func ExampleGetUnifiedDiffCode() { - a := `one -two -three -four -fmt.Printf("%s,%T",a,b)` - b := `zero -one -three -four` - diff := UnifiedDiff{ - A: SplitLines(a), - B: SplitLines(b), - FromFile: "Original", - FromDate: "2005-01-26 23:30:50", - ToFile: "Current", - ToDate: "2010-04-02 10:20:52", - Context: 3, - } - result, _ := GetUnifiedDiffString(diff) - fmt.Println(strings.Replace(result, "\t", " ", -1)) - // Output: - // --- Original 2005-01-26 23:30:50 - // +++ Current 2010-04-02 10:20:52 - // @@ -1,5 +1,4 @@ - // +zero - // one - // -two - // three - // four - // -fmt.Printf("%s,%T",a,b) -} - -func ExampleGetContextDiffCode() { - a := `one -two -three -four -fmt.Printf("%s,%T",a,b)` - b := `zero -one -tree -four` - diff := ContextDiff{ - A: SplitLines(a), - B: SplitLines(b), - FromFile: "Original", - ToFile: "Current", - Context: 3, - Eol: "\n", - } - result, _ := GetContextDiffString(diff) - fmt.Print(strings.Replace(result, "\t", " ", -1)) - // Output: - // *** Original - // --- Current - // *************** - // *** 1,5 **** - // one - // ! two - // ! three - // four - // - fmt.Printf("%s,%T",a,b) - // --- 1,4 ---- - // + zero - // one - // ! tree - // four -} - -func ExampleGetContextDiffString() { - a := `one -two -three -four` - b := `zero -one -tree -four` - diff := ContextDiff{ - A: SplitLines(a), - B: SplitLines(b), - FromFile: "Original", - ToFile: "Current", - Context: 3, - Eol: "\n", - } - result, _ := GetContextDiffString(diff) - fmt.Printf(strings.Replace(result, "\t", " ", -1)) - // Output: - // *** Original - // --- Current - // *************** - // *** 1,4 **** - // one - // ! two - // ! three - // four - // --- 1,4 ---- - // + zero - // one - // ! tree - // four -} - -func rep(s string, count int) string { - return strings.Repeat(s, count) -} - -func TestWithAsciiOneInsert(t *testing.T) { - sm := NewMatcher(splitChars(rep("b", 100)), - splitChars("a"+rep("b", 100))) - assertAlmostEqual(t, sm.Ratio(), 0.995, 3) - assertEqual(t, sm.GetOpCodes(), - []OpCode{{'i', 0, 0, 0, 1}, {'e', 0, 100, 1, 101}}) - assertEqual(t, len(sm.bPopular), 0) - - sm = NewMatcher(splitChars(rep("b", 100)), - splitChars(rep("b", 50)+"a"+rep("b", 50))) - assertAlmostEqual(t, sm.Ratio(), 0.995, 3) - assertEqual(t, sm.GetOpCodes(), - []OpCode{{'e', 0, 50, 0, 50}, {'i', 50, 50, 50, 51}, {'e', 50, 100, 51, 101}}) - assertEqual(t, len(sm.bPopular), 0) -} - -func TestWithAsciiOnDelete(t *testing.T) { - sm := NewMatcher(splitChars(rep("a", 40)+"c"+rep("b", 40)), - splitChars(rep("a", 40)+rep("b", 40))) - assertAlmostEqual(t, sm.Ratio(), 0.994, 3) - assertEqual(t, sm.GetOpCodes(), - []OpCode{{'e', 0, 40, 0, 40}, {'d', 40, 41, 40, 40}, {'e', 41, 81, 40, 80}}) -} - -func TestWithAsciiBJunk(t *testing.T) { - isJunk := func(s string) bool { - return s == " " - } - sm := NewMatcherWithJunk(splitChars(rep("a", 40)+rep("b", 40)), - splitChars(rep("a", 44)+rep("b", 40)), true, isJunk) - assertEqual(t, sm.bJunk, map[string]struct{}{}) - - sm = NewMatcherWithJunk(splitChars(rep("a", 40)+rep("b", 40)), - splitChars(rep("a", 44)+rep("b", 40)+rep(" ", 20)), false, isJunk) - assertEqual(t, sm.bJunk, map[string]struct{}{" ": struct{}{}}) - - isJunk = func(s string) bool { - return s == " " || s == "b" - } - sm = NewMatcherWithJunk(splitChars(rep("a", 40)+rep("b", 40)), - splitChars(rep("a", 44)+rep("b", 40)+rep(" ", 20)), false, isJunk) - assertEqual(t, sm.bJunk, map[string]struct{}{" ": struct{}{}, "b": struct{}{}}) -} - -func TestSFBugsRatioForNullSeqn(t *testing.T) { - sm := NewMatcher(nil, nil) - assertEqual(t, sm.Ratio(), 1.0) - assertEqual(t, sm.QuickRatio(), 1.0) - assertEqual(t, sm.RealQuickRatio(), 1.0) -} - -func TestSFBugsComparingEmptyLists(t *testing.T) { - groups := NewMatcher(nil, nil).GetGroupedOpCodes(-1) - assertEqual(t, len(groups), 0) - diff := UnifiedDiff{ - FromFile: "Original", - ToFile: "Current", - Context: 3, - } - result, err := GetUnifiedDiffString(diff) - assertEqual(t, err, nil) - assertEqual(t, result, "") -} - -func TestOutputFormatRangeFormatUnified(t *testing.T) { - // Per the diff spec at http://www.unix.org/single_unix_specification/ - // - // Each field shall be of the form: - // %1d", if the range contains exactly one line, - // and: - // "%1d,%1d", , otherwise. - // If a range is empty, its beginning line number shall be the number of - // the line just before the range, or 0 if the empty range starts the file. - fm := formatRangeUnified - assertEqual(t, fm(3, 3), "3,0") - assertEqual(t, fm(3, 4), "4") - assertEqual(t, fm(3, 5), "4,2") - assertEqual(t, fm(3, 6), "4,3") - assertEqual(t, fm(0, 0), "0,0") -} - -func TestOutputFormatRangeFormatContext(t *testing.T) { - // Per the diff spec at http://www.unix.org/single_unix_specification/ - // - // The range of lines in file1 shall be written in the following format - // if the range contains two or more lines: - // "*** %d,%d ****\n", , - // and the following format otherwise: - // "*** %d ****\n", - // The ending line number of an empty range shall be the number of the preceding line, - // or 0 if the range is at the start of the file. - // - // Next, the range of lines in file2 shall be written in the following format - // if the range contains two or more lines: - // "--- %d,%d ----\n", , - // and the following format otherwise: - // "--- %d ----\n", - fm := formatRangeContext - assertEqual(t, fm(3, 3), "3") - assertEqual(t, fm(3, 4), "4") - assertEqual(t, fm(3, 5), "4,5") - assertEqual(t, fm(3, 6), "4,6") - assertEqual(t, fm(0, 0), "0") -} - -func TestOutputFormatTabDelimiter(t *testing.T) { - diff := UnifiedDiff{ - A: splitChars("one"), - B: splitChars("two"), - FromFile: "Original", - FromDate: "2005-01-26 23:30:50", - ToFile: "Current", - ToDate: "2010-04-12 10:20:52", - Eol: "\n", - } - ud, err := GetUnifiedDiffString(diff) - assertEqual(t, err, nil) - assertEqual(t, SplitLines(ud)[:2], []string{ - "--- Original\t2005-01-26 23:30:50\n", - "+++ Current\t2010-04-12 10:20:52\n", - }) - cd, err := GetContextDiffString(ContextDiff(diff)) - assertEqual(t, err, nil) - assertEqual(t, SplitLines(cd)[:2], []string{ - "*** Original\t2005-01-26 23:30:50\n", - "--- Current\t2010-04-12 10:20:52\n", - }) -} - -func TestOutputFormatNoTrailingTabOnEmptyFiledate(t *testing.T) { - diff := UnifiedDiff{ - A: splitChars("one"), - B: splitChars("two"), - FromFile: "Original", - ToFile: "Current", - Eol: "\n", - } - ud, err := GetUnifiedDiffString(diff) - assertEqual(t, err, nil) - assertEqual(t, SplitLines(ud)[:2], []string{"--- Original\n", "+++ Current\n"}) - - cd, err := GetContextDiffString(ContextDiff(diff)) - assertEqual(t, err, nil) - assertEqual(t, SplitLines(cd)[:2], []string{"*** Original\n", "--- Current\n"}) -} - -func TestOmitFilenames(t *testing.T) { - diff := UnifiedDiff{ - A: SplitLines("o\nn\ne\n"), - B: SplitLines("t\nw\no\n"), - Eol: "\n", - } - ud, err := GetUnifiedDiffString(diff) - assertEqual(t, err, nil) - assertEqual(t, SplitLines(ud), []string{ - "@@ -0,0 +1,2 @@\n", - "+t\n", - "+w\n", - "@@ -2,2 +3,0 @@\n", - "-n\n", - "-e\n", - "\n", - }) - - cd, err := GetContextDiffString(ContextDiff(diff)) - assertEqual(t, err, nil) - assertEqual(t, SplitLines(cd), []string{ - "***************\n", - "*** 0 ****\n", - "--- 1,2 ----\n", - "+ t\n", - "+ w\n", - "***************\n", - "*** 2,3 ****\n", - "- n\n", - "- e\n", - "--- 3 ----\n", - "\n", - }) -} - -func TestSplitLines(t *testing.T) { - allTests := []struct { - input string - want []string - }{ - {"foo", []string{"foo\n"}}, - {"foo\nbar", []string{"foo\n", "bar\n"}}, - {"foo\nbar\n", []string{"foo\n", "bar\n", "\n"}}, - } - for _, test := range allTests { - assertEqual(t, SplitLines(test.input), test.want) - } -} - -func benchmarkSplitLines(b *testing.B, count int) { - str := strings.Repeat("foo\n", count) - - b.ResetTimer() - - n := 0 - for i := 0; i < b.N; i++ { - n += len(SplitLines(str)) - } -} - -func BenchmarkSplitLines100(b *testing.B) { - benchmarkSplitLines(b, 100) -} - -func BenchmarkSplitLines10000(b *testing.B) { - benchmarkSplitLines(b, 10000) -} diff --git a/vendor/github.com/stretchr/testify/LICENSE b/vendor/github.com/stretchr/testify/LICENSE deleted file mode 100644 index f38ec5956b64..000000000000 --- a/vendor/github.com/stretchr/testify/LICENSE +++ /dev/null @@ -1,21 +0,0 @@ -MIT License - -Copyright (c) 2012-2018 Mat Ryer and Tyler Bunnell - -Permission is hereby granted, free of charge, to any person obtaining a copy -of this software and associated documentation files (the "Software"), to deal -in the Software without restriction, including without limitation the rights -to use, copy, modify, merge, publish, distribute, sublicense, and/or sell -copies of the Software, and to permit persons to whom the Software is -furnished to do so, subject to the following conditions: - -The above copyright notice and this permission notice shall be included in all -copies or substantial portions of the Software. - -THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, -FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE -SOFTWARE. diff --git a/vendor/github.com/stretchr/testify/assert/assertion_format.go b/vendor/github.com/stretchr/testify/assert/assertion_format.go deleted file mode 100644 index aa1c2b95cddb..000000000000 --- a/vendor/github.com/stretchr/testify/assert/assertion_format.go +++ /dev/null @@ -1,484 +0,0 @@ -/* -* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen -* THIS FILE MUST NOT BE EDITED BY HAND - */ - -package assert - -import ( - http "net/http" - url "net/url" - time "time" -) - -// Conditionf uses a Comparison to assert a complex condition. -func Conditionf(t TestingT, comp Comparison, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return Condition(t, comp, append([]interface{}{msg}, args...)...) -} - -// Containsf asserts that the specified string, list(array, slice...) or map contains the -// specified substring or element. -// -// assert.Containsf(t, "Hello World", "World", "error message %s", "formatted") -// assert.Containsf(t, ["Hello", "World"], "World", "error message %s", "formatted") -// assert.Containsf(t, {"Hello": "World"}, "Hello", "error message %s", "formatted") -func Containsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return Contains(t, s, contains, append([]interface{}{msg}, args...)...) -} - -// DirExistsf checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists. -func DirExistsf(t TestingT, path string, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return DirExists(t, path, append([]interface{}{msg}, args...)...) -} - -// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified -// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, -// the number of appearances of each of them in both lists should match. -// -// assert.ElementsMatchf(t, [1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted") -func ElementsMatchf(t TestingT, listA interface{}, listB interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return ElementsMatch(t, listA, listB, append([]interface{}{msg}, args...)...) -} - -// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either -// a slice or a channel with len == 0. -// -// assert.Emptyf(t, obj, "error message %s", "formatted") -func Emptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return Empty(t, object, append([]interface{}{msg}, args...)...) -} - -// Equalf asserts that two objects are equal. -// -// assert.Equalf(t, 123, 123, "error message %s", "formatted") -// -// Pointer variable equality is determined based on the equality of the -// referenced values (as opposed to the memory addresses). Function equality -// cannot be determined and will always fail. -func Equalf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return Equal(t, expected, actual, append([]interface{}{msg}, args...)...) -} - -// EqualErrorf asserts that a function returned an error (i.e. not `nil`) -// and that it is equal to the provided error. -// -// actualObj, err := SomeFunction() -// assert.EqualErrorf(t, err, expectedErrorString, "error message %s", "formatted") -func EqualErrorf(t TestingT, theError error, errString string, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return EqualError(t, theError, errString, append([]interface{}{msg}, args...)...) -} - -// EqualValuesf asserts that two objects are equal or convertable to the same types -// and equal. -// -// assert.EqualValuesf(t, uint32(123, "error message %s", "formatted"), int32(123)) -func EqualValuesf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return EqualValues(t, expected, actual, append([]interface{}{msg}, args...)...) -} - -// Errorf asserts that a function returned an error (i.e. not `nil`). -// -// actualObj, err := SomeFunction() -// if assert.Errorf(t, err, "error message %s", "formatted") { -// assert.Equal(t, expectedErrorf, err) -// } -func Errorf(t TestingT, err error, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return Error(t, err, append([]interface{}{msg}, args...)...) -} - -// Exactlyf asserts that two objects are equal in value and type. -// -// assert.Exactlyf(t, int32(123, "error message %s", "formatted"), int64(123)) -func Exactlyf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return Exactly(t, expected, actual, append([]interface{}{msg}, args...)...) -} - -// Failf reports a failure through -func Failf(t TestingT, failureMessage string, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return Fail(t, failureMessage, append([]interface{}{msg}, args...)...) -} - -// FailNowf fails test -func FailNowf(t TestingT, failureMessage string, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return FailNow(t, failureMessage, append([]interface{}{msg}, args...)...) -} - -// Falsef asserts that the specified value is false. -// -// assert.Falsef(t, myBool, "error message %s", "formatted") -func Falsef(t TestingT, value bool, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return False(t, value, append([]interface{}{msg}, args...)...) -} - -// FileExistsf checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file. -func FileExistsf(t TestingT, path string, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return FileExists(t, path, append([]interface{}{msg}, args...)...) -} - -// HTTPBodyContainsf asserts that a specified handler returns a -// body that contains a string. -// -// assert.HTTPBodyContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") -// -// Returns whether the assertion was successful (true) or not (false). -func HTTPBodyContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return HTTPBodyContains(t, handler, method, url, values, str, append([]interface{}{msg}, args...)...) -} - -// HTTPBodyNotContainsf asserts that a specified handler returns a -// body that does not contain a string. -// -// assert.HTTPBodyNotContainsf(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") -// -// Returns whether the assertion was successful (true) or not (false). -func HTTPBodyNotContainsf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return HTTPBodyNotContains(t, handler, method, url, values, str, append([]interface{}{msg}, args...)...) -} - -// HTTPErrorf asserts that a specified handler returns an error status code. -// -// assert.HTTPErrorf(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// -// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). -func HTTPErrorf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return HTTPError(t, handler, method, url, values, append([]interface{}{msg}, args...)...) -} - -// HTTPRedirectf asserts that a specified handler returns a redirect status code. -// -// assert.HTTPRedirectf(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// -// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). -func HTTPRedirectf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return HTTPRedirect(t, handler, method, url, values, append([]interface{}{msg}, args...)...) -} - -// HTTPSuccessf asserts that a specified handler returns a success status code. -// -// assert.HTTPSuccessf(t, myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted") -// -// Returns whether the assertion was successful (true) or not (false). -func HTTPSuccessf(t TestingT, handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return HTTPSuccess(t, handler, method, url, values, append([]interface{}{msg}, args...)...) -} - -// Implementsf asserts that an object is implemented by the specified interface. -// -// assert.Implementsf(t, (*MyInterface, "error message %s", "formatted")(nil), new(MyObject)) -func Implementsf(t TestingT, interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return Implements(t, interfaceObject, object, append([]interface{}{msg}, args...)...) -} - -// InDeltaf asserts that the two numerals are within delta of each other. -// -// assert.InDeltaf(t, math.Pi, (22 / 7.0, "error message %s", "formatted"), 0.01) -func InDeltaf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return InDelta(t, expected, actual, delta, append([]interface{}{msg}, args...)...) -} - -// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. -func InDeltaMapValuesf(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return InDeltaMapValues(t, expected, actual, delta, append([]interface{}{msg}, args...)...) -} - -// InDeltaSlicef is the same as InDelta, except it compares two slices. -func InDeltaSlicef(t TestingT, expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return InDeltaSlice(t, expected, actual, delta, append([]interface{}{msg}, args...)...) -} - -// InEpsilonf asserts that expected and actual have a relative error less than epsilon -func InEpsilonf(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return InEpsilon(t, expected, actual, epsilon, append([]interface{}{msg}, args...)...) -} - -// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices. -func InEpsilonSlicef(t TestingT, expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return InEpsilonSlice(t, expected, actual, epsilon, append([]interface{}{msg}, args...)...) -} - -// IsTypef asserts that the specified objects are of the same type. -func IsTypef(t TestingT, expectedType interface{}, object interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return IsType(t, expectedType, object, append([]interface{}{msg}, args...)...) -} - -// JSONEqf asserts that two JSON strings are equivalent. -// -// assert.JSONEqf(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted") -func JSONEqf(t TestingT, expected string, actual string, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return JSONEq(t, expected, actual, append([]interface{}{msg}, args...)...) -} - -// Lenf asserts that the specified object has specific length. -// Lenf also fails if the object has a type that len() not accept. -// -// assert.Lenf(t, mySlice, 3, "error message %s", "formatted") -func Lenf(t TestingT, object interface{}, length int, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return Len(t, object, length, append([]interface{}{msg}, args...)...) -} - -// Nilf asserts that the specified object is nil. -// -// assert.Nilf(t, err, "error message %s", "formatted") -func Nilf(t TestingT, object interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return Nil(t, object, append([]interface{}{msg}, args...)...) -} - -// NoErrorf asserts that a function returned no error (i.e. `nil`). -// -// actualObj, err := SomeFunction() -// if assert.NoErrorf(t, err, "error message %s", "formatted") { -// assert.Equal(t, expectedObj, actualObj) -// } -func NoErrorf(t TestingT, err error, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return NoError(t, err, append([]interface{}{msg}, args...)...) -} - -// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the -// specified substring or element. -// -// assert.NotContainsf(t, "Hello World", "Earth", "error message %s", "formatted") -// assert.NotContainsf(t, ["Hello", "World"], "Earth", "error message %s", "formatted") -// assert.NotContainsf(t, {"Hello": "World"}, "Earth", "error message %s", "formatted") -func NotContainsf(t TestingT, s interface{}, contains interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return NotContains(t, s, contains, append([]interface{}{msg}, args...)...) -} - -// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either -// a slice or a channel with len == 0. -// -// if assert.NotEmptyf(t, obj, "error message %s", "formatted") { -// assert.Equal(t, "two", obj[1]) -// } -func NotEmptyf(t TestingT, object interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return NotEmpty(t, object, append([]interface{}{msg}, args...)...) -} - -// NotEqualf asserts that the specified values are NOT equal. -// -// assert.NotEqualf(t, obj1, obj2, "error message %s", "formatted") -// -// Pointer variable equality is determined based on the equality of the -// referenced values (as opposed to the memory addresses). -func NotEqualf(t TestingT, expected interface{}, actual interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return NotEqual(t, expected, actual, append([]interface{}{msg}, args...)...) -} - -// NotNilf asserts that the specified object is not nil. -// -// assert.NotNilf(t, err, "error message %s", "formatted") -func NotNilf(t TestingT, object interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return NotNil(t, object, append([]interface{}{msg}, args...)...) -} - -// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic. -// -// assert.NotPanicsf(t, func(){ RemainCalm() }, "error message %s", "formatted") -func NotPanicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return NotPanics(t, f, append([]interface{}{msg}, args...)...) -} - -// NotRegexpf asserts that a specified regexp does not match a string. -// -// assert.NotRegexpf(t, regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting") -// assert.NotRegexpf(t, "^start", "it's not starting", "error message %s", "formatted") -func NotRegexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return NotRegexp(t, rx, str, append([]interface{}{msg}, args...)...) -} - -// NotSubsetf asserts that the specified list(array, slice...) contains not all -// elements given in the specified subset(array, slice...). -// -// assert.NotSubsetf(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") -func NotSubsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return NotSubset(t, list, subset, append([]interface{}{msg}, args...)...) -} - -// NotZerof asserts that i is not the zero value for its type. -func NotZerof(t TestingT, i interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return NotZero(t, i, append([]interface{}{msg}, args...)...) -} - -// Panicsf asserts that the code inside the specified PanicTestFunc panics. -// -// assert.Panicsf(t, func(){ GoCrazy() }, "error message %s", "formatted") -func Panicsf(t TestingT, f PanicTestFunc, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return Panics(t, f, append([]interface{}{msg}, args...)...) -} - -// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that -// the recovered panic value equals the expected panic value. -// -// assert.PanicsWithValuef(t, "crazy error", func(){ GoCrazy() }, "error message %s", "formatted") -func PanicsWithValuef(t TestingT, expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return PanicsWithValue(t, expected, f, append([]interface{}{msg}, args...)...) -} - -// Regexpf asserts that a specified regexp matches a string. -// -// assert.Regexpf(t, regexp.MustCompile("start", "error message %s", "formatted"), "it's starting") -// assert.Regexpf(t, "start...$", "it's not starting", "error message %s", "formatted") -func Regexpf(t TestingT, rx interface{}, str interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return Regexp(t, rx, str, append([]interface{}{msg}, args...)...) -} - -// Subsetf asserts that the specified list(array, slice...) contains all -// elements given in the specified subset(array, slice...). -// -// assert.Subsetf(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") -func Subsetf(t TestingT, list interface{}, subset interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return Subset(t, list, subset, append([]interface{}{msg}, args...)...) -} - -// Truef asserts that the specified value is true. -// -// assert.Truef(t, myBool, "error message %s", "formatted") -func Truef(t TestingT, value bool, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return True(t, value, append([]interface{}{msg}, args...)...) -} - -// WithinDurationf asserts that the two times are within duration delta of each other. -// -// assert.WithinDurationf(t, time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted") -func WithinDurationf(t TestingT, expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return WithinDuration(t, expected, actual, delta, append([]interface{}{msg}, args...)...) -} - -// Zerof asserts that i is the zero value for its type. -func Zerof(t TestingT, i interface{}, msg string, args ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - return Zero(t, i, append([]interface{}{msg}, args...)...) -} diff --git a/vendor/github.com/stretchr/testify/assert/assertion_format.go.tmpl b/vendor/github.com/stretchr/testify/assert/assertion_format.go.tmpl deleted file mode 100644 index d2bb0b817788..000000000000 --- a/vendor/github.com/stretchr/testify/assert/assertion_format.go.tmpl +++ /dev/null @@ -1,5 +0,0 @@ -{{.CommentFormat}} -func {{.DocInfo.Name}}f(t TestingT, {{.ParamsFormat}}) bool { - if h, ok := t.(tHelper); ok { h.Helper() } - return {{.DocInfo.Name}}(t, {{.ForwardedParamsFormat}}) -} diff --git a/vendor/github.com/stretchr/testify/assert/assertion_forward.go b/vendor/github.com/stretchr/testify/assert/assertion_forward.go deleted file mode 100644 index de39f794e721..000000000000 --- a/vendor/github.com/stretchr/testify/assert/assertion_forward.go +++ /dev/null @@ -1,956 +0,0 @@ -/* -* CODE GENERATED AUTOMATICALLY WITH github.com/stretchr/testify/_codegen -* THIS FILE MUST NOT BE EDITED BY HAND - */ - -package assert - -import ( - http "net/http" - url "net/url" - time "time" -) - -// Condition uses a Comparison to assert a complex condition. -func (a *Assertions) Condition(comp Comparison, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Condition(a.t, comp, msgAndArgs...) -} - -// Conditionf uses a Comparison to assert a complex condition. -func (a *Assertions) Conditionf(comp Comparison, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Conditionf(a.t, comp, msg, args...) -} - -// Contains asserts that the specified string, list(array, slice...) or map contains the -// specified substring or element. -// -// a.Contains("Hello World", "World") -// a.Contains(["Hello", "World"], "World") -// a.Contains({"Hello": "World"}, "Hello") -func (a *Assertions) Contains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Contains(a.t, s, contains, msgAndArgs...) -} - -// Containsf asserts that the specified string, list(array, slice...) or map contains the -// specified substring or element. -// -// a.Containsf("Hello World", "World", "error message %s", "formatted") -// a.Containsf(["Hello", "World"], "World", "error message %s", "formatted") -// a.Containsf({"Hello": "World"}, "Hello", "error message %s", "formatted") -func (a *Assertions) Containsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Containsf(a.t, s, contains, msg, args...) -} - -// DirExists checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists. -func (a *Assertions) DirExists(path string, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return DirExists(a.t, path, msgAndArgs...) -} - -// DirExistsf checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists. -func (a *Assertions) DirExistsf(path string, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return DirExistsf(a.t, path, msg, args...) -} - -// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified -// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, -// the number of appearances of each of them in both lists should match. -// -// a.ElementsMatch([1, 3, 2, 3], [1, 3, 3, 2]) -func (a *Assertions) ElementsMatch(listA interface{}, listB interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return ElementsMatch(a.t, listA, listB, msgAndArgs...) -} - -// ElementsMatchf asserts that the specified listA(array, slice...) is equal to specified -// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, -// the number of appearances of each of them in both lists should match. -// -// a.ElementsMatchf([1, 3, 2, 3], [1, 3, 3, 2], "error message %s", "formatted") -func (a *Assertions) ElementsMatchf(listA interface{}, listB interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return ElementsMatchf(a.t, listA, listB, msg, args...) -} - -// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either -// a slice or a channel with len == 0. -// -// a.Empty(obj) -func (a *Assertions) Empty(object interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Empty(a.t, object, msgAndArgs...) -} - -// Emptyf asserts that the specified object is empty. I.e. nil, "", false, 0 or either -// a slice or a channel with len == 0. -// -// a.Emptyf(obj, "error message %s", "formatted") -func (a *Assertions) Emptyf(object interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Emptyf(a.t, object, msg, args...) -} - -// Equal asserts that two objects are equal. -// -// a.Equal(123, 123) -// -// Pointer variable equality is determined based on the equality of the -// referenced values (as opposed to the memory addresses). Function equality -// cannot be determined and will always fail. -func (a *Assertions) Equal(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Equal(a.t, expected, actual, msgAndArgs...) -} - -// EqualError asserts that a function returned an error (i.e. not `nil`) -// and that it is equal to the provided error. -// -// actualObj, err := SomeFunction() -// a.EqualError(err, expectedErrorString) -func (a *Assertions) EqualError(theError error, errString string, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return EqualError(a.t, theError, errString, msgAndArgs...) -} - -// EqualErrorf asserts that a function returned an error (i.e. not `nil`) -// and that it is equal to the provided error. -// -// actualObj, err := SomeFunction() -// a.EqualErrorf(err, expectedErrorString, "error message %s", "formatted") -func (a *Assertions) EqualErrorf(theError error, errString string, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return EqualErrorf(a.t, theError, errString, msg, args...) -} - -// EqualValues asserts that two objects are equal or convertable to the same types -// and equal. -// -// a.EqualValues(uint32(123), int32(123)) -func (a *Assertions) EqualValues(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return EqualValues(a.t, expected, actual, msgAndArgs...) -} - -// EqualValuesf asserts that two objects are equal or convertable to the same types -// and equal. -// -// a.EqualValuesf(uint32(123, "error message %s", "formatted"), int32(123)) -func (a *Assertions) EqualValuesf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return EqualValuesf(a.t, expected, actual, msg, args...) -} - -// Equalf asserts that two objects are equal. -// -// a.Equalf(123, 123, "error message %s", "formatted") -// -// Pointer variable equality is determined based on the equality of the -// referenced values (as opposed to the memory addresses). Function equality -// cannot be determined and will always fail. -func (a *Assertions) Equalf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Equalf(a.t, expected, actual, msg, args...) -} - -// Error asserts that a function returned an error (i.e. not `nil`). -// -// actualObj, err := SomeFunction() -// if a.Error(err) { -// assert.Equal(t, expectedError, err) -// } -func (a *Assertions) Error(err error, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Error(a.t, err, msgAndArgs...) -} - -// Errorf asserts that a function returned an error (i.e. not `nil`). -// -// actualObj, err := SomeFunction() -// if a.Errorf(err, "error message %s", "formatted") { -// assert.Equal(t, expectedErrorf, err) -// } -func (a *Assertions) Errorf(err error, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Errorf(a.t, err, msg, args...) -} - -// Exactly asserts that two objects are equal in value and type. -// -// a.Exactly(int32(123), int64(123)) -func (a *Assertions) Exactly(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Exactly(a.t, expected, actual, msgAndArgs...) -} - -// Exactlyf asserts that two objects are equal in value and type. -// -// a.Exactlyf(int32(123, "error message %s", "formatted"), int64(123)) -func (a *Assertions) Exactlyf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Exactlyf(a.t, expected, actual, msg, args...) -} - -// Fail reports a failure through -func (a *Assertions) Fail(failureMessage string, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Fail(a.t, failureMessage, msgAndArgs...) -} - -// FailNow fails test -func (a *Assertions) FailNow(failureMessage string, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return FailNow(a.t, failureMessage, msgAndArgs...) -} - -// FailNowf fails test -func (a *Assertions) FailNowf(failureMessage string, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return FailNowf(a.t, failureMessage, msg, args...) -} - -// Failf reports a failure through -func (a *Assertions) Failf(failureMessage string, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Failf(a.t, failureMessage, msg, args...) -} - -// False asserts that the specified value is false. -// -// a.False(myBool) -func (a *Assertions) False(value bool, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return False(a.t, value, msgAndArgs...) -} - -// Falsef asserts that the specified value is false. -// -// a.Falsef(myBool, "error message %s", "formatted") -func (a *Assertions) Falsef(value bool, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Falsef(a.t, value, msg, args...) -} - -// FileExists checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file. -func (a *Assertions) FileExists(path string, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return FileExists(a.t, path, msgAndArgs...) -} - -// FileExistsf checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file. -func (a *Assertions) FileExistsf(path string, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return FileExistsf(a.t, path, msg, args...) -} - -// HTTPBodyContains asserts that a specified handler returns a -// body that contains a string. -// -// a.HTTPBodyContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") -// -// Returns whether the assertion was successful (true) or not (false). -func (a *Assertions) HTTPBodyContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return HTTPBodyContains(a.t, handler, method, url, values, str, msgAndArgs...) -} - -// HTTPBodyContainsf asserts that a specified handler returns a -// body that contains a string. -// -// a.HTTPBodyContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") -// -// Returns whether the assertion was successful (true) or not (false). -func (a *Assertions) HTTPBodyContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return HTTPBodyContainsf(a.t, handler, method, url, values, str, msg, args...) -} - -// HTTPBodyNotContains asserts that a specified handler returns a -// body that does not contain a string. -// -// a.HTTPBodyNotContains(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") -// -// Returns whether the assertion was successful (true) or not (false). -func (a *Assertions) HTTPBodyNotContains(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return HTTPBodyNotContains(a.t, handler, method, url, values, str, msgAndArgs...) -} - -// HTTPBodyNotContainsf asserts that a specified handler returns a -// body that does not contain a string. -// -// a.HTTPBodyNotContainsf(myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky", "error message %s", "formatted") -// -// Returns whether the assertion was successful (true) or not (false). -func (a *Assertions) HTTPBodyNotContainsf(handler http.HandlerFunc, method string, url string, values url.Values, str interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return HTTPBodyNotContainsf(a.t, handler, method, url, values, str, msg, args...) -} - -// HTTPError asserts that a specified handler returns an error status code. -// -// a.HTTPError(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// -// Returns whether the assertion was successful (true) or not (false). -func (a *Assertions) HTTPError(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return HTTPError(a.t, handler, method, url, values, msgAndArgs...) -} - -// HTTPErrorf asserts that a specified handler returns an error status code. -// -// a.HTTPErrorf(myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// -// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). -func (a *Assertions) HTTPErrorf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return HTTPErrorf(a.t, handler, method, url, values, msg, args...) -} - -// HTTPRedirect asserts that a specified handler returns a redirect status code. -// -// a.HTTPRedirect(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// -// Returns whether the assertion was successful (true) or not (false). -func (a *Assertions) HTTPRedirect(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return HTTPRedirect(a.t, handler, method, url, values, msgAndArgs...) -} - -// HTTPRedirectf asserts that a specified handler returns a redirect status code. -// -// a.HTTPRedirectf(myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// -// Returns whether the assertion was successful (true, "error message %s", "formatted") or not (false). -func (a *Assertions) HTTPRedirectf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return HTTPRedirectf(a.t, handler, method, url, values, msg, args...) -} - -// HTTPSuccess asserts that a specified handler returns a success status code. -// -// a.HTTPSuccess(myHandler, "POST", "http://www.google.com", nil) -// -// Returns whether the assertion was successful (true) or not (false). -func (a *Assertions) HTTPSuccess(handler http.HandlerFunc, method string, url string, values url.Values, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return HTTPSuccess(a.t, handler, method, url, values, msgAndArgs...) -} - -// HTTPSuccessf asserts that a specified handler returns a success status code. -// -// a.HTTPSuccessf(myHandler, "POST", "http://www.google.com", nil, "error message %s", "formatted") -// -// Returns whether the assertion was successful (true) or not (false). -func (a *Assertions) HTTPSuccessf(handler http.HandlerFunc, method string, url string, values url.Values, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return HTTPSuccessf(a.t, handler, method, url, values, msg, args...) -} - -// Implements asserts that an object is implemented by the specified interface. -// -// a.Implements((*MyInterface)(nil), new(MyObject)) -func (a *Assertions) Implements(interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Implements(a.t, interfaceObject, object, msgAndArgs...) -} - -// Implementsf asserts that an object is implemented by the specified interface. -// -// a.Implementsf((*MyInterface, "error message %s", "formatted")(nil), new(MyObject)) -func (a *Assertions) Implementsf(interfaceObject interface{}, object interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Implementsf(a.t, interfaceObject, object, msg, args...) -} - -// InDelta asserts that the two numerals are within delta of each other. -// -// a.InDelta(math.Pi, (22 / 7.0), 0.01) -func (a *Assertions) InDelta(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return InDelta(a.t, expected, actual, delta, msgAndArgs...) -} - -// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. -func (a *Assertions) InDeltaMapValues(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return InDeltaMapValues(a.t, expected, actual, delta, msgAndArgs...) -} - -// InDeltaMapValuesf is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. -func (a *Assertions) InDeltaMapValuesf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return InDeltaMapValuesf(a.t, expected, actual, delta, msg, args...) -} - -// InDeltaSlice is the same as InDelta, except it compares two slices. -func (a *Assertions) InDeltaSlice(expected interface{}, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return InDeltaSlice(a.t, expected, actual, delta, msgAndArgs...) -} - -// InDeltaSlicef is the same as InDelta, except it compares two slices. -func (a *Assertions) InDeltaSlicef(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return InDeltaSlicef(a.t, expected, actual, delta, msg, args...) -} - -// InDeltaf asserts that the two numerals are within delta of each other. -// -// a.InDeltaf(math.Pi, (22 / 7.0, "error message %s", "formatted"), 0.01) -func (a *Assertions) InDeltaf(expected interface{}, actual interface{}, delta float64, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return InDeltaf(a.t, expected, actual, delta, msg, args...) -} - -// InEpsilon asserts that expected and actual have a relative error less than epsilon -func (a *Assertions) InEpsilon(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return InEpsilon(a.t, expected, actual, epsilon, msgAndArgs...) -} - -// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices. -func (a *Assertions) InEpsilonSlice(expected interface{}, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return InEpsilonSlice(a.t, expected, actual, epsilon, msgAndArgs...) -} - -// InEpsilonSlicef is the same as InEpsilon, except it compares each value from two slices. -func (a *Assertions) InEpsilonSlicef(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return InEpsilonSlicef(a.t, expected, actual, epsilon, msg, args...) -} - -// InEpsilonf asserts that expected and actual have a relative error less than epsilon -func (a *Assertions) InEpsilonf(expected interface{}, actual interface{}, epsilon float64, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return InEpsilonf(a.t, expected, actual, epsilon, msg, args...) -} - -// IsType asserts that the specified objects are of the same type. -func (a *Assertions) IsType(expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return IsType(a.t, expectedType, object, msgAndArgs...) -} - -// IsTypef asserts that the specified objects are of the same type. -func (a *Assertions) IsTypef(expectedType interface{}, object interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return IsTypef(a.t, expectedType, object, msg, args...) -} - -// JSONEq asserts that two JSON strings are equivalent. -// -// a.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) -func (a *Assertions) JSONEq(expected string, actual string, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return JSONEq(a.t, expected, actual, msgAndArgs...) -} - -// JSONEqf asserts that two JSON strings are equivalent. -// -// a.JSONEqf(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`, "error message %s", "formatted") -func (a *Assertions) JSONEqf(expected string, actual string, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return JSONEqf(a.t, expected, actual, msg, args...) -} - -// Len asserts that the specified object has specific length. -// Len also fails if the object has a type that len() not accept. -// -// a.Len(mySlice, 3) -func (a *Assertions) Len(object interface{}, length int, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Len(a.t, object, length, msgAndArgs...) -} - -// Lenf asserts that the specified object has specific length. -// Lenf also fails if the object has a type that len() not accept. -// -// a.Lenf(mySlice, 3, "error message %s", "formatted") -func (a *Assertions) Lenf(object interface{}, length int, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Lenf(a.t, object, length, msg, args...) -} - -// Nil asserts that the specified object is nil. -// -// a.Nil(err) -func (a *Assertions) Nil(object interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Nil(a.t, object, msgAndArgs...) -} - -// Nilf asserts that the specified object is nil. -// -// a.Nilf(err, "error message %s", "formatted") -func (a *Assertions) Nilf(object interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Nilf(a.t, object, msg, args...) -} - -// NoError asserts that a function returned no error (i.e. `nil`). -// -// actualObj, err := SomeFunction() -// if a.NoError(err) { -// assert.Equal(t, expectedObj, actualObj) -// } -func (a *Assertions) NoError(err error, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NoError(a.t, err, msgAndArgs...) -} - -// NoErrorf asserts that a function returned no error (i.e. `nil`). -// -// actualObj, err := SomeFunction() -// if a.NoErrorf(err, "error message %s", "formatted") { -// assert.Equal(t, expectedObj, actualObj) -// } -func (a *Assertions) NoErrorf(err error, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NoErrorf(a.t, err, msg, args...) -} - -// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the -// specified substring or element. -// -// a.NotContains("Hello World", "Earth") -// a.NotContains(["Hello", "World"], "Earth") -// a.NotContains({"Hello": "World"}, "Earth") -func (a *Assertions) NotContains(s interface{}, contains interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NotContains(a.t, s, contains, msgAndArgs...) -} - -// NotContainsf asserts that the specified string, list(array, slice...) or map does NOT contain the -// specified substring or element. -// -// a.NotContainsf("Hello World", "Earth", "error message %s", "formatted") -// a.NotContainsf(["Hello", "World"], "Earth", "error message %s", "formatted") -// a.NotContainsf({"Hello": "World"}, "Earth", "error message %s", "formatted") -func (a *Assertions) NotContainsf(s interface{}, contains interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NotContainsf(a.t, s, contains, msg, args...) -} - -// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either -// a slice or a channel with len == 0. -// -// if a.NotEmpty(obj) { -// assert.Equal(t, "two", obj[1]) -// } -func (a *Assertions) NotEmpty(object interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NotEmpty(a.t, object, msgAndArgs...) -} - -// NotEmptyf asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either -// a slice or a channel with len == 0. -// -// if a.NotEmptyf(obj, "error message %s", "formatted") { -// assert.Equal(t, "two", obj[1]) -// } -func (a *Assertions) NotEmptyf(object interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NotEmptyf(a.t, object, msg, args...) -} - -// NotEqual asserts that the specified values are NOT equal. -// -// a.NotEqual(obj1, obj2) -// -// Pointer variable equality is determined based on the equality of the -// referenced values (as opposed to the memory addresses). -func (a *Assertions) NotEqual(expected interface{}, actual interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NotEqual(a.t, expected, actual, msgAndArgs...) -} - -// NotEqualf asserts that the specified values are NOT equal. -// -// a.NotEqualf(obj1, obj2, "error message %s", "formatted") -// -// Pointer variable equality is determined based on the equality of the -// referenced values (as opposed to the memory addresses). -func (a *Assertions) NotEqualf(expected interface{}, actual interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NotEqualf(a.t, expected, actual, msg, args...) -} - -// NotNil asserts that the specified object is not nil. -// -// a.NotNil(err) -func (a *Assertions) NotNil(object interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NotNil(a.t, object, msgAndArgs...) -} - -// NotNilf asserts that the specified object is not nil. -// -// a.NotNilf(err, "error message %s", "formatted") -func (a *Assertions) NotNilf(object interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NotNilf(a.t, object, msg, args...) -} - -// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. -// -// a.NotPanics(func(){ RemainCalm() }) -func (a *Assertions) NotPanics(f PanicTestFunc, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NotPanics(a.t, f, msgAndArgs...) -} - -// NotPanicsf asserts that the code inside the specified PanicTestFunc does NOT panic. -// -// a.NotPanicsf(func(){ RemainCalm() }, "error message %s", "formatted") -func (a *Assertions) NotPanicsf(f PanicTestFunc, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NotPanicsf(a.t, f, msg, args...) -} - -// NotRegexp asserts that a specified regexp does not match a string. -// -// a.NotRegexp(regexp.MustCompile("starts"), "it's starting") -// a.NotRegexp("^start", "it's not starting") -func (a *Assertions) NotRegexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NotRegexp(a.t, rx, str, msgAndArgs...) -} - -// NotRegexpf asserts that a specified regexp does not match a string. -// -// a.NotRegexpf(regexp.MustCompile("starts", "error message %s", "formatted"), "it's starting") -// a.NotRegexpf("^start", "it's not starting", "error message %s", "formatted") -func (a *Assertions) NotRegexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NotRegexpf(a.t, rx, str, msg, args...) -} - -// NotSubset asserts that the specified list(array, slice...) contains not all -// elements given in the specified subset(array, slice...). -// -// a.NotSubset([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") -func (a *Assertions) NotSubset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NotSubset(a.t, list, subset, msgAndArgs...) -} - -// NotSubsetf asserts that the specified list(array, slice...) contains not all -// elements given in the specified subset(array, slice...). -// -// a.NotSubsetf([1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]", "error message %s", "formatted") -func (a *Assertions) NotSubsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NotSubsetf(a.t, list, subset, msg, args...) -} - -// NotZero asserts that i is not the zero value for its type. -func (a *Assertions) NotZero(i interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NotZero(a.t, i, msgAndArgs...) -} - -// NotZerof asserts that i is not the zero value for its type. -func (a *Assertions) NotZerof(i interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return NotZerof(a.t, i, msg, args...) -} - -// Panics asserts that the code inside the specified PanicTestFunc panics. -// -// a.Panics(func(){ GoCrazy() }) -func (a *Assertions) Panics(f PanicTestFunc, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Panics(a.t, f, msgAndArgs...) -} - -// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that -// the recovered panic value equals the expected panic value. -// -// a.PanicsWithValue("crazy error", func(){ GoCrazy() }) -func (a *Assertions) PanicsWithValue(expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return PanicsWithValue(a.t, expected, f, msgAndArgs...) -} - -// PanicsWithValuef asserts that the code inside the specified PanicTestFunc panics, and that -// the recovered panic value equals the expected panic value. -// -// a.PanicsWithValuef("crazy error", func(){ GoCrazy() }, "error message %s", "formatted") -func (a *Assertions) PanicsWithValuef(expected interface{}, f PanicTestFunc, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return PanicsWithValuef(a.t, expected, f, msg, args...) -} - -// Panicsf asserts that the code inside the specified PanicTestFunc panics. -// -// a.Panicsf(func(){ GoCrazy() }, "error message %s", "formatted") -func (a *Assertions) Panicsf(f PanicTestFunc, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Panicsf(a.t, f, msg, args...) -} - -// Regexp asserts that a specified regexp matches a string. -// -// a.Regexp(regexp.MustCompile("start"), "it's starting") -// a.Regexp("start...$", "it's not starting") -func (a *Assertions) Regexp(rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Regexp(a.t, rx, str, msgAndArgs...) -} - -// Regexpf asserts that a specified regexp matches a string. -// -// a.Regexpf(regexp.MustCompile("start", "error message %s", "formatted"), "it's starting") -// a.Regexpf("start...$", "it's not starting", "error message %s", "formatted") -func (a *Assertions) Regexpf(rx interface{}, str interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Regexpf(a.t, rx, str, msg, args...) -} - -// Subset asserts that the specified list(array, slice...) contains all -// elements given in the specified subset(array, slice...). -// -// a.Subset([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") -func (a *Assertions) Subset(list interface{}, subset interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Subset(a.t, list, subset, msgAndArgs...) -} - -// Subsetf asserts that the specified list(array, slice...) contains all -// elements given in the specified subset(array, slice...). -// -// a.Subsetf([1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]", "error message %s", "formatted") -func (a *Assertions) Subsetf(list interface{}, subset interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Subsetf(a.t, list, subset, msg, args...) -} - -// True asserts that the specified value is true. -// -// a.True(myBool) -func (a *Assertions) True(value bool, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return True(a.t, value, msgAndArgs...) -} - -// Truef asserts that the specified value is true. -// -// a.Truef(myBool, "error message %s", "formatted") -func (a *Assertions) Truef(value bool, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Truef(a.t, value, msg, args...) -} - -// WithinDuration asserts that the two times are within duration delta of each other. -// -// a.WithinDuration(time.Now(), time.Now(), 10*time.Second) -func (a *Assertions) WithinDuration(expected time.Time, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return WithinDuration(a.t, expected, actual, delta, msgAndArgs...) -} - -// WithinDurationf asserts that the two times are within duration delta of each other. -// -// a.WithinDurationf(time.Now(), time.Now(), 10*time.Second, "error message %s", "formatted") -func (a *Assertions) WithinDurationf(expected time.Time, actual time.Time, delta time.Duration, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return WithinDurationf(a.t, expected, actual, delta, msg, args...) -} - -// Zero asserts that i is the zero value for its type. -func (a *Assertions) Zero(i interface{}, msgAndArgs ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Zero(a.t, i, msgAndArgs...) -} - -// Zerof asserts that i is the zero value for its type. -func (a *Assertions) Zerof(i interface{}, msg string, args ...interface{}) bool { - if h, ok := a.t.(tHelper); ok { - h.Helper() - } - return Zerof(a.t, i, msg, args...) -} diff --git a/vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl b/vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl deleted file mode 100644 index 188bb9e17439..000000000000 --- a/vendor/github.com/stretchr/testify/assert/assertion_forward.go.tmpl +++ /dev/null @@ -1,5 +0,0 @@ -{{.CommentWithoutT "a"}} -func (a *Assertions) {{.DocInfo.Name}}({{.Params}}) bool { - if h, ok := a.t.(tHelper); ok { h.Helper() } - return {{.DocInfo.Name}}(a.t, {{.ForwardedParams}}) -} diff --git a/vendor/github.com/stretchr/testify/assert/assertion_order.go b/vendor/github.com/stretchr/testify/assert/assertion_order.go deleted file mode 100644 index 8c4f347f93c3..000000000000 --- a/vendor/github.com/stretchr/testify/assert/assertion_order.go +++ /dev/null @@ -1,309 +0,0 @@ -package assert - -import ( - "fmt" - "reflect" -) - -func compare(obj1, obj2 interface{}, kind reflect.Kind) (int, bool) { - switch kind { - case reflect.Int: - { - intobj1 := obj1.(int) - intobj2 := obj2.(int) - if intobj1 > intobj2 { - return -1, true - } - if intobj1 == intobj2 { - return 0, true - } - if intobj1 < intobj2 { - return 1, true - } - } - case reflect.Int8: - { - int8obj1 := obj1.(int8) - int8obj2 := obj2.(int8) - if int8obj1 > int8obj2 { - return -1, true - } - if int8obj1 == int8obj2 { - return 0, true - } - if int8obj1 < int8obj2 { - return 1, true - } - } - case reflect.Int16: - { - int16obj1 := obj1.(int16) - int16obj2 := obj2.(int16) - if int16obj1 > int16obj2 { - return -1, true - } - if int16obj1 == int16obj2 { - return 0, true - } - if int16obj1 < int16obj2 { - return 1, true - } - } - case reflect.Int32: - { - int32obj1 := obj1.(int32) - int32obj2 := obj2.(int32) - if int32obj1 > int32obj2 { - return -1, true - } - if int32obj1 == int32obj2 { - return 0, true - } - if int32obj1 < int32obj2 { - return 1, true - } - } - case reflect.Int64: - { - int64obj1 := obj1.(int64) - int64obj2 := obj2.(int64) - if int64obj1 > int64obj2 { - return -1, true - } - if int64obj1 == int64obj2 { - return 0, true - } - if int64obj1 < int64obj2 { - return 1, true - } - } - case reflect.Uint: - { - uintobj1 := obj1.(uint) - uintobj2 := obj2.(uint) - if uintobj1 > uintobj2 { - return -1, true - } - if uintobj1 == uintobj2 { - return 0, true - } - if uintobj1 < uintobj2 { - return 1, true - } - } - case reflect.Uint8: - { - uint8obj1 := obj1.(uint8) - uint8obj2 := obj2.(uint8) - if uint8obj1 > uint8obj2 { - return -1, true - } - if uint8obj1 == uint8obj2 { - return 0, true - } - if uint8obj1 < uint8obj2 { - return 1, true - } - } - case reflect.Uint16: - { - uint16obj1 := obj1.(uint16) - uint16obj2 := obj2.(uint16) - if uint16obj1 > uint16obj2 { - return -1, true - } - if uint16obj1 == uint16obj2 { - return 0, true - } - if uint16obj1 < uint16obj2 { - return 1, true - } - } - case reflect.Uint32: - { - uint32obj1 := obj1.(uint32) - uint32obj2 := obj2.(uint32) - if uint32obj1 > uint32obj2 { - return -1, true - } - if uint32obj1 == uint32obj2 { - return 0, true - } - if uint32obj1 < uint32obj2 { - return 1, true - } - } - case reflect.Uint64: - { - uint64obj1 := obj1.(uint64) - uint64obj2 := obj2.(uint64) - if uint64obj1 > uint64obj2 { - return -1, true - } - if uint64obj1 == uint64obj2 { - return 0, true - } - if uint64obj1 < uint64obj2 { - return 1, true - } - } - case reflect.Float32: - { - float32obj1 := obj1.(float32) - float32obj2 := obj2.(float32) - if float32obj1 > float32obj2 { - return -1, true - } - if float32obj1 == float32obj2 { - return 0, true - } - if float32obj1 < float32obj2 { - return 1, true - } - } - case reflect.Float64: - { - float64obj1 := obj1.(float64) - float64obj2 := obj2.(float64) - if float64obj1 > float64obj2 { - return -1, true - } - if float64obj1 == float64obj2 { - return 0, true - } - if float64obj1 < float64obj2 { - return 1, true - } - } - case reflect.String: - { - stringobj1 := obj1.(string) - stringobj2 := obj2.(string) - if stringobj1 > stringobj2 { - return -1, true - } - if stringobj1 == stringobj2 { - return 0, true - } - if stringobj1 < stringobj2 { - return 1, true - } - } - } - - return 0, false -} - -// Greater asserts that the first element is greater than the second -// -// assert.Greater(t, 2, 1) -// assert.Greater(t, float64(2), float64(1)) -// assert.Greater(t, "b", "a") -func Greater(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - e1Kind := reflect.ValueOf(e1).Kind() - e2Kind := reflect.ValueOf(e2).Kind() - if e1Kind != e2Kind { - return Fail(t, "Elements should be the same type", msgAndArgs...) - } - - res, isComparable := compare(e1, e2, e1Kind) - if !isComparable { - return Fail(t, fmt.Sprintf("Can not compare type \"%s\"", reflect.TypeOf(e1)), msgAndArgs...) - } - - if res != -1 { - return Fail(t, fmt.Sprintf("\"%s\" is not greater than \"%s\"", e1, e2), msgAndArgs...) - } - - return true -} - -// GreaterOrEqual asserts that the first element in greater or equal than the second -// -// assert.GreaterOrEqual(t, 2, 1) -// assert.GreaterOrEqual(t, 2, 2) -// assert.GreaterOrEqual(t, "b", "a") -// assert.GreaterOrEqual(t, "b", "b") -func GreaterOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - e1Kind := reflect.ValueOf(e1).Kind() - e2Kind := reflect.ValueOf(e2).Kind() - if e1Kind != e2Kind { - return Fail(t, "Elements should be the same type", msgAndArgs...) - } - - res, isComparable := compare(e1, e2, e1Kind) - if !isComparable { - return Fail(t, fmt.Sprintf("Can not compare type \"%s\"", reflect.TypeOf(e1)), msgAndArgs...) - } - - if res != -1 && res != 0 { - return Fail(t, fmt.Sprintf("\"%s\" is not greater or equal than \"%s\"", e1, e2), msgAndArgs...) - } - - return true -} - -// Less asserts that the first element in less than the second -// -// assert.Less(t, 1, 2) -// assert.Less(t, float64(1), float64(2)) -// assert.Less(t, "a", "b") -func Less(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - e1Kind := reflect.ValueOf(e1).Kind() - e2Kind := reflect.ValueOf(e2).Kind() - if e1Kind != e2Kind { - return Fail(t, "Elements should be the same type", msgAndArgs...) - } - - res, isComparable := compare(e1, e2, e1Kind) - if !isComparable { - return Fail(t, fmt.Sprintf("Can not compare type \"%s\"", reflect.TypeOf(e1)), msgAndArgs...) - } - - if res != 1 { - return Fail(t, fmt.Sprintf("\"%s\" is not less than \"%s\"", e1, e2), msgAndArgs...) - } - - return true -} - -// LessOrEqual asserts that the first element in greater or equal than the second -// -// assert.LessOrEqual(t, 1, 2) -// assert.LessOrEqual(t, 2, 2) -// assert.LessOrEqual(t, "a", "b") -// assert.LessOrEqual(t, "b", "b") -func LessOrEqual(t TestingT, e1 interface{}, e2 interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - e1Kind := reflect.ValueOf(e1).Kind() - e2Kind := reflect.ValueOf(e2).Kind() - if e1Kind != e2Kind { - return Fail(t, "Elements should be the same type", msgAndArgs...) - } - - res, isComparable := compare(e1, e2, e1Kind) - if !isComparable { - return Fail(t, fmt.Sprintf("Can not compare type \"%s\"", reflect.TypeOf(e1)), msgAndArgs...) - } - - if res != 1 && res != 0 { - return Fail(t, fmt.Sprintf("\"%s\" is not less or equal than \"%s\"", e1, e2), msgAndArgs...) - } - - return true -} diff --git a/vendor/github.com/stretchr/testify/assert/assertion_order_test.go b/vendor/github.com/stretchr/testify/assert/assertion_order_test.go deleted file mode 100644 index 4dd897a8afdb..000000000000 --- a/vendor/github.com/stretchr/testify/assert/assertion_order_test.go +++ /dev/null @@ -1,118 +0,0 @@ -package assert - -import ( - "reflect" - "testing" -) - -func TestCompare(t *testing.T) { - for _, currCase := range []struct { - less interface{} - greater interface{} - cType string - }{ - {less: "a", greater: "b", cType: "string"}, - {less: int(1), greater: int(2), cType: "int"}, - {less: int8(1), greater: int8(2), cType: "int8"}, - {less: int16(1), greater: int16(2), cType: "int16"}, - {less: int32(1), greater: int32(2), cType: "int32"}, - {less: int64(1), greater: int64(2), cType: "int64"}, - {less: uint8(1), greater: uint8(2), cType: "uint8"}, - {less: uint16(1), greater: uint16(2), cType: "uint16"}, - {less: uint32(1), greater: uint32(2), cType: "uint32"}, - {less: uint64(1), greater: uint64(2), cType: "uint64"}, - {less: float32(1), greater: float32(2), cType: "float32"}, - {less: float64(1), greater: float64(2), cType: "float64"}, - } { - resLess, isComparable := compare(currCase.less, currCase.greater, reflect.ValueOf(currCase.less).Kind()) - if !isComparable { - t.Error("object should be comparable for type " + currCase.cType) - } - - if resLess != 1 { - t.Errorf("object less should be less than greater for type " + currCase.cType) - } - - resGreater, isComparable := compare(currCase.greater, currCase.less, reflect.ValueOf(currCase.less).Kind()) - if !isComparable { - t.Error("object are comparable for type " + currCase.cType) - } - - if resGreater != -1 { - t.Errorf("object greater should be greater than less for type " + currCase.cType) - } - - resEqual, isComparable := compare(currCase.less, currCase.less, reflect.ValueOf(currCase.less).Kind()) - if !isComparable { - t.Error("object are comparable for type " + currCase.cType) - } - - if resEqual != 0 { - t.Errorf("objects should be equal for type " + currCase.cType) - } - } -} - -func TestGreater(t *testing.T) { - mockT := new(testing.T) - - if !Greater(mockT, 2, 1) { - t.Error("Greater should return true") - } - - if Greater(mockT, 1, 1) { - t.Error("Greater should return false") - } - - if Greater(mockT, 1, 2) { - t.Error("Greater should return false") - } -} - -func TestGreaterOrEqual(t *testing.T) { - mockT := new(testing.T) - - if !GreaterOrEqual(mockT, 2, 1) { - t.Error("Greater should return true") - } - - if !GreaterOrEqual(mockT, 1, 1) { - t.Error("Greater should return true") - } - - if GreaterOrEqual(mockT, 1, 2) { - t.Error("Greater should return false") - } -} - -func TestLess(t *testing.T) { - mockT := new(testing.T) - - if !Less(mockT, 1, 2) { - t.Error("Less should return true") - } - - if Less(mockT, 1, 1) { - t.Error("Less should return false") - } - - if Less(mockT, 2, 1) { - t.Error("Less should return false") - } -} - -func TestLessOrEqual(t *testing.T) { - mockT := new(testing.T) - - if !LessOrEqual(mockT, 1, 2) { - t.Error("Greater should return true") - } - - if !LessOrEqual(mockT, 1, 1) { - t.Error("Greater should return true") - } - - if LessOrEqual(mockT, 2, 1) { - t.Error("Greater should return false") - } -} diff --git a/vendor/github.com/stretchr/testify/assert/assertions.go b/vendor/github.com/stretchr/testify/assert/assertions.go deleted file mode 100644 index eb3b39baf1aa..000000000000 --- a/vendor/github.com/stretchr/testify/assert/assertions.go +++ /dev/null @@ -1,1448 +0,0 @@ -package assert - -import ( - "bufio" - "bytes" - "encoding/json" - "errors" - "fmt" - "math" - "os" - "reflect" - "regexp" - "runtime" - "strings" - "time" - "unicode" - "unicode/utf8" - - "github.com/davecgh/go-spew/spew" - "github.com/pmezard/go-difflib/difflib" -) - -//go:generate go run ../_codegen/main.go -output-package=assert -template=assertion_format.go.tmpl - -// TestingT is an interface wrapper around *testing.T -type TestingT interface { - Errorf(format string, args ...interface{}) -} - -// ComparisonAssertionFunc is a common function prototype when comparing two values. Can be useful -// for table driven tests. -type ComparisonAssertionFunc func(TestingT, interface{}, interface{}, ...interface{}) bool - -// ValueAssertionFunc is a common function prototype when validating a single value. Can be useful -// for table driven tests. -type ValueAssertionFunc func(TestingT, interface{}, ...interface{}) bool - -// BoolAssertionFunc is a common function prototype when validating a bool value. Can be useful -// for table driven tests. -type BoolAssertionFunc func(TestingT, bool, ...interface{}) bool - -// ErrorAssertionFunc is a common function prototype when validating an error value. Can be useful -// for table driven tests. -type ErrorAssertionFunc func(TestingT, error, ...interface{}) bool - -// Comparison a custom function that returns true on success and false on failure -type Comparison func() (success bool) - -/* - Helper functions -*/ - -// ObjectsAreEqual determines if two objects are considered equal. -// -// This function does no assertion of any kind. -func ObjectsAreEqual(expected, actual interface{}) bool { - if expected == nil || actual == nil { - return expected == actual - } - - exp, ok := expected.([]byte) - if !ok { - return reflect.DeepEqual(expected, actual) - } - - act, ok := actual.([]byte) - if !ok { - return false - } - if exp == nil || act == nil { - return exp == nil && act == nil - } - return bytes.Equal(exp, act) -} - -// ObjectsAreEqualValues gets whether two objects are equal, or if their -// values are equal. -func ObjectsAreEqualValues(expected, actual interface{}) bool { - if ObjectsAreEqual(expected, actual) { - return true - } - - actualType := reflect.TypeOf(actual) - if actualType == nil { - return false - } - expectedValue := reflect.ValueOf(expected) - if expectedValue.IsValid() && expectedValue.Type().ConvertibleTo(actualType) { - // Attempt comparison after type conversion - return reflect.DeepEqual(expectedValue.Convert(actualType).Interface(), actual) - } - - return false -} - -/* CallerInfo is necessary because the assert functions use the testing object -internally, causing it to print the file:line of the assert method, rather than where -the problem actually occurred in calling code.*/ - -// CallerInfo returns an array of strings containing the file and line number -// of each stack frame leading from the current test to the assert call that -// failed. -func CallerInfo() []string { - - pc := uintptr(0) - file := "" - line := 0 - ok := false - name := "" - - callers := []string{} - for i := 0; ; i++ { - pc, file, line, ok = runtime.Caller(i) - if !ok { - // The breaks below failed to terminate the loop, and we ran off the - // end of the call stack. - break - } - - // This is a huge edge case, but it will panic if this is the case, see #180 - if file == "" { - break - } - - f := runtime.FuncForPC(pc) - if f == nil { - break - } - name = f.Name() - - // testing.tRunner is the standard library function that calls - // tests. Subtests are called directly by tRunner, without going through - // the Test/Benchmark/Example function that contains the t.Run calls, so - // with subtests we should break when we hit tRunner, without adding it - // to the list of callers. - if name == "testing.tRunner" { - break - } - - parts := strings.Split(file, "/") - file = parts[len(parts)-1] - if len(parts) > 1 { - dir := parts[len(parts)-2] - if (dir != "assert" && dir != "mock" && dir != "require") || file == "mock_test.go" { - callers = append(callers, fmt.Sprintf("%s:%d", file, line)) - } - } - - // Drop the package - segments := strings.Split(name, ".") - name = segments[len(segments)-1] - if isTest(name, "Test") || - isTest(name, "Benchmark") || - isTest(name, "Example") { - break - } - } - - return callers -} - -// Stolen from the `go test` tool. -// isTest tells whether name looks like a test (or benchmark, according to prefix). -// It is a Test (say) if there is a character after Test that is not a lower-case letter. -// We don't want TesticularCancer. -func isTest(name, prefix string) bool { - if !strings.HasPrefix(name, prefix) { - return false - } - if len(name) == len(prefix) { // "Test" is ok - return true - } - rune, _ := utf8.DecodeRuneInString(name[len(prefix):]) - return !unicode.IsLower(rune) -} - -func messageFromMsgAndArgs(msgAndArgs ...interface{}) string { - if len(msgAndArgs) == 0 || msgAndArgs == nil { - return "" - } - if len(msgAndArgs) == 1 { - msg := msgAndArgs[0] - if msgAsStr, ok := msg.(string); ok { - return msgAsStr - } - return fmt.Sprintf("%+v", msg) - } - if len(msgAndArgs) > 1 { - return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...) - } - return "" -} - -// Aligns the provided message so that all lines after the first line start at the same location as the first line. -// Assumes that the first line starts at the correct location (after carriage return, tab, label, spacer and tab). -// The longestLabelLen parameter specifies the length of the longest label in the output (required becaues this is the -// basis on which the alignment occurs). -func indentMessageLines(message string, longestLabelLen int) string { - outBuf := new(bytes.Buffer) - - for i, scanner := 0, bufio.NewScanner(strings.NewReader(message)); scanner.Scan(); i++ { - // no need to align first line because it starts at the correct location (after the label) - if i != 0 { - // append alignLen+1 spaces to align with "{{longestLabel}}:" before adding tab - outBuf.WriteString("\n\t" + strings.Repeat(" ", longestLabelLen+1) + "\t") - } - outBuf.WriteString(scanner.Text()) - } - - return outBuf.String() -} - -type failNower interface { - FailNow() -} - -// FailNow fails test -func FailNow(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - Fail(t, failureMessage, msgAndArgs...) - - // We cannot extend TestingT with FailNow() and - // maintain backwards compatibility, so we fallback - // to panicking when FailNow is not available in - // TestingT. - // See issue #263 - - if t, ok := t.(failNower); ok { - t.FailNow() - } else { - panic("test failed and t is missing `FailNow()`") - } - return false -} - -// Fail reports a failure through -func Fail(t TestingT, failureMessage string, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - content := []labeledContent{ - {"Error Trace", strings.Join(CallerInfo(), "\n\t\t\t")}, - {"Error", failureMessage}, - } - - // Add test name if the Go version supports it - if n, ok := t.(interface { - Name() string - }); ok { - content = append(content, labeledContent{"Test", n.Name()}) - } - - message := messageFromMsgAndArgs(msgAndArgs...) - if len(message) > 0 { - content = append(content, labeledContent{"Messages", message}) - } - - t.Errorf("\n%s", ""+labeledOutput(content...)) - - return false -} - -type labeledContent struct { - label string - content string -} - -// labeledOutput returns a string consisting of the provided labeledContent. Each labeled output is appended in the following manner: -// -// \t{{label}}:{{align_spaces}}\t{{content}}\n -// -// The initial carriage return is required to undo/erase any padding added by testing.T.Errorf. The "\t{{label}}:" is for the label. -// If a label is shorter than the longest label provided, padding spaces are added to make all the labels match in length. Once this -// alignment is achieved, "\t{{content}}\n" is added for the output. -// -// If the content of the labeledOutput contains line breaks, the subsequent lines are aligned so that they start at the same location as the first line. -func labeledOutput(content ...labeledContent) string { - longestLabel := 0 - for _, v := range content { - if len(v.label) > longestLabel { - longestLabel = len(v.label) - } - } - var output string - for _, v := range content { - output += "\t" + v.label + ":" + strings.Repeat(" ", longestLabel-len(v.label)) + "\t" + indentMessageLines(v.content, longestLabel) + "\n" - } - return output -} - -// Implements asserts that an object is implemented by the specified interface. -// -// assert.Implements(t, (*MyInterface)(nil), new(MyObject)) -func Implements(t TestingT, interfaceObject interface{}, object interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - interfaceType := reflect.TypeOf(interfaceObject).Elem() - - if object == nil { - return Fail(t, fmt.Sprintf("Cannot check if nil implements %v", interfaceType), msgAndArgs...) - } - if !reflect.TypeOf(object).Implements(interfaceType) { - return Fail(t, fmt.Sprintf("%T must implement %v", object, interfaceType), msgAndArgs...) - } - - return true -} - -// IsType asserts that the specified objects are of the same type. -func IsType(t TestingT, expectedType interface{}, object interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - if !ObjectsAreEqual(reflect.TypeOf(object), reflect.TypeOf(expectedType)) { - return Fail(t, fmt.Sprintf("Object expected to be of type %v, but was %v", reflect.TypeOf(expectedType), reflect.TypeOf(object)), msgAndArgs...) - } - - return true -} - -// Equal asserts that two objects are equal. -// -// assert.Equal(t, 123, 123) -// -// Pointer variable equality is determined based on the equality of the -// referenced values (as opposed to the memory addresses). Function equality -// cannot be determined and will always fail. -func Equal(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - if err := validateEqualArgs(expected, actual); err != nil { - return Fail(t, fmt.Sprintf("Invalid operation: %#v == %#v (%s)", - expected, actual, err), msgAndArgs...) - } - - if !ObjectsAreEqual(expected, actual) { - diff := diff(expected, actual) - expected, actual = formatUnequalValues(expected, actual) - return Fail(t, fmt.Sprintf("Not equal: \n"+ - "expected: %s\n"+ - "actual : %s%s", expected, actual, diff), msgAndArgs...) - } - - return true - -} - -// Same asserts that two pointers reference the same object. -// -// assert.Same(t, ptr1, ptr2) -// -// Both arguments must be pointer variables. Pointer variable sameness is -// determined based on the equality of both type and value. -func Same(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - expectedPtr, actualPtr := reflect.ValueOf(expected), reflect.ValueOf(actual) - if expectedPtr.Kind() != reflect.Ptr || actualPtr.Kind() != reflect.Ptr { - return Fail(t, "Invalid operation: both arguments must be pointers", msgAndArgs...) - } - - expectedType, actualType := reflect.TypeOf(expected), reflect.TypeOf(actual) - if expectedType != actualType { - return Fail(t, fmt.Sprintf("Pointer expected to be of type %v, but was %v", - expectedType, actualType), msgAndArgs...) - } - - if expected != actual { - return Fail(t, fmt.Sprintf("Not same: \n"+ - "expected: %p %#v\n"+ - "actual : %p %#v", expected, expected, actual, actual), msgAndArgs...) - } - - return true -} - -// formatUnequalValues takes two values of arbitrary types and returns string -// representations appropriate to be presented to the user. -// -// If the values are not of like type, the returned strings will be prefixed -// with the type name, and the value will be enclosed in parenthesis similar -// to a type conversion in the Go grammar. -func formatUnequalValues(expected, actual interface{}) (e string, a string) { - if reflect.TypeOf(expected) != reflect.TypeOf(actual) { - return fmt.Sprintf("%T(%#v)", expected, expected), - fmt.Sprintf("%T(%#v)", actual, actual) - } - - return fmt.Sprintf("%#v", expected), - fmt.Sprintf("%#v", actual) -} - -// EqualValues asserts that two objects are equal or convertable to the same types -// and equal. -// -// assert.EqualValues(t, uint32(123), int32(123)) -func EqualValues(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - if !ObjectsAreEqualValues(expected, actual) { - diff := diff(expected, actual) - expected, actual = formatUnequalValues(expected, actual) - return Fail(t, fmt.Sprintf("Not equal: \n"+ - "expected: %s\n"+ - "actual : %s%s", expected, actual, diff), msgAndArgs...) - } - - return true - -} - -// Exactly asserts that two objects are equal in value and type. -// -// assert.Exactly(t, int32(123), int64(123)) -func Exactly(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - aType := reflect.TypeOf(expected) - bType := reflect.TypeOf(actual) - - if aType != bType { - return Fail(t, fmt.Sprintf("Types expected to match exactly\n\t%v != %v", aType, bType), msgAndArgs...) - } - - return Equal(t, expected, actual, msgAndArgs...) - -} - -// NotNil asserts that the specified object is not nil. -// -// assert.NotNil(t, err) -func NotNil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - if !isNil(object) { - return true - } - return Fail(t, "Expected value not to be nil.", msgAndArgs...) -} - -// containsKind checks if a specified kind in the slice of kinds. -func containsKind(kinds []reflect.Kind, kind reflect.Kind) bool { - for i := 0; i < len(kinds); i++ { - if kind == kinds[i] { - return true - } - } - - return false -} - -// isNil checks if a specified object is nil or not, without Failing. -func isNil(object interface{}) bool { - if object == nil { - return true - } - - value := reflect.ValueOf(object) - kind := value.Kind() - isNilableKind := containsKind( - []reflect.Kind{ - reflect.Chan, reflect.Func, - reflect.Interface, reflect.Map, - reflect.Ptr, reflect.Slice}, - kind) - - if isNilableKind && value.IsNil() { - return true - } - - return false -} - -// Nil asserts that the specified object is nil. -// -// assert.Nil(t, err) -func Nil(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - if isNil(object) { - return true - } - return Fail(t, fmt.Sprintf("Expected nil, but got: %#v", object), msgAndArgs...) -} - -// isEmpty gets whether the specified object is considered empty or not. -func isEmpty(object interface{}) bool { - - // get nil case out of the way - if object == nil { - return true - } - - objValue := reflect.ValueOf(object) - - switch objValue.Kind() { - // collection types are empty when they have no element - case reflect.Array, reflect.Chan, reflect.Map, reflect.Slice: - return objValue.Len() == 0 - // pointers are empty if nil or if the value they point to is empty - case reflect.Ptr: - if objValue.IsNil() { - return true - } - deref := objValue.Elem().Interface() - return isEmpty(deref) - // for all other types, compare against the zero value - default: - zero := reflect.Zero(objValue.Type()) - return reflect.DeepEqual(object, zero.Interface()) - } -} - -// Empty asserts that the specified object is empty. I.e. nil, "", false, 0 or either -// a slice or a channel with len == 0. -// -// assert.Empty(t, obj) -func Empty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - pass := isEmpty(object) - if !pass { - Fail(t, fmt.Sprintf("Should be empty, but was %v", object), msgAndArgs...) - } - - return pass - -} - -// NotEmpty asserts that the specified object is NOT empty. I.e. not nil, "", false, 0 or either -// a slice or a channel with len == 0. -// -// if assert.NotEmpty(t, obj) { -// assert.Equal(t, "two", obj[1]) -// } -func NotEmpty(t TestingT, object interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - pass := !isEmpty(object) - if !pass { - Fail(t, fmt.Sprintf("Should NOT be empty, but was %v", object), msgAndArgs...) - } - - return pass - -} - -// getLen try to get length of object. -// return (false, 0) if impossible. -func getLen(x interface{}) (ok bool, length int) { - v := reflect.ValueOf(x) - defer func() { - if e := recover(); e != nil { - ok = false - } - }() - return true, v.Len() -} - -// Len asserts that the specified object has specific length. -// Len also fails if the object has a type that len() not accept. -// -// assert.Len(t, mySlice, 3) -func Len(t TestingT, object interface{}, length int, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - ok, l := getLen(object) - if !ok { - return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", object), msgAndArgs...) - } - - if l != length { - return Fail(t, fmt.Sprintf("\"%s\" should have %d item(s), but has %d", object, length, l), msgAndArgs...) - } - return true -} - -// True asserts that the specified value is true. -// -// assert.True(t, myBool) -func True(t TestingT, value bool, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - if h, ok := t.(interface { - Helper() - }); ok { - h.Helper() - } - - if value != true { - return Fail(t, "Should be true", msgAndArgs...) - } - - return true - -} - -// False asserts that the specified value is false. -// -// assert.False(t, myBool) -func False(t TestingT, value bool, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - if value != false { - return Fail(t, "Should be false", msgAndArgs...) - } - - return true - -} - -// NotEqual asserts that the specified values are NOT equal. -// -// assert.NotEqual(t, obj1, obj2) -// -// Pointer variable equality is determined based on the equality of the -// referenced values (as opposed to the memory addresses). -func NotEqual(t TestingT, expected, actual interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - if err := validateEqualArgs(expected, actual); err != nil { - return Fail(t, fmt.Sprintf("Invalid operation: %#v != %#v (%s)", - expected, actual, err), msgAndArgs...) - } - - if ObjectsAreEqual(expected, actual) { - return Fail(t, fmt.Sprintf("Should not be: %#v\n", actual), msgAndArgs...) - } - - return true - -} - -// containsElement try loop over the list check if the list includes the element. -// return (false, false) if impossible. -// return (true, false) if element was not found. -// return (true, true) if element was found. -func includeElement(list interface{}, element interface{}) (ok, found bool) { - - listValue := reflect.ValueOf(list) - listKind := reflect.TypeOf(list).Kind() - defer func() { - if e := recover(); e != nil { - ok = false - found = false - } - }() - - if listKind == reflect.String { - elementValue := reflect.ValueOf(element) - return true, strings.Contains(listValue.String(), elementValue.String()) - } - - if listKind == reflect.Map { - mapKeys := listValue.MapKeys() - for i := 0; i < len(mapKeys); i++ { - if ObjectsAreEqual(mapKeys[i].Interface(), element) { - return true, true - } - } - return true, false - } - - for i := 0; i < listValue.Len(); i++ { - if ObjectsAreEqual(listValue.Index(i).Interface(), element) { - return true, true - } - } - return true, false - -} - -// Contains asserts that the specified string, list(array, slice...) or map contains the -// specified substring or element. -// -// assert.Contains(t, "Hello World", "World") -// assert.Contains(t, ["Hello", "World"], "World") -// assert.Contains(t, {"Hello": "World"}, "Hello") -func Contains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - ok, found := includeElement(s, contains) - if !ok { - return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...) - } - if !found { - return Fail(t, fmt.Sprintf("\"%s\" does not contain \"%s\"", s, contains), msgAndArgs...) - } - - return true - -} - -// NotContains asserts that the specified string, list(array, slice...) or map does NOT contain the -// specified substring or element. -// -// assert.NotContains(t, "Hello World", "Earth") -// assert.NotContains(t, ["Hello", "World"], "Earth") -// assert.NotContains(t, {"Hello": "World"}, "Earth") -func NotContains(t TestingT, s, contains interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - ok, found := includeElement(s, contains) - if !ok { - return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", s), msgAndArgs...) - } - if found { - return Fail(t, fmt.Sprintf("\"%s\" should not contain \"%s\"", s, contains), msgAndArgs...) - } - - return true - -} - -// Subset asserts that the specified list(array, slice...) contains all -// elements given in the specified subset(array, slice...). -// -// assert.Subset(t, [1, 2, 3], [1, 2], "But [1, 2, 3] does contain [1, 2]") -func Subset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) { - if h, ok := t.(tHelper); ok { - h.Helper() - } - if subset == nil { - return true // we consider nil to be equal to the nil set - } - - subsetValue := reflect.ValueOf(subset) - defer func() { - if e := recover(); e != nil { - ok = false - } - }() - - listKind := reflect.TypeOf(list).Kind() - subsetKind := reflect.TypeOf(subset).Kind() - - if listKind != reflect.Array && listKind != reflect.Slice { - return Fail(t, fmt.Sprintf("%q has an unsupported type %s", list, listKind), msgAndArgs...) - } - - if subsetKind != reflect.Array && subsetKind != reflect.Slice { - return Fail(t, fmt.Sprintf("%q has an unsupported type %s", subset, subsetKind), msgAndArgs...) - } - - for i := 0; i < subsetValue.Len(); i++ { - element := subsetValue.Index(i).Interface() - ok, found := includeElement(list, element) - if !ok { - return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", list), msgAndArgs...) - } - if !found { - return Fail(t, fmt.Sprintf("\"%s\" does not contain \"%s\"", list, element), msgAndArgs...) - } - } - - return true -} - -// NotSubset asserts that the specified list(array, slice...) contains not all -// elements given in the specified subset(array, slice...). -// -// assert.NotSubset(t, [1, 3, 4], [1, 2], "But [1, 3, 4] does not contain [1, 2]") -func NotSubset(t TestingT, list, subset interface{}, msgAndArgs ...interface{}) (ok bool) { - if h, ok := t.(tHelper); ok { - h.Helper() - } - if subset == nil { - return Fail(t, fmt.Sprintf("nil is the empty set which is a subset of every set"), msgAndArgs...) - } - - subsetValue := reflect.ValueOf(subset) - defer func() { - if e := recover(); e != nil { - ok = false - } - }() - - listKind := reflect.TypeOf(list).Kind() - subsetKind := reflect.TypeOf(subset).Kind() - - if listKind != reflect.Array && listKind != reflect.Slice { - return Fail(t, fmt.Sprintf("%q has an unsupported type %s", list, listKind), msgAndArgs...) - } - - if subsetKind != reflect.Array && subsetKind != reflect.Slice { - return Fail(t, fmt.Sprintf("%q has an unsupported type %s", subset, subsetKind), msgAndArgs...) - } - - for i := 0; i < subsetValue.Len(); i++ { - element := subsetValue.Index(i).Interface() - ok, found := includeElement(list, element) - if !ok { - return Fail(t, fmt.Sprintf("\"%s\" could not be applied builtin len()", list), msgAndArgs...) - } - if !found { - return true - } - } - - return Fail(t, fmt.Sprintf("%q is a subset of %q", subset, list), msgAndArgs...) -} - -// ElementsMatch asserts that the specified listA(array, slice...) is equal to specified -// listB(array, slice...) ignoring the order of the elements. If there are duplicate elements, -// the number of appearances of each of them in both lists should match. -// -// assert.ElementsMatch(t, [1, 3, 2, 3], [1, 3, 3, 2]) -func ElementsMatch(t TestingT, listA, listB interface{}, msgAndArgs ...interface{}) (ok bool) { - if h, ok := t.(tHelper); ok { - h.Helper() - } - if isEmpty(listA) && isEmpty(listB) { - return true - } - - aKind := reflect.TypeOf(listA).Kind() - bKind := reflect.TypeOf(listB).Kind() - - if aKind != reflect.Array && aKind != reflect.Slice { - return Fail(t, fmt.Sprintf("%q has an unsupported type %s", listA, aKind), msgAndArgs...) - } - - if bKind != reflect.Array && bKind != reflect.Slice { - return Fail(t, fmt.Sprintf("%q has an unsupported type %s", listB, bKind), msgAndArgs...) - } - - aValue := reflect.ValueOf(listA) - bValue := reflect.ValueOf(listB) - - aLen := aValue.Len() - bLen := bValue.Len() - - if aLen != bLen { - return Fail(t, fmt.Sprintf("lengths don't match: %d != %d", aLen, bLen), msgAndArgs...) - } - - // Mark indexes in bValue that we already used - visited := make([]bool, bLen) - for i := 0; i < aLen; i++ { - element := aValue.Index(i).Interface() - found := false - for j := 0; j < bLen; j++ { - if visited[j] { - continue - } - if ObjectsAreEqual(bValue.Index(j).Interface(), element) { - visited[j] = true - found = true - break - } - } - if !found { - return Fail(t, fmt.Sprintf("element %s appears more times in %s than in %s", element, aValue, bValue), msgAndArgs...) - } - } - - return true -} - -// Condition uses a Comparison to assert a complex condition. -func Condition(t TestingT, comp Comparison, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - result := comp() - if !result { - Fail(t, "Condition failed!", msgAndArgs...) - } - return result -} - -// PanicTestFunc defines a func that should be passed to the assert.Panics and assert.NotPanics -// methods, and represents a simple func that takes no arguments, and returns nothing. -type PanicTestFunc func() - -// didPanic returns true if the function passed to it panics. Otherwise, it returns false. -func didPanic(f PanicTestFunc) (bool, interface{}) { - - didPanic := false - var message interface{} - func() { - - defer func() { - if message = recover(); message != nil { - didPanic = true - } - }() - - // call the target function - f() - - }() - - return didPanic, message - -} - -// Panics asserts that the code inside the specified PanicTestFunc panics. -// -// assert.Panics(t, func(){ GoCrazy() }) -func Panics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - if funcDidPanic, panicValue := didPanic(f); !funcDidPanic { - return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...) - } - - return true -} - -// PanicsWithValue asserts that the code inside the specified PanicTestFunc panics, and that -// the recovered panic value equals the expected panic value. -// -// assert.PanicsWithValue(t, "crazy error", func(){ GoCrazy() }) -func PanicsWithValue(t TestingT, expected interface{}, f PanicTestFunc, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - funcDidPanic, panicValue := didPanic(f) - if !funcDidPanic { - return Fail(t, fmt.Sprintf("func %#v should panic\n\tPanic value:\t%#v", f, panicValue), msgAndArgs...) - } - if panicValue != expected { - return Fail(t, fmt.Sprintf("func %#v should panic with value:\t%#v\n\tPanic value:\t%#v", f, expected, panicValue), msgAndArgs...) - } - - return true -} - -// NotPanics asserts that the code inside the specified PanicTestFunc does NOT panic. -// -// assert.NotPanics(t, func(){ RemainCalm() }) -func NotPanics(t TestingT, f PanicTestFunc, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - if funcDidPanic, panicValue := didPanic(f); funcDidPanic { - return Fail(t, fmt.Sprintf("func %#v should not panic\n\tPanic value:\t%v", f, panicValue), msgAndArgs...) - } - - return true -} - -// WithinDuration asserts that the two times are within duration delta of each other. -// -// assert.WithinDuration(t, time.Now(), time.Now(), 10*time.Second) -func WithinDuration(t TestingT, expected, actual time.Time, delta time.Duration, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - dt := expected.Sub(actual) - if dt < -delta || dt > delta { - return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...) - } - - return true -} - -func toFloat(x interface{}) (float64, bool) { - var xf float64 - xok := true - - switch xn := x.(type) { - case uint8: - xf = float64(xn) - case uint16: - xf = float64(xn) - case uint32: - xf = float64(xn) - case uint64: - xf = float64(xn) - case int: - xf = float64(xn) - case int8: - xf = float64(xn) - case int16: - xf = float64(xn) - case int32: - xf = float64(xn) - case int64: - xf = float64(xn) - case float32: - xf = float64(xn) - case float64: - xf = float64(xn) - case time.Duration: - xf = float64(xn) - default: - xok = false - } - - return xf, xok -} - -// InDelta asserts that the two numerals are within delta of each other. -// -// assert.InDelta(t, math.Pi, (22 / 7.0), 0.01) -func InDelta(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - af, aok := toFloat(expected) - bf, bok := toFloat(actual) - - if !aok || !bok { - return Fail(t, fmt.Sprintf("Parameters must be numerical"), msgAndArgs...) - } - - if math.IsNaN(af) { - return Fail(t, fmt.Sprintf("Expected must not be NaN"), msgAndArgs...) - } - - if math.IsNaN(bf) { - return Fail(t, fmt.Sprintf("Expected %v with delta %v, but was NaN", expected, delta), msgAndArgs...) - } - - dt := af - bf - if dt < -delta || dt > delta { - return Fail(t, fmt.Sprintf("Max difference between %v and %v allowed is %v, but difference was %v", expected, actual, delta, dt), msgAndArgs...) - } - - return true -} - -// InDeltaSlice is the same as InDelta, except it compares two slices. -func InDeltaSlice(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - if expected == nil || actual == nil || - reflect.TypeOf(actual).Kind() != reflect.Slice || - reflect.TypeOf(expected).Kind() != reflect.Slice { - return Fail(t, fmt.Sprintf("Parameters must be slice"), msgAndArgs...) - } - - actualSlice := reflect.ValueOf(actual) - expectedSlice := reflect.ValueOf(expected) - - for i := 0; i < actualSlice.Len(); i++ { - result := InDelta(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), delta, msgAndArgs...) - if !result { - return result - } - } - - return true -} - -// InDeltaMapValues is the same as InDelta, but it compares all values between two maps. Both maps must have exactly the same keys. -func InDeltaMapValues(t TestingT, expected, actual interface{}, delta float64, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - if expected == nil || actual == nil || - reflect.TypeOf(actual).Kind() != reflect.Map || - reflect.TypeOf(expected).Kind() != reflect.Map { - return Fail(t, "Arguments must be maps", msgAndArgs...) - } - - expectedMap := reflect.ValueOf(expected) - actualMap := reflect.ValueOf(actual) - - if expectedMap.Len() != actualMap.Len() { - return Fail(t, "Arguments must have the same number of keys", msgAndArgs...) - } - - for _, k := range expectedMap.MapKeys() { - ev := expectedMap.MapIndex(k) - av := actualMap.MapIndex(k) - - if !ev.IsValid() { - return Fail(t, fmt.Sprintf("missing key %q in expected map", k), msgAndArgs...) - } - - if !av.IsValid() { - return Fail(t, fmt.Sprintf("missing key %q in actual map", k), msgAndArgs...) - } - - if !InDelta( - t, - ev.Interface(), - av.Interface(), - delta, - msgAndArgs..., - ) { - return false - } - } - - return true -} - -func calcRelativeError(expected, actual interface{}) (float64, error) { - af, aok := toFloat(expected) - if !aok { - return 0, fmt.Errorf("expected value %q cannot be converted to float", expected) - } - if af == 0 { - return 0, fmt.Errorf("expected value must have a value other than zero to calculate the relative error") - } - bf, bok := toFloat(actual) - if !bok { - return 0, fmt.Errorf("actual value %q cannot be converted to float", actual) - } - - return math.Abs(af-bf) / math.Abs(af), nil -} - -// InEpsilon asserts that expected and actual have a relative error less than epsilon -func InEpsilon(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - actualEpsilon, err := calcRelativeError(expected, actual) - if err != nil { - return Fail(t, err.Error(), msgAndArgs...) - } - if actualEpsilon > epsilon { - return Fail(t, fmt.Sprintf("Relative error is too high: %#v (expected)\n"+ - " < %#v (actual)", epsilon, actualEpsilon), msgAndArgs...) - } - - return true -} - -// InEpsilonSlice is the same as InEpsilon, except it compares each value from two slices. -func InEpsilonSlice(t TestingT, expected, actual interface{}, epsilon float64, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - if expected == nil || actual == nil || - reflect.TypeOf(actual).Kind() != reflect.Slice || - reflect.TypeOf(expected).Kind() != reflect.Slice { - return Fail(t, fmt.Sprintf("Parameters must be slice"), msgAndArgs...) - } - - actualSlice := reflect.ValueOf(actual) - expectedSlice := reflect.ValueOf(expected) - - for i := 0; i < actualSlice.Len(); i++ { - result := InEpsilon(t, actualSlice.Index(i).Interface(), expectedSlice.Index(i).Interface(), epsilon) - if !result { - return result - } - } - - return true -} - -/* - Errors -*/ - -// NoError asserts that a function returned no error (i.e. `nil`). -// -// actualObj, err := SomeFunction() -// if assert.NoError(t, err) { -// assert.Equal(t, expectedObj, actualObj) -// } -func NoError(t TestingT, err error, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - if err != nil { - return Fail(t, fmt.Sprintf("Received unexpected error:\n%+v", err), msgAndArgs...) - } - - return true -} - -// Error asserts that a function returned an error (i.e. not `nil`). -// -// actualObj, err := SomeFunction() -// if assert.Error(t, err) { -// assert.Equal(t, expectedError, err) -// } -func Error(t TestingT, err error, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - if err == nil { - return Fail(t, "An error is expected but got nil.", msgAndArgs...) - } - - return true -} - -// EqualError asserts that a function returned an error (i.e. not `nil`) -// and that it is equal to the provided error. -// -// actualObj, err := SomeFunction() -// assert.EqualError(t, err, expectedErrorString) -func EqualError(t TestingT, theError error, errString string, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - if !Error(t, theError, msgAndArgs...) { - return false - } - expected := errString - actual := theError.Error() - // don't need to use deep equals here, we know they are both strings - if expected != actual { - return Fail(t, fmt.Sprintf("Error message not equal:\n"+ - "expected: %q\n"+ - "actual : %q", expected, actual), msgAndArgs...) - } - return true -} - -// matchRegexp return true if a specified regexp matches a string. -func matchRegexp(rx interface{}, str interface{}) bool { - - var r *regexp.Regexp - if rr, ok := rx.(*regexp.Regexp); ok { - r = rr - } else { - r = regexp.MustCompile(fmt.Sprint(rx)) - } - - return (r.FindStringIndex(fmt.Sprint(str)) != nil) - -} - -// Regexp asserts that a specified regexp matches a string. -// -// assert.Regexp(t, regexp.MustCompile("start"), "it's starting") -// assert.Regexp(t, "start...$", "it's not starting") -func Regexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - - match := matchRegexp(rx, str) - - if !match { - Fail(t, fmt.Sprintf("Expect \"%v\" to match \"%v\"", str, rx), msgAndArgs...) - } - - return match -} - -// NotRegexp asserts that a specified regexp does not match a string. -// -// assert.NotRegexp(t, regexp.MustCompile("starts"), "it's starting") -// assert.NotRegexp(t, "^start", "it's not starting") -func NotRegexp(t TestingT, rx interface{}, str interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - match := matchRegexp(rx, str) - - if match { - Fail(t, fmt.Sprintf("Expect \"%v\" to NOT match \"%v\"", str, rx), msgAndArgs...) - } - - return !match - -} - -// Zero asserts that i is the zero value for its type. -func Zero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - if i != nil && !reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) { - return Fail(t, fmt.Sprintf("Should be zero, but was %v", i), msgAndArgs...) - } - return true -} - -// NotZero asserts that i is not the zero value for its type. -func NotZero(t TestingT, i interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - if i == nil || reflect.DeepEqual(i, reflect.Zero(reflect.TypeOf(i)).Interface()) { - return Fail(t, fmt.Sprintf("Should not be zero, but was %v", i), msgAndArgs...) - } - return true -} - -// FileExists checks whether a file exists in the given path. It also fails if the path points to a directory or there is an error when trying to check the file. -func FileExists(t TestingT, path string, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - info, err := os.Lstat(path) - if err != nil { - if os.IsNotExist(err) { - return Fail(t, fmt.Sprintf("unable to find file %q", path), msgAndArgs...) - } - return Fail(t, fmt.Sprintf("error when running os.Lstat(%q): %s", path, err), msgAndArgs...) - } - if info.IsDir() { - return Fail(t, fmt.Sprintf("%q is a directory", path), msgAndArgs...) - } - return true -} - -// DirExists checks whether a directory exists in the given path. It also fails if the path is a file rather a directory or there is an error checking whether it exists. -func DirExists(t TestingT, path string, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - info, err := os.Lstat(path) - if err != nil { - if os.IsNotExist(err) { - return Fail(t, fmt.Sprintf("unable to find file %q", path), msgAndArgs...) - } - return Fail(t, fmt.Sprintf("error when running os.Lstat(%q): %s", path, err), msgAndArgs...) - } - if !info.IsDir() { - return Fail(t, fmt.Sprintf("%q is a file", path), msgAndArgs...) - } - return true -} - -// JSONEq asserts that two JSON strings are equivalent. -// -// assert.JSONEq(t, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) -func JSONEq(t TestingT, expected string, actual string, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - var expectedJSONAsInterface, actualJSONAsInterface interface{} - - if err := json.Unmarshal([]byte(expected), &expectedJSONAsInterface); err != nil { - return Fail(t, fmt.Sprintf("Expected value ('%s') is not valid json.\nJSON parsing error: '%s'", expected, err.Error()), msgAndArgs...) - } - - if err := json.Unmarshal([]byte(actual), &actualJSONAsInterface); err != nil { - return Fail(t, fmt.Sprintf("Input ('%s') needs to be valid json.\nJSON parsing error: '%s'", actual, err.Error()), msgAndArgs...) - } - - return Equal(t, expectedJSONAsInterface, actualJSONAsInterface, msgAndArgs...) -} - -func typeAndKind(v interface{}) (reflect.Type, reflect.Kind) { - t := reflect.TypeOf(v) - k := t.Kind() - - if k == reflect.Ptr { - t = t.Elem() - k = t.Kind() - } - return t, k -} - -// diff returns a diff of both values as long as both are of the same type and -// are a struct, map, slice, array or string. Otherwise it returns an empty string. -func diff(expected interface{}, actual interface{}) string { - if expected == nil || actual == nil { - return "" - } - - et, ek := typeAndKind(expected) - at, _ := typeAndKind(actual) - - if et != at { - return "" - } - - if ek != reflect.Struct && ek != reflect.Map && ek != reflect.Slice && ek != reflect.Array && ek != reflect.String { - return "" - } - - var e, a string - if et != reflect.TypeOf("") { - e = spewConfig.Sdump(expected) - a = spewConfig.Sdump(actual) - } else { - e = expected.(string) - a = actual.(string) - } - - diff, _ := difflib.GetUnifiedDiffString(difflib.UnifiedDiff{ - A: difflib.SplitLines(e), - B: difflib.SplitLines(a), - FromFile: "Expected", - FromDate: "", - ToFile: "Actual", - ToDate: "", - Context: 1, - }) - - return "\n\nDiff:\n" + diff -} - -// validateEqualArgs checks whether provided arguments can be safely used in the -// Equal/NotEqual functions. -func validateEqualArgs(expected, actual interface{}) error { - if isFunction(expected) || isFunction(actual) { - return errors.New("cannot take func type as argument") - } - return nil -} - -func isFunction(arg interface{}) bool { - if arg == nil { - return false - } - return reflect.TypeOf(arg).Kind() == reflect.Func -} - -var spewConfig = spew.ConfigState{ - Indent: " ", - DisablePointerAddresses: true, - DisableCapacities: true, - SortKeys: true, -} - -type tHelper interface { - Helper() -} diff --git a/vendor/github.com/stretchr/testify/assert/assertions_test.go b/vendor/github.com/stretchr/testify/assert/assertions_test.go deleted file mode 100644 index 332271eb65db..000000000000 --- a/vendor/github.com/stretchr/testify/assert/assertions_test.go +++ /dev/null @@ -1,1826 +0,0 @@ -package assert - -import ( - "bytes" - "encoding/json" - "errors" - "fmt" - "io" - "math" - "os" - "reflect" - "regexp" - "runtime" - "strings" - "testing" - "time" -) - -var ( - i interface{} - zeros = []interface{}{ - false, - byte(0), - complex64(0), - complex128(0), - float32(0), - float64(0), - int(0), - int8(0), - int16(0), - int32(0), - int64(0), - rune(0), - uint(0), - uint8(0), - uint16(0), - uint32(0), - uint64(0), - uintptr(0), - "", - [0]interface{}{}, - []interface{}(nil), - struct{ x int }{}, - (*interface{})(nil), - (func())(nil), - nil, - interface{}(nil), - map[interface{}]interface{}(nil), - (chan interface{})(nil), - (<-chan interface{})(nil), - (chan<- interface{})(nil), - } - nonZeros = []interface{}{ - true, - byte(1), - complex64(1), - complex128(1), - float32(1), - float64(1), - int(1), - int8(1), - int16(1), - int32(1), - int64(1), - rune(1), - uint(1), - uint8(1), - uint16(1), - uint32(1), - uint64(1), - uintptr(1), - "s", - [1]interface{}{1}, - []interface{}{}, - struct{ x int }{1}, - (*interface{})(&i), - (func())(func() {}), - interface{}(1), - map[interface{}]interface{}{}, - (chan interface{})(make(chan interface{})), - (<-chan interface{})(make(chan interface{})), - (chan<- interface{})(make(chan interface{})), - } -) - -// AssertionTesterInterface defines an interface to be used for testing assertion methods -type AssertionTesterInterface interface { - TestMethod() -} - -// AssertionTesterConformingObject is an object that conforms to the AssertionTesterInterface interface -type AssertionTesterConformingObject struct { -} - -func (a *AssertionTesterConformingObject) TestMethod() { -} - -// AssertionTesterNonConformingObject is an object that does not conform to the AssertionTesterInterface interface -type AssertionTesterNonConformingObject struct { -} - -func TestObjectsAreEqual(t *testing.T) { - - if !ObjectsAreEqual("Hello World", "Hello World") { - t.Error("objectsAreEqual should return true") - } - if !ObjectsAreEqual(123, 123) { - t.Error("objectsAreEqual should return true") - } - if !ObjectsAreEqual(123.5, 123.5) { - t.Error("objectsAreEqual should return true") - } - if !ObjectsAreEqual([]byte("Hello World"), []byte("Hello World")) { - t.Error("objectsAreEqual should return true") - } - if !ObjectsAreEqual(nil, nil) { - t.Error("objectsAreEqual should return true") - } - if ObjectsAreEqual(map[int]int{5: 10}, map[int]int{10: 20}) { - t.Error("objectsAreEqual should return false") - } - if ObjectsAreEqual('x', "x") { - t.Error("objectsAreEqual should return false") - } - if ObjectsAreEqual("x", 'x') { - t.Error("objectsAreEqual should return false") - } - if ObjectsAreEqual(0, 0.1) { - t.Error("objectsAreEqual should return false") - } - if ObjectsAreEqual(0.1, 0) { - t.Error("objectsAreEqual should return false") - } - if ObjectsAreEqual(uint32(10), int32(10)) { - t.Error("objectsAreEqual should return false") - } - if !ObjectsAreEqualValues(uint32(10), int32(10)) { - t.Error("ObjectsAreEqualValues should return true") - } - if ObjectsAreEqualValues(0, nil) { - t.Fail() - } - if ObjectsAreEqualValues(nil, 0) { - t.Fail() - } - -} - -func TestImplements(t *testing.T) { - - mockT := new(testing.T) - - if !Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject)) { - t.Error("Implements method should return true: AssertionTesterConformingObject implements AssertionTesterInterface") - } - if Implements(mockT, (*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject)) { - t.Error("Implements method should return false: AssertionTesterNonConformingObject does not implements AssertionTesterInterface") - } - if Implements(mockT, (*AssertionTesterInterface)(nil), nil) { - t.Error("Implements method should return false: nil does not implement AssertionTesterInterface") - } - -} - -func TestIsType(t *testing.T) { - - mockT := new(testing.T) - - if !IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) { - t.Error("IsType should return true: AssertionTesterConformingObject is the same type as AssertionTesterConformingObject") - } - if IsType(mockT, new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject)) { - t.Error("IsType should return false: AssertionTesterConformingObject is not the same type as AssertionTesterNonConformingObject") - } - -} - -type myType string - -func TestEqual(t *testing.T) { - - mockT := new(testing.T) - - if !Equal(mockT, "Hello World", "Hello World") { - t.Error("Equal should return true") - } - if !Equal(mockT, 123, 123) { - t.Error("Equal should return true") - } - if !Equal(mockT, 123.5, 123.5) { - t.Error("Equal should return true") - } - if !Equal(mockT, []byte("Hello World"), []byte("Hello World")) { - t.Error("Equal should return true") - } - if !Equal(mockT, nil, nil) { - t.Error("Equal should return true") - } - if !Equal(mockT, int32(123), int32(123)) { - t.Error("Equal should return true") - } - if !Equal(mockT, uint64(123), uint64(123)) { - t.Error("Equal should return true") - } - if !Equal(mockT, myType("1"), myType("1")) { - t.Error("Equal should return true") - } - if !Equal(mockT, &struct{}{}, &struct{}{}) { - t.Error("Equal should return true (pointer equality is based on equality of underlying value)") - } - var m map[string]interface{} - if Equal(mockT, m["bar"], "something") { - t.Error("Equal should return false") - } - if Equal(mockT, myType("1"), myType("2")) { - t.Error("Equal should return false") - } -} - -func TestSame(t *testing.T) { - - mockT := new(testing.T) - - ptr := func(i int) *int { - return &i - } - - if Same(mockT, ptr(1), ptr(1)) { - t.Error("Same should return false") - } - if Same(mockT, 1, 1) { - t.Error("Same should return false") - } - p := ptr(2) - if Same(mockT, p, *p) { - t.Error("Same should return false") - } - if !Same(mockT, p, p) { - t.Error("Same should return true") - } -} - -// bufferT implements TestingT. Its implementation of Errorf writes the output that would be produced by -// testing.T.Errorf to an internal bytes.Buffer. -type bufferT struct { - buf bytes.Buffer -} - -func (t *bufferT) Errorf(format string, args ...interface{}) { - // implementation of decorate is copied from testing.T - decorate := func(s string) string { - _, file, line, ok := runtime.Caller(3) // decorate + log + public function. - if ok { - // Truncate file name at last file name separator. - if index := strings.LastIndex(file, "/"); index >= 0 { - file = file[index+1:] - } else if index = strings.LastIndex(file, "\\"); index >= 0 { - file = file[index+1:] - } - } else { - file = "???" - line = 1 - } - buf := new(bytes.Buffer) - // Every line is indented at least one tab. - buf.WriteByte('\t') - fmt.Fprintf(buf, "%s:%d: ", file, line) - lines := strings.Split(s, "\n") - if l := len(lines); l > 1 && lines[l-1] == "" { - lines = lines[:l-1] - } - for i, line := range lines { - if i > 0 { - // Second and subsequent lines are indented an extra tab. - buf.WriteString("\n\t\t") - } - buf.WriteString(line) - } - buf.WriteByte('\n') - return buf.String() - } - t.buf.WriteString(decorate(fmt.Sprintf(format, args...))) -} - -func TestStringEqual(t *testing.T) { - for i, currCase := range []struct { - equalWant string - equalGot string - msgAndArgs []interface{} - want string - }{ - {equalWant: "hi, \nmy name is", equalGot: "what,\nmy name is", want: "\tassertions.go:\\d+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"hi, \\\\nmy name is\"\n\\s+actual\\s+: \"what,\\\\nmy name is\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1,2 \\+1,2 @@\n\\s+-hi, \n\\s+\\+what,\n\\s+my name is"}, - } { - mockT := &bufferT{} - Equal(mockT, currCase.equalWant, currCase.equalGot, currCase.msgAndArgs...) - Regexp(t, regexp.MustCompile(currCase.want), mockT.buf.String(), "Case %d", i) - } -} - -func TestEqualFormatting(t *testing.T) { - for i, currCase := range []struct { - equalWant string - equalGot string - msgAndArgs []interface{} - want string - }{ - {equalWant: "want", equalGot: "got", want: "\tassertions.go:\\d+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n"}, - {equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{"hello, %v!", "world"}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+hello, world!\n"}, - {equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{123}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+123\n"}, - {equalWant: "want", equalGot: "got", msgAndArgs: []interface{}{struct{ a string }{"hello"}}, want: "\tassertions.go:[0-9]+: \n\t+Error Trace:\t\n\t+Error:\\s+Not equal:\\s+\n\\s+expected: \"want\"\n\\s+actual\\s+: \"got\"\n\\s+Diff:\n\\s+-+ Expected\n\\s+\\++ Actual\n\\s+@@ -1 \\+1 @@\n\\s+-want\n\\s+\\+got\n\\s+Messages:\\s+{a:hello}\n"}, - } { - mockT := &bufferT{} - Equal(mockT, currCase.equalWant, currCase.equalGot, currCase.msgAndArgs...) - Regexp(t, regexp.MustCompile(currCase.want), mockT.buf.String(), "Case %d", i) - } -} - -func TestFormatUnequalValues(t *testing.T) { - expected, actual := formatUnequalValues("foo", "bar") - Equal(t, `"foo"`, expected, "value should not include type") - Equal(t, `"bar"`, actual, "value should not include type") - - expected, actual = formatUnequalValues(123, 123) - Equal(t, `123`, expected, "value should not include type") - Equal(t, `123`, actual, "value should not include type") - - expected, actual = formatUnequalValues(int64(123), int32(123)) - Equal(t, `int64(123)`, expected, "value should include type") - Equal(t, `int32(123)`, actual, "value should include type") - - expected, actual = formatUnequalValues(int64(123), nil) - Equal(t, `int64(123)`, expected, "value should include type") - Equal(t, `()`, actual, "value should include type") - - type testStructType struct { - Val string - } - - expected, actual = formatUnequalValues(&testStructType{Val: "test"}, &testStructType{Val: "test"}) - Equal(t, `&assert.testStructType{Val:"test"}`, expected, "value should not include type annotation") - Equal(t, `&assert.testStructType{Val:"test"}`, actual, "value should not include type annotation") -} - -func TestNotNil(t *testing.T) { - - mockT := new(testing.T) - - if !NotNil(mockT, new(AssertionTesterConformingObject)) { - t.Error("NotNil should return true: object is not nil") - } - if NotNil(mockT, nil) { - t.Error("NotNil should return false: object is nil") - } - if NotNil(mockT, (*struct{})(nil)) { - t.Error("NotNil should return false: object is (*struct{})(nil)") - } - -} - -func TestNil(t *testing.T) { - - mockT := new(testing.T) - - if !Nil(mockT, nil) { - t.Error("Nil should return true: object is nil") - } - if !Nil(mockT, (*struct{})(nil)) { - t.Error("Nil should return true: object is (*struct{})(nil)") - } - if Nil(mockT, new(AssertionTesterConformingObject)) { - t.Error("Nil should return false: object is not nil") - } - -} - -func TestTrue(t *testing.T) { - - mockT := new(testing.T) - - if !True(mockT, true) { - t.Error("True should return true") - } - if True(mockT, false) { - t.Error("True should return false") - } - -} - -func TestFalse(t *testing.T) { - - mockT := new(testing.T) - - if !False(mockT, false) { - t.Error("False should return true") - } - if False(mockT, true) { - t.Error("False should return false") - } - -} - -func TestExactly(t *testing.T) { - - mockT := new(testing.T) - - a := float32(1) - b := float64(1) - c := float32(1) - d := float32(2) - - if Exactly(mockT, a, b) { - t.Error("Exactly should return false") - } - if Exactly(mockT, a, d) { - t.Error("Exactly should return false") - } - if !Exactly(mockT, a, c) { - t.Error("Exactly should return true") - } - - if Exactly(mockT, nil, a) { - t.Error("Exactly should return false") - } - if Exactly(mockT, a, nil) { - t.Error("Exactly should return false") - } - -} - -func TestNotEqual(t *testing.T) { - - mockT := new(testing.T) - - if !NotEqual(mockT, "Hello World", "Hello World!") { - t.Error("NotEqual should return true") - } - if !NotEqual(mockT, 123, 1234) { - t.Error("NotEqual should return true") - } - if !NotEqual(mockT, 123.5, 123.55) { - t.Error("NotEqual should return true") - } - if !NotEqual(mockT, []byte("Hello World"), []byte("Hello World!")) { - t.Error("NotEqual should return true") - } - if !NotEqual(mockT, nil, new(AssertionTesterConformingObject)) { - t.Error("NotEqual should return true") - } - funcA := func() int { return 23 } - funcB := func() int { return 42 } - if NotEqual(mockT, funcA, funcB) { - t.Error("NotEqual should return false") - } - - if NotEqual(mockT, "Hello World", "Hello World") { - t.Error("NotEqual should return false") - } - if NotEqual(mockT, 123, 123) { - t.Error("NotEqual should return false") - } - if NotEqual(mockT, 123.5, 123.5) { - t.Error("NotEqual should return false") - } - if NotEqual(mockT, []byte("Hello World"), []byte("Hello World")) { - t.Error("NotEqual should return false") - } - if NotEqual(mockT, new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) { - t.Error("NotEqual should return false") - } - if NotEqual(mockT, &struct{}{}, &struct{}{}) { - t.Error("NotEqual should return false") - } -} - -type A struct { - Name, Value string -} - -func TestContains(t *testing.T) { - - mockT := new(testing.T) - list := []string{"Foo", "Bar"} - complexList := []*A{ - {"b", "c"}, - {"d", "e"}, - {"g", "h"}, - {"j", "k"}, - } - simpleMap := map[interface{}]interface{}{"Foo": "Bar"} - - if !Contains(mockT, "Hello World", "Hello") { - t.Error("Contains should return true: \"Hello World\" contains \"Hello\"") - } - if Contains(mockT, "Hello World", "Salut") { - t.Error("Contains should return false: \"Hello World\" does not contain \"Salut\"") - } - - if !Contains(mockT, list, "Bar") { - t.Error("Contains should return true: \"[\"Foo\", \"Bar\"]\" contains \"Bar\"") - } - if Contains(mockT, list, "Salut") { - t.Error("Contains should return false: \"[\"Foo\", \"Bar\"]\" does not contain \"Salut\"") - } - if !Contains(mockT, complexList, &A{"g", "h"}) { - t.Error("Contains should return true: complexList contains {\"g\", \"h\"}") - } - if Contains(mockT, complexList, &A{"g", "e"}) { - t.Error("Contains should return false: complexList contains {\"g\", \"e\"}") - } - if Contains(mockT, complexList, &A{"g", "e"}) { - t.Error("Contains should return false: complexList contains {\"g\", \"e\"}") - } - if !Contains(mockT, simpleMap, "Foo") { - t.Error("Contains should return true: \"{\"Foo\": \"Bar\"}\" contains \"Foo\"") - } - if Contains(mockT, simpleMap, "Bar") { - t.Error("Contains should return false: \"{\"Foo\": \"Bar\"}\" does not contains \"Bar\"") - } -} - -func TestNotContains(t *testing.T) { - - mockT := new(testing.T) - list := []string{"Foo", "Bar"} - simpleMap := map[interface{}]interface{}{"Foo": "Bar"} - - if !NotContains(mockT, "Hello World", "Hello!") { - t.Error("NotContains should return true: \"Hello World\" does not contain \"Hello!\"") - } - if NotContains(mockT, "Hello World", "Hello") { - t.Error("NotContains should return false: \"Hello World\" contains \"Hello\"") - } - - if !NotContains(mockT, list, "Foo!") { - t.Error("NotContains should return true: \"[\"Foo\", \"Bar\"]\" does not contain \"Foo!\"") - } - if NotContains(mockT, list, "Foo") { - t.Error("NotContains should return false: \"[\"Foo\", \"Bar\"]\" contains \"Foo\"") - } - if NotContains(mockT, simpleMap, "Foo") { - t.Error("Contains should return true: \"{\"Foo\": \"Bar\"}\" contains \"Foo\"") - } - if !NotContains(mockT, simpleMap, "Bar") { - t.Error("Contains should return false: \"{\"Foo\": \"Bar\"}\" does not contains \"Bar\"") - } -} - -func TestSubset(t *testing.T) { - mockT := new(testing.T) - - if !Subset(mockT, []int{1, 2, 3}, nil) { - t.Error("Subset should return true: given subset is nil") - } - if !Subset(mockT, []int{1, 2, 3}, []int{}) { - t.Error("Subset should return true: any set contains the nil set") - } - if !Subset(mockT, []int{1, 2, 3}, []int{1, 2}) { - t.Error("Subset should return true: [1, 2, 3] contains [1, 2]") - } - if !Subset(mockT, []int{1, 2, 3}, []int{1, 2, 3}) { - t.Error("Subset should return true: [1, 2, 3] contains [1, 2, 3]") - } - if !Subset(mockT, []string{"hello", "world"}, []string{"hello"}) { - t.Error("Subset should return true: [\"hello\", \"world\"] contains [\"hello\"]") - } - - if Subset(mockT, []string{"hello", "world"}, []string{"hello", "testify"}) { - t.Error("Subset should return false: [\"hello\", \"world\"] does not contain [\"hello\", \"testify\"]") - } - if Subset(mockT, []int{1, 2, 3}, []int{4, 5}) { - t.Error("Subset should return false: [1, 2, 3] does not contain [4, 5]") - } - if Subset(mockT, []int{1, 2, 3}, []int{1, 5}) { - t.Error("Subset should return false: [1, 2, 3] does not contain [1, 5]") - } -} - -func TestNotSubset(t *testing.T) { - mockT := new(testing.T) - - if NotSubset(mockT, []int{1, 2, 3}, nil) { - t.Error("NotSubset should return false: given subset is nil") - } - if NotSubset(mockT, []int{1, 2, 3}, []int{}) { - t.Error("NotSubset should return false: any set contains the nil set") - } - if NotSubset(mockT, []int{1, 2, 3}, []int{1, 2}) { - t.Error("NotSubset should return false: [1, 2, 3] contains [1, 2]") - } - if NotSubset(mockT, []int{1, 2, 3}, []int{1, 2, 3}) { - t.Error("NotSubset should return false: [1, 2, 3] contains [1, 2, 3]") - } - if NotSubset(mockT, []string{"hello", "world"}, []string{"hello"}) { - t.Error("NotSubset should return false: [\"hello\", \"world\"] contains [\"hello\"]") - } - - if !NotSubset(mockT, []string{"hello", "world"}, []string{"hello", "testify"}) { - t.Error("NotSubset should return true: [\"hello\", \"world\"] does not contain [\"hello\", \"testify\"]") - } - if !NotSubset(mockT, []int{1, 2, 3}, []int{4, 5}) { - t.Error("NotSubset should return true: [1, 2, 3] does not contain [4, 5]") - } - if !NotSubset(mockT, []int{1, 2, 3}, []int{1, 5}) { - t.Error("NotSubset should return true: [1, 2, 3] does not contain [1, 5]") - } -} - -func TestNotSubsetNil(t *testing.T) { - mockT := new(testing.T) - NotSubset(mockT, []string{"foo"}, nil) - if !mockT.Failed() { - t.Error("NotSubset on nil set should have failed the test") - } -} - -func Test_includeElement(t *testing.T) { - - list1 := []string{"Foo", "Bar"} - list2 := []int{1, 2} - simpleMap := map[interface{}]interface{}{"Foo": "Bar"} - - ok, found := includeElement("Hello World", "World") - True(t, ok) - True(t, found) - - ok, found = includeElement(list1, "Foo") - True(t, ok) - True(t, found) - - ok, found = includeElement(list1, "Bar") - True(t, ok) - True(t, found) - - ok, found = includeElement(list2, 1) - True(t, ok) - True(t, found) - - ok, found = includeElement(list2, 2) - True(t, ok) - True(t, found) - - ok, found = includeElement(list1, "Foo!") - True(t, ok) - False(t, found) - - ok, found = includeElement(list2, 3) - True(t, ok) - False(t, found) - - ok, found = includeElement(list2, "1") - True(t, ok) - False(t, found) - - ok, found = includeElement(simpleMap, "Foo") - True(t, ok) - True(t, found) - - ok, found = includeElement(simpleMap, "Bar") - True(t, ok) - False(t, found) - - ok, found = includeElement(1433, "1") - False(t, ok) - False(t, found) -} - -func TestElementsMatch(t *testing.T) { - mockT := new(testing.T) - - if !ElementsMatch(mockT, nil, nil) { - t.Error("ElementsMatch should return true") - } - if !ElementsMatch(mockT, []int{}, []int{}) { - t.Error("ElementsMatch should return true") - } - if !ElementsMatch(mockT, []int{1}, []int{1}) { - t.Error("ElementsMatch should return true") - } - if !ElementsMatch(mockT, []int{1, 1}, []int{1, 1}) { - t.Error("ElementsMatch should return true") - } - if !ElementsMatch(mockT, []int{1, 2}, []int{1, 2}) { - t.Error("ElementsMatch should return true") - } - if !ElementsMatch(mockT, []int{1, 2}, []int{2, 1}) { - t.Error("ElementsMatch should return true") - } - if !ElementsMatch(mockT, [2]int{1, 2}, [2]int{2, 1}) { - t.Error("ElementsMatch should return true") - } - if !ElementsMatch(mockT, []string{"hello", "world"}, []string{"world", "hello"}) { - t.Error("ElementsMatch should return true") - } - if !ElementsMatch(mockT, []string{"hello", "hello"}, []string{"hello", "hello"}) { - t.Error("ElementsMatch should return true") - } - if !ElementsMatch(mockT, []string{"hello", "hello", "world"}, []string{"hello", "world", "hello"}) { - t.Error("ElementsMatch should return true") - } - if !ElementsMatch(mockT, [3]string{"hello", "hello", "world"}, [3]string{"hello", "world", "hello"}) { - t.Error("ElementsMatch should return true") - } - if !ElementsMatch(mockT, []int{}, nil) { - t.Error("ElementsMatch should return true") - } - - if ElementsMatch(mockT, []int{1}, []int{1, 1}) { - t.Error("ElementsMatch should return false") - } - if ElementsMatch(mockT, []int{1, 2}, []int{2, 2}) { - t.Error("ElementsMatch should return false") - } - if ElementsMatch(mockT, []string{"hello", "hello"}, []string{"hello"}) { - t.Error("ElementsMatch should return false") - } -} - -func TestCondition(t *testing.T) { - mockT := new(testing.T) - - if !Condition(mockT, func() bool { return true }, "Truth") { - t.Error("Condition should return true") - } - - if Condition(mockT, func() bool { return false }, "Lie") { - t.Error("Condition should return false") - } - -} - -func TestDidPanic(t *testing.T) { - - if funcDidPanic, _ := didPanic(func() { - panic("Panic!") - }); !funcDidPanic { - t.Error("didPanic should return true") - } - - if funcDidPanic, _ := didPanic(func() { - }); funcDidPanic { - t.Error("didPanic should return false") - } - -} - -func TestPanics(t *testing.T) { - - mockT := new(testing.T) - - if !Panics(mockT, func() { - panic("Panic!") - }) { - t.Error("Panics should return true") - } - - if Panics(mockT, func() { - }) { - t.Error("Panics should return false") - } - -} - -func TestPanicsWithValue(t *testing.T) { - - mockT := new(testing.T) - - if !PanicsWithValue(mockT, "Panic!", func() { - panic("Panic!") - }) { - t.Error("PanicsWithValue should return true") - } - - if PanicsWithValue(mockT, "Panic!", func() { - }) { - t.Error("PanicsWithValue should return false") - } - - if PanicsWithValue(mockT, "at the disco", func() { - panic("Panic!") - }) { - t.Error("PanicsWithValue should return false") - } -} - -func TestNotPanics(t *testing.T) { - - mockT := new(testing.T) - - if !NotPanics(mockT, func() { - }) { - t.Error("NotPanics should return true") - } - - if NotPanics(mockT, func() { - panic("Panic!") - }) { - t.Error("NotPanics should return false") - } - -} - -func TestNoError(t *testing.T) { - - mockT := new(testing.T) - - // start with a nil error - var err error - - True(t, NoError(mockT, err), "NoError should return True for nil arg") - - // now set an error - err = errors.New("some error") - - False(t, NoError(mockT, err), "NoError with error should return False") - - // returning an empty error interface - err = func() error { - var err *customError - if err != nil { - t.Fatal("err should be nil here") - } - return err - }() - - if err == nil { // err is not nil here! - t.Errorf("Error should be nil due to empty interface: %s", err) - } - - False(t, NoError(mockT, err), "NoError should fail with empty error interface") -} - -type customError struct{} - -func (*customError) Error() string { return "fail" } - -func TestError(t *testing.T) { - - mockT := new(testing.T) - - // start with a nil error - var err error - - False(t, Error(mockT, err), "Error should return False for nil arg") - - // now set an error - err = errors.New("some error") - - True(t, Error(mockT, err), "Error with error should return True") - - // go vet check - True(t, Errorf(mockT, err, "example with %s", "formatted message"), "Errorf with error should rturn True") - - // returning an empty error interface - err = func() error { - var err *customError - if err != nil { - t.Fatal("err should be nil here") - } - return err - }() - - if err == nil { // err is not nil here! - t.Errorf("Error should be nil due to empty interface: %s", err) - } - - True(t, Error(mockT, err), "Error should pass with empty error interface") -} - -func TestEqualError(t *testing.T) { - mockT := new(testing.T) - - // start with a nil error - var err error - False(t, EqualError(mockT, err, ""), - "EqualError should return false for nil arg") - - // now set an error - err = errors.New("some error") - False(t, EqualError(mockT, err, "Not some error"), - "EqualError should return false for different error string") - True(t, EqualError(mockT, err, "some error"), - "EqualError should return true") -} - -func Test_isEmpty(t *testing.T) { - - chWithValue := make(chan struct{}, 1) - chWithValue <- struct{}{} - - True(t, isEmpty("")) - True(t, isEmpty(nil)) - True(t, isEmpty([]string{})) - True(t, isEmpty(0)) - True(t, isEmpty(int32(0))) - True(t, isEmpty(int64(0))) - True(t, isEmpty(false)) - True(t, isEmpty(map[string]string{})) - True(t, isEmpty(new(time.Time))) - True(t, isEmpty(time.Time{})) - True(t, isEmpty(make(chan struct{}))) - False(t, isEmpty("something")) - False(t, isEmpty(errors.New("something"))) - False(t, isEmpty([]string{"something"})) - False(t, isEmpty(1)) - False(t, isEmpty(true)) - False(t, isEmpty(map[string]string{"Hello": "World"})) - False(t, isEmpty(chWithValue)) - -} - -func TestEmpty(t *testing.T) { - - mockT := new(testing.T) - chWithValue := make(chan struct{}, 1) - chWithValue <- struct{}{} - var tiP *time.Time - var tiNP time.Time - var s *string - var f *os.File - sP := &s - x := 1 - xP := &x - - type TString string - type TStruct struct { - x int - s []int - } - - True(t, Empty(mockT, ""), "Empty string is empty") - True(t, Empty(mockT, nil), "Nil is empty") - True(t, Empty(mockT, []string{}), "Empty string array is empty") - True(t, Empty(mockT, 0), "Zero int value is empty") - True(t, Empty(mockT, false), "False value is empty") - True(t, Empty(mockT, make(chan struct{})), "Channel without values is empty") - True(t, Empty(mockT, s), "Nil string pointer is empty") - True(t, Empty(mockT, f), "Nil os.File pointer is empty") - True(t, Empty(mockT, tiP), "Nil time.Time pointer is empty") - True(t, Empty(mockT, tiNP), "time.Time is empty") - True(t, Empty(mockT, TStruct{}), "struct with zero values is empty") - True(t, Empty(mockT, TString("")), "empty aliased string is empty") - True(t, Empty(mockT, sP), "ptr to nil value is empty") - - False(t, Empty(mockT, "something"), "Non Empty string is not empty") - False(t, Empty(mockT, errors.New("something")), "Non nil object is not empty") - False(t, Empty(mockT, []string{"something"}), "Non empty string array is not empty") - False(t, Empty(mockT, 1), "Non-zero int value is not empty") - False(t, Empty(mockT, true), "True value is not empty") - False(t, Empty(mockT, chWithValue), "Channel with values is not empty") - False(t, Empty(mockT, TStruct{x: 1}), "struct with initialized values is empty") - False(t, Empty(mockT, TString("abc")), "non-empty aliased string is empty") - False(t, Empty(mockT, xP), "ptr to non-nil value is not empty") -} - -func TestNotEmpty(t *testing.T) { - - mockT := new(testing.T) - chWithValue := make(chan struct{}, 1) - chWithValue <- struct{}{} - - False(t, NotEmpty(mockT, ""), "Empty string is empty") - False(t, NotEmpty(mockT, nil), "Nil is empty") - False(t, NotEmpty(mockT, []string{}), "Empty string array is empty") - False(t, NotEmpty(mockT, 0), "Zero int value is empty") - False(t, NotEmpty(mockT, false), "False value is empty") - False(t, NotEmpty(mockT, make(chan struct{})), "Channel without values is empty") - - True(t, NotEmpty(mockT, "something"), "Non Empty string is not empty") - True(t, NotEmpty(mockT, errors.New("something")), "Non nil object is not empty") - True(t, NotEmpty(mockT, []string{"something"}), "Non empty string array is not empty") - True(t, NotEmpty(mockT, 1), "Non-zero int value is not empty") - True(t, NotEmpty(mockT, true), "True value is not empty") - True(t, NotEmpty(mockT, chWithValue), "Channel with values is not empty") -} - -func Test_getLen(t *testing.T) { - falseCases := []interface{}{ - nil, - 0, - true, - false, - 'A', - struct{}{}, - } - for _, v := range falseCases { - ok, l := getLen(v) - False(t, ok, "Expected getLen fail to get length of %#v", v) - Equal(t, 0, l, "getLen should return 0 for %#v", v) - } - - ch := make(chan int, 5) - ch <- 1 - ch <- 2 - ch <- 3 - trueCases := []struct { - v interface{} - l int - }{ - {[]int{1, 2, 3}, 3}, - {[...]int{1, 2, 3}, 3}, - {"ABC", 3}, - {map[int]int{1: 2, 2: 4, 3: 6}, 3}, - {ch, 3}, - - {[]int{}, 0}, - {map[int]int{}, 0}, - {make(chan int), 0}, - - {[]int(nil), 0}, - {map[int]int(nil), 0}, - {(chan int)(nil), 0}, - } - - for _, c := range trueCases { - ok, l := getLen(c.v) - True(t, ok, "Expected getLen success to get length of %#v", c.v) - Equal(t, c.l, l) - } -} - -func TestLen(t *testing.T) { - mockT := new(testing.T) - - False(t, Len(mockT, nil, 0), "nil does not have length") - False(t, Len(mockT, 0, 0), "int does not have length") - False(t, Len(mockT, true, 0), "true does not have length") - False(t, Len(mockT, false, 0), "false does not have length") - False(t, Len(mockT, 'A', 0), "Rune does not have length") - False(t, Len(mockT, struct{}{}, 0), "Struct does not have length") - - ch := make(chan int, 5) - ch <- 1 - ch <- 2 - ch <- 3 - - cases := []struct { - v interface{} - l int - }{ - {[]int{1, 2, 3}, 3}, - {[...]int{1, 2, 3}, 3}, - {"ABC", 3}, - {map[int]int{1: 2, 2: 4, 3: 6}, 3}, - {ch, 3}, - - {[]int{}, 0}, - {map[int]int{}, 0}, - {make(chan int), 0}, - - {[]int(nil), 0}, - {map[int]int(nil), 0}, - {(chan int)(nil), 0}, - } - - for _, c := range cases { - True(t, Len(mockT, c.v, c.l), "%#v have %d items", c.v, c.l) - } - - cases = []struct { - v interface{} - l int - }{ - {[]int{1, 2, 3}, 4}, - {[...]int{1, 2, 3}, 2}, - {"ABC", 2}, - {map[int]int{1: 2, 2: 4, 3: 6}, 4}, - {ch, 2}, - - {[]int{}, 1}, - {map[int]int{}, 1}, - {make(chan int), 1}, - - {[]int(nil), 1}, - {map[int]int(nil), 1}, - {(chan int)(nil), 1}, - } - - for _, c := range cases { - False(t, Len(mockT, c.v, c.l), "%#v have %d items", c.v, c.l) - } -} - -func TestWithinDuration(t *testing.T) { - - mockT := new(testing.T) - a := time.Now() - b := a.Add(10 * time.Second) - - True(t, WithinDuration(mockT, a, b, 10*time.Second), "A 10s difference is within a 10s time difference") - True(t, WithinDuration(mockT, b, a, 10*time.Second), "A 10s difference is within a 10s time difference") - - False(t, WithinDuration(mockT, a, b, 9*time.Second), "A 10s difference is not within a 9s time difference") - False(t, WithinDuration(mockT, b, a, 9*time.Second), "A 10s difference is not within a 9s time difference") - - False(t, WithinDuration(mockT, a, b, -9*time.Second), "A 10s difference is not within a 9s time difference") - False(t, WithinDuration(mockT, b, a, -9*time.Second), "A 10s difference is not within a 9s time difference") - - False(t, WithinDuration(mockT, a, b, -11*time.Second), "A 10s difference is not within a 9s time difference") - False(t, WithinDuration(mockT, b, a, -11*time.Second), "A 10s difference is not within a 9s time difference") -} - -func TestInDelta(t *testing.T) { - mockT := new(testing.T) - - True(t, InDelta(mockT, 1.001, 1, 0.01), "|1.001 - 1| <= 0.01") - True(t, InDelta(mockT, 1, 1.001, 0.01), "|1 - 1.001| <= 0.01") - True(t, InDelta(mockT, 1, 2, 1), "|1 - 2| <= 1") - False(t, InDelta(mockT, 1, 2, 0.5), "Expected |1 - 2| <= 0.5 to fail") - False(t, InDelta(mockT, 2, 1, 0.5), "Expected |2 - 1| <= 0.5 to fail") - False(t, InDelta(mockT, "", nil, 1), "Expected non numerals to fail") - False(t, InDelta(mockT, 42, math.NaN(), 0.01), "Expected NaN for actual to fail") - False(t, InDelta(mockT, math.NaN(), 42, 0.01), "Expected NaN for expected to fail") - - cases := []struct { - a, b interface{} - delta float64 - }{ - {uint8(2), uint8(1), 1}, - {uint16(2), uint16(1), 1}, - {uint32(2), uint32(1), 1}, - {uint64(2), uint64(1), 1}, - - {int(2), int(1), 1}, - {int8(2), int8(1), 1}, - {int16(2), int16(1), 1}, - {int32(2), int32(1), 1}, - {int64(2), int64(1), 1}, - - {float32(2), float32(1), 1}, - {float64(2), float64(1), 1}, - } - - for _, tc := range cases { - True(t, InDelta(mockT, tc.a, tc.b, tc.delta), "Expected |%V - %V| <= %v", tc.a, tc.b, tc.delta) - } -} - -func TestInDeltaSlice(t *testing.T) { - mockT := new(testing.T) - - True(t, InDeltaSlice(mockT, - []float64{1.001, 0.999}, - []float64{1, 1}, - 0.1), "{1.001, 0.009} is element-wise close to {1, 1} in delta=0.1") - - True(t, InDeltaSlice(mockT, - []float64{1, 2}, - []float64{0, 3}, - 1), "{1, 2} is element-wise close to {0, 3} in delta=1") - - False(t, InDeltaSlice(mockT, - []float64{1, 2}, - []float64{0, 3}, - 0.1), "{1, 2} is not element-wise close to {0, 3} in delta=0.1") - - False(t, InDeltaSlice(mockT, "", nil, 1), "Expected non numeral slices to fail") -} - -func TestInDeltaMapValues(t *testing.T) { - mockT := new(testing.T) - - for _, tc := range []struct { - title string - expect interface{} - actual interface{} - f func(TestingT, bool, ...interface{}) bool - delta float64 - }{ - { - title: "Within delta", - expect: map[string]float64{ - "foo": 1.0, - "bar": 2.0, - }, - actual: map[string]float64{ - "foo": 1.01, - "bar": 1.99, - }, - delta: 0.1, - f: True, - }, - { - title: "Within delta", - expect: map[int]float64{ - 1: 1.0, - 2: 2.0, - }, - actual: map[int]float64{ - 1: 1.0, - 2: 1.99, - }, - delta: 0.1, - f: True, - }, - { - title: "Different number of keys", - expect: map[int]float64{ - 1: 1.0, - 2: 2.0, - }, - actual: map[int]float64{ - 1: 1.0, - }, - delta: 0.1, - f: False, - }, - { - title: "Within delta with zero value", - expect: map[string]float64{ - "zero": 0.0, - }, - actual: map[string]float64{ - "zero": 0.0, - }, - delta: 0.1, - f: True, - }, - { - title: "With missing key with zero value", - expect: map[string]float64{ - "zero": 0.0, - "foo": 0.0, - }, - actual: map[string]float64{ - "zero": 0.0, - "bar": 0.0, - }, - f: False, - }, - } { - tc.f(t, InDeltaMapValues(mockT, tc.expect, tc.actual, tc.delta), tc.title+"\n"+diff(tc.expect, tc.actual)) - } -} - -func TestInEpsilon(t *testing.T) { - mockT := new(testing.T) - - cases := []struct { - a, b interface{} - epsilon float64 - }{ - {uint8(2), uint16(2), .001}, - {2.1, 2.2, 0.1}, - {2.2, 2.1, 0.1}, - {-2.1, -2.2, 0.1}, - {-2.2, -2.1, 0.1}, - {uint64(100), uint8(101), 0.01}, - {0.1, -0.1, 2}, - {0.1, 0, 2}, - {time.Second, time.Second + time.Millisecond, 0.002}, - } - - for _, tc := range cases { - True(t, InEpsilon(t, tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon), "test: %q", tc) - } - - cases = []struct { - a, b interface{} - epsilon float64 - }{ - {uint8(2), int16(-2), .001}, - {uint64(100), uint8(102), 0.01}, - {2.1, 2.2, 0.001}, - {2.2, 2.1, 0.001}, - {2.1, -2.2, 1}, - {2.1, "bla-bla", 0}, - {0.1, -0.1, 1.99}, - {0, 0.1, 2}, // expected must be different to zero - {time.Second, time.Second + 10*time.Millisecond, 0.002}, - } - - for _, tc := range cases { - False(t, InEpsilon(mockT, tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon)) - } - -} - -func TestInEpsilonSlice(t *testing.T) { - mockT := new(testing.T) - - True(t, InEpsilonSlice(mockT, - []float64{2.2, 2.0}, - []float64{2.1, 2.1}, - 0.06), "{2.2, 2.0} is element-wise close to {2.1, 2.1} in espilon=0.06") - - False(t, InEpsilonSlice(mockT, - []float64{2.2, 2.0}, - []float64{2.1, 2.1}, - 0.04), "{2.2, 2.0} is not element-wise close to {2.1, 2.1} in espilon=0.04") - - False(t, InEpsilonSlice(mockT, "", nil, 1), "Expected non numeral slices to fail") -} - -func TestRegexp(t *testing.T) { - mockT := new(testing.T) - - cases := []struct { - rx, str string - }{ - {"^start", "start of the line"}, - {"end$", "in the end"}, - {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12.34"}, - } - - for _, tc := range cases { - True(t, Regexp(mockT, tc.rx, tc.str)) - True(t, Regexp(mockT, regexp.MustCompile(tc.rx), tc.str)) - False(t, NotRegexp(mockT, tc.rx, tc.str)) - False(t, NotRegexp(mockT, regexp.MustCompile(tc.rx), tc.str)) - } - - cases = []struct { - rx, str string - }{ - {"^asdfastart", "Not the start of the line"}, - {"end$", "in the end."}, - {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12a.34"}, - } - - for _, tc := range cases { - False(t, Regexp(mockT, tc.rx, tc.str), "Expected \"%s\" to not match \"%s\"", tc.rx, tc.str) - False(t, Regexp(mockT, regexp.MustCompile(tc.rx), tc.str)) - True(t, NotRegexp(mockT, tc.rx, tc.str)) - True(t, NotRegexp(mockT, regexp.MustCompile(tc.rx), tc.str)) - } -} - -func testAutogeneratedFunction() { - defer func() { - if err := recover(); err == nil { - panic("did not panic") - } - CallerInfo() - }() - t := struct { - io.Closer - }{} - var c io.Closer - c = t - c.Close() -} - -func TestCallerInfoWithAutogeneratedFunctions(t *testing.T) { - NotPanics(t, func() { - testAutogeneratedFunction() - }) -} - -func TestZero(t *testing.T) { - mockT := new(testing.T) - - for _, test := range zeros { - True(t, Zero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test))) - } - - for _, test := range nonZeros { - False(t, Zero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test))) - } -} - -func TestNotZero(t *testing.T) { - mockT := new(testing.T) - - for _, test := range zeros { - False(t, NotZero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test))) - } - - for _, test := range nonZeros { - True(t, NotZero(mockT, test, "%#v is not the %v zero value", test, reflect.TypeOf(test))) - } -} - -func TestFileExists(t *testing.T) { - mockT := new(testing.T) - True(t, FileExists(mockT, "assertions.go")) - - mockT = new(testing.T) - False(t, FileExists(mockT, "random_file")) - - mockT = new(testing.T) - False(t, FileExists(mockT, "../_codegen")) -} - -func TestDirExists(t *testing.T) { - mockT := new(testing.T) - False(t, DirExists(mockT, "assertions.go")) - - mockT = new(testing.T) - False(t, DirExists(mockT, "random_dir")) - - mockT = new(testing.T) - True(t, DirExists(mockT, "../_codegen")) -} - -func TestJSONEq_EqualSONString(t *testing.T) { - mockT := new(testing.T) - True(t, JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`)) -} - -func TestJSONEq_EquivalentButNotEqual(t *testing.T) { - mockT := new(testing.T) - True(t, JSONEq(mockT, `{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)) -} - -func TestJSONEq_HashOfArraysAndHashes(t *testing.T) { - mockT := new(testing.T) - True(t, JSONEq(mockT, "{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}", - "{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}")) -} - -func TestJSONEq_Array(t *testing.T) { - mockT := new(testing.T) - True(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`)) -} - -func TestJSONEq_HashAndArrayNotEquivalent(t *testing.T) { - mockT := new(testing.T) - False(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`)) -} - -func TestJSONEq_HashesNotEquivalent(t *testing.T) { - mockT := new(testing.T) - False(t, JSONEq(mockT, `{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`)) -} - -func TestJSONEq_ActualIsNotJSON(t *testing.T) { - mockT := new(testing.T) - False(t, JSONEq(mockT, `{"foo": "bar"}`, "Not JSON")) -} - -func TestJSONEq_ExpectedIsNotJSON(t *testing.T) { - mockT := new(testing.T) - False(t, JSONEq(mockT, "Not JSON", `{"foo": "bar", "hello": "world"}`)) -} - -func TestJSONEq_ExpectedAndActualNotJSON(t *testing.T) { - mockT := new(testing.T) - False(t, JSONEq(mockT, "Not JSON", "Not JSON")) -} - -func TestJSONEq_ArraysOfDifferentOrder(t *testing.T) { - mockT := new(testing.T) - False(t, JSONEq(mockT, `["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`)) -} - -func TestDiff(t *testing.T) { - expected := ` - -Diff: ---- Expected -+++ Actual -@@ -1,3 +1,3 @@ - (struct { foo string }) { -- foo: (string) (len=5) "hello" -+ foo: (string) (len=3) "bar" - } -` - actual := diff( - struct{ foo string }{"hello"}, - struct{ foo string }{"bar"}, - ) - Equal(t, expected, actual) - - expected = ` - -Diff: ---- Expected -+++ Actual -@@ -2,5 +2,5 @@ - (int) 1, -- (int) 2, - (int) 3, -- (int) 4 -+ (int) 5, -+ (int) 7 - } -` - actual = diff( - []int{1, 2, 3, 4}, - []int{1, 3, 5, 7}, - ) - Equal(t, expected, actual) - - expected = ` - -Diff: ---- Expected -+++ Actual -@@ -2,4 +2,4 @@ - (int) 1, -- (int) 2, -- (int) 3 -+ (int) 3, -+ (int) 5 - } -` - actual = diff( - []int{1, 2, 3, 4}[0:3], - []int{1, 3, 5, 7}[0:3], - ) - Equal(t, expected, actual) - - expected = ` - -Diff: ---- Expected -+++ Actual -@@ -1,6 +1,6 @@ - (map[string]int) (len=4) { -- (string) (len=4) "four": (int) 4, -+ (string) (len=4) "five": (int) 5, - (string) (len=3) "one": (int) 1, -- (string) (len=5) "three": (int) 3, -- (string) (len=3) "two": (int) 2 -+ (string) (len=5) "seven": (int) 7, -+ (string) (len=5) "three": (int) 3 - } -` - - actual = diff( - map[string]int{"one": 1, "two": 2, "three": 3, "four": 4}, - map[string]int{"one": 1, "three": 3, "five": 5, "seven": 7}, - ) - Equal(t, expected, actual) -} - -func TestDiffEmptyCases(t *testing.T) { - Equal(t, "", diff(nil, nil)) - Equal(t, "", diff(struct{ foo string }{}, nil)) - Equal(t, "", diff(nil, struct{ foo string }{})) - Equal(t, "", diff(1, 2)) - Equal(t, "", diff(1, 2)) - Equal(t, "", diff([]int{1}, []bool{true})) -} - -// Ensure there are no data races -func TestDiffRace(t *testing.T) { - t.Parallel() - - expected := map[string]string{ - "a": "A", - "b": "B", - "c": "C", - } - - actual := map[string]string{ - "d": "D", - "e": "E", - "f": "F", - } - - // run diffs in parallel simulating tests with t.Parallel() - numRoutines := 10 - rChans := make([]chan string, numRoutines) - for idx := range rChans { - rChans[idx] = make(chan string) - go func(ch chan string) { - defer close(ch) - ch <- diff(expected, actual) - }(rChans[idx]) - } - - for _, ch := range rChans { - for msg := range ch { - NotZero(t, msg) // dummy assert - } - } -} - -type mockTestingT struct { -} - -func (m *mockTestingT) Errorf(format string, args ...interface{}) {} - -func TestFailNowWithPlainTestingT(t *testing.T) { - mockT := &mockTestingT{} - - Panics(t, func() { - FailNow(mockT, "failed") - }, "should panic since mockT is missing FailNow()") -} - -type mockFailNowTestingT struct { -} - -func (m *mockFailNowTestingT) Errorf(format string, args ...interface{}) {} - -func (m *mockFailNowTestingT) FailNow() {} - -func TestFailNowWithFullTestingT(t *testing.T) { - mockT := &mockFailNowTestingT{} - - NotPanics(t, func() { - FailNow(mockT, "failed") - }, "should call mockT.FailNow() rather than panicking") -} - -func TestBytesEqual(t *testing.T) { - var cases = []struct { - a, b []byte - }{ - {make([]byte, 2), make([]byte, 2)}, - {make([]byte, 2), make([]byte, 2, 3)}, - {nil, make([]byte, 0)}, - } - for i, c := range cases { - Equal(t, reflect.DeepEqual(c.a, c.b), ObjectsAreEqual(c.a, c.b), "case %d failed", i+1) - } -} - -func BenchmarkBytesEqual(b *testing.B) { - const size = 1024 * 8 - s := make([]byte, size) - for i := range s { - s[i] = byte(i % 255) - } - s2 := make([]byte, size) - copy(s2, s) - - mockT := &mockFailNowTestingT{} - b.ResetTimer() - for i := 0; i < b.N; i++ { - Equal(mockT, s, s2) - } -} - -func TestEqualArgsValidation(t *testing.T) { - err := validateEqualArgs(time.Now, time.Now) - EqualError(t, err, "cannot take func type as argument") -} - -func ExampleComparisonAssertionFunc() { - t := &testing.T{} // provided by test - - adder := func(x, y int) int { - return x + y - } - - type args struct { - x int - y int - } - - tests := []struct { - name string - args args - expect int - assertion ComparisonAssertionFunc - }{ - {"2+2=4", args{2, 2}, 4, Equal}, - {"2+2!=5", args{2, 2}, 5, NotEqual}, - {"2+3==5", args{2, 3}, 5, Exactly}, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - tt.assertion(t, tt.expect, adder(tt.args.x, tt.args.y)) - }) - } -} - -func TestComparisonAssertionFunc(t *testing.T) { - type iface interface { - Name() string - } - - tests := []struct { - name string - expect interface{} - got interface{} - assertion ComparisonAssertionFunc - }{ - {"implements", (*iface)(nil), t, Implements}, - {"isType", (*testing.T)(nil), t, IsType}, - {"equal", t, t, Equal}, - {"equalValues", t, t, EqualValues}, - {"exactly", t, t, Exactly}, - {"notEqual", t, nil, NotEqual}, - {"notContains", []int{1, 2, 3}, 4, NotContains}, - {"subset", []int{1, 2, 3, 4}, []int{2, 3}, Subset}, - {"notSubset", []int{1, 2, 3, 4}, []int{0, 3}, NotSubset}, - {"elementsMatch", []byte("abc"), []byte("bac"), ElementsMatch}, - {"regexp", "^t.*y$", "testify", Regexp}, - {"notRegexp", "^t.*y$", "Testify", NotRegexp}, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - tt.assertion(t, tt.expect, tt.got) - }) - } -} - -func ExampleValueAssertionFunc() { - t := &testing.T{} // provided by test - - dumbParse := func(input string) interface{} { - var x interface{} - json.Unmarshal([]byte(input), &x) - return x - } - - tests := []struct { - name string - arg string - assertion ValueAssertionFunc - }{ - {"true is not nil", "true", NotNil}, - {"empty string is nil", "", Nil}, - {"zero is not nil", "0", NotNil}, - {"zero is zero", "0", Zero}, - {"false is zero", "false", Zero}, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - tt.assertion(t, dumbParse(tt.arg)) - }) - } -} - -func TestValueAssertionFunc(t *testing.T) { - tests := []struct { - name string - value interface{} - assertion ValueAssertionFunc - }{ - {"notNil", true, NotNil}, - {"nil", nil, Nil}, - {"empty", []int{}, Empty}, - {"notEmpty", []int{1}, NotEmpty}, - {"zero", false, Zero}, - {"notZero", 42, NotZero}, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - tt.assertion(t, tt.value) - }) - } -} - -func ExampleBoolAssertionFunc() { - t := &testing.T{} // provided by test - - isOkay := func(x int) bool { - return x >= 42 - } - - tests := []struct { - name string - arg int - assertion BoolAssertionFunc - }{ - {"-1 is bad", -1, False}, - {"42 is good", 42, True}, - {"41 is bad", 41, False}, - {"45 is cool", 45, True}, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - tt.assertion(t, isOkay(tt.arg)) - }) - } -} - -func TestBoolAssertionFunc(t *testing.T) { - tests := []struct { - name string - value bool - assertion BoolAssertionFunc - }{ - {"true", true, True}, - {"false", false, False}, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - tt.assertion(t, tt.value) - }) - } -} - -func ExampleErrorAssertionFunc() { - t := &testing.T{} // provided by test - - dumbParseNum := func(input string, v interface{}) error { - return json.Unmarshal([]byte(input), v) - } - - tests := []struct { - name string - arg string - assertion ErrorAssertionFunc - }{ - {"1.2 is number", "1.2", NoError}, - {"1.2.3 not number", "1.2.3", Error}, - {"true is not number", "true", Error}, - {"3 is number", "3", NoError}, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - var x float64 - tt.assertion(t, dumbParseNum(tt.arg, &x)) - }) - } -} - -func TestErrorAssertionFunc(t *testing.T) { - tests := []struct { - name string - err error - assertion ErrorAssertionFunc - }{ - {"noError", nil, NoError}, - {"error", errors.New("whoops"), Error}, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - tt.assertion(t, tt.err) - }) - } -} diff --git a/vendor/github.com/stretchr/testify/assert/doc.go b/vendor/github.com/stretchr/testify/assert/doc.go deleted file mode 100644 index c9dccc4d6cd0..000000000000 --- a/vendor/github.com/stretchr/testify/assert/doc.go +++ /dev/null @@ -1,45 +0,0 @@ -// Package assert provides a set of comprehensive testing tools for use with the normal Go testing system. -// -// Example Usage -// -// The following is a complete example using assert in a standard test function: -// import ( -// "testing" -// "github.com/stretchr/testify/assert" -// ) -// -// func TestSomething(t *testing.T) { -// -// var a string = "Hello" -// var b string = "Hello" -// -// assert.Equal(t, a, b, "The two words should be the same.") -// -// } -// -// if you assert many times, use the format below: -// -// import ( -// "testing" -// "github.com/stretchr/testify/assert" -// ) -// -// func TestSomething(t *testing.T) { -// assert := assert.New(t) -// -// var a string = "Hello" -// var b string = "Hello" -// -// assert.Equal(a, b, "The two words should be the same.") -// } -// -// Assertions -// -// Assertions allow you to easily write test code, and are global funcs in the `assert` package. -// All assertion functions take, as the first argument, the `*testing.T` object provided by the -// testing framework. This allows the assertion funcs to write the failings and other details to -// the correct place. -// -// Every assertion function also takes an optional string message as the final argument, -// allowing custom error messages to be appended to the message the assertion method outputs. -package assert diff --git a/vendor/github.com/stretchr/testify/assert/errors.go b/vendor/github.com/stretchr/testify/assert/errors.go deleted file mode 100644 index ac9dc9d1d615..000000000000 --- a/vendor/github.com/stretchr/testify/assert/errors.go +++ /dev/null @@ -1,10 +0,0 @@ -package assert - -import ( - "errors" -) - -// AnError is an error instance useful for testing. If the code does not care -// about error specifics, and only needs to return the error for example, this -// error should be used to make the test code more readable. -var AnError = errors.New("assert.AnError general error for testing") diff --git a/vendor/github.com/stretchr/testify/assert/forward_assertions.go b/vendor/github.com/stretchr/testify/assert/forward_assertions.go deleted file mode 100644 index 9ad56851d971..000000000000 --- a/vendor/github.com/stretchr/testify/assert/forward_assertions.go +++ /dev/null @@ -1,16 +0,0 @@ -package assert - -// Assertions provides assertion methods around the -// TestingT interface. -type Assertions struct { - t TestingT -} - -// New makes a new Assertions object for the specified TestingT. -func New(t TestingT) *Assertions { - return &Assertions{ - t: t, - } -} - -//go:generate go run ../_codegen/main.go -output-package=assert -template=assertion_forward.go.tmpl -include-format-funcs diff --git a/vendor/github.com/stretchr/testify/assert/forward_assertions_test.go b/vendor/github.com/stretchr/testify/assert/forward_assertions_test.go deleted file mode 100644 index 22e1df1d9619..000000000000 --- a/vendor/github.com/stretchr/testify/assert/forward_assertions_test.go +++ /dev/null @@ -1,611 +0,0 @@ -package assert - -import ( - "errors" - "regexp" - "testing" - "time" -) - -func TestImplementsWrapper(t *testing.T) { - assert := New(new(testing.T)) - - if !assert.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterConformingObject)) { - t.Error("Implements method should return true: AssertionTesterConformingObject implements AssertionTesterInterface") - } - if assert.Implements((*AssertionTesterInterface)(nil), new(AssertionTesterNonConformingObject)) { - t.Error("Implements method should return false: AssertionTesterNonConformingObject does not implements AssertionTesterInterface") - } -} - -func TestIsTypeWrapper(t *testing.T) { - assert := New(new(testing.T)) - - if !assert.IsType(new(AssertionTesterConformingObject), new(AssertionTesterConformingObject)) { - t.Error("IsType should return true: AssertionTesterConformingObject is the same type as AssertionTesterConformingObject") - } - if assert.IsType(new(AssertionTesterConformingObject), new(AssertionTesterNonConformingObject)) { - t.Error("IsType should return false: AssertionTesterConformingObject is not the same type as AssertionTesterNonConformingObject") - } - -} - -func TestEqualWrapper(t *testing.T) { - assert := New(new(testing.T)) - - if !assert.Equal("Hello World", "Hello World") { - t.Error("Equal should return true") - } - if !assert.Equal(123, 123) { - t.Error("Equal should return true") - } - if !assert.Equal(123.5, 123.5) { - t.Error("Equal should return true") - } - if !assert.Equal([]byte("Hello World"), []byte("Hello World")) { - t.Error("Equal should return true") - } - if !assert.Equal(nil, nil) { - t.Error("Equal should return true") - } -} - -func TestEqualValuesWrapper(t *testing.T) { - assert := New(new(testing.T)) - - if !assert.EqualValues(uint32(10), int32(10)) { - t.Error("EqualValues should return true") - } -} - -func TestNotNilWrapper(t *testing.T) { - assert := New(new(testing.T)) - - if !assert.NotNil(new(AssertionTesterConformingObject)) { - t.Error("NotNil should return true: object is not nil") - } - if assert.NotNil(nil) { - t.Error("NotNil should return false: object is nil") - } - -} - -func TestNilWrapper(t *testing.T) { - assert := New(new(testing.T)) - - if !assert.Nil(nil) { - t.Error("Nil should return true: object is nil") - } - if assert.Nil(new(AssertionTesterConformingObject)) { - t.Error("Nil should return false: object is not nil") - } - -} - -func TestTrueWrapper(t *testing.T) { - assert := New(new(testing.T)) - - if !assert.True(true) { - t.Error("True should return true") - } - if assert.True(false) { - t.Error("True should return false") - } - -} - -func TestFalseWrapper(t *testing.T) { - assert := New(new(testing.T)) - - if !assert.False(false) { - t.Error("False should return true") - } - if assert.False(true) { - t.Error("False should return false") - } - -} - -func TestExactlyWrapper(t *testing.T) { - assert := New(new(testing.T)) - - a := float32(1) - b := float64(1) - c := float32(1) - d := float32(2) - - if assert.Exactly(a, b) { - t.Error("Exactly should return false") - } - if assert.Exactly(a, d) { - t.Error("Exactly should return false") - } - if !assert.Exactly(a, c) { - t.Error("Exactly should return true") - } - - if assert.Exactly(nil, a) { - t.Error("Exactly should return false") - } - if assert.Exactly(a, nil) { - t.Error("Exactly should return false") - } - -} - -func TestNotEqualWrapper(t *testing.T) { - - assert := New(new(testing.T)) - - if !assert.NotEqual("Hello World", "Hello World!") { - t.Error("NotEqual should return true") - } - if !assert.NotEqual(123, 1234) { - t.Error("NotEqual should return true") - } - if !assert.NotEqual(123.5, 123.55) { - t.Error("NotEqual should return true") - } - if !assert.NotEqual([]byte("Hello World"), []byte("Hello World!")) { - t.Error("NotEqual should return true") - } - if !assert.NotEqual(nil, new(AssertionTesterConformingObject)) { - t.Error("NotEqual should return true") - } -} - -func TestContainsWrapper(t *testing.T) { - - assert := New(new(testing.T)) - list := []string{"Foo", "Bar"} - - if !assert.Contains("Hello World", "Hello") { - t.Error("Contains should return true: \"Hello World\" contains \"Hello\"") - } - if assert.Contains("Hello World", "Salut") { - t.Error("Contains should return false: \"Hello World\" does not contain \"Salut\"") - } - - if !assert.Contains(list, "Foo") { - t.Error("Contains should return true: \"[\"Foo\", \"Bar\"]\" contains \"Foo\"") - } - if assert.Contains(list, "Salut") { - t.Error("Contains should return false: \"[\"Foo\", \"Bar\"]\" does not contain \"Salut\"") - } - -} - -func TestNotContainsWrapper(t *testing.T) { - - assert := New(new(testing.T)) - list := []string{"Foo", "Bar"} - - if !assert.NotContains("Hello World", "Hello!") { - t.Error("NotContains should return true: \"Hello World\" does not contain \"Hello!\"") - } - if assert.NotContains("Hello World", "Hello") { - t.Error("NotContains should return false: \"Hello World\" contains \"Hello\"") - } - - if !assert.NotContains(list, "Foo!") { - t.Error("NotContains should return true: \"[\"Foo\", \"Bar\"]\" does not contain \"Foo!\"") - } - if assert.NotContains(list, "Foo") { - t.Error("NotContains should return false: \"[\"Foo\", \"Bar\"]\" contains \"Foo\"") - } - -} - -func TestConditionWrapper(t *testing.T) { - - assert := New(new(testing.T)) - - if !assert.Condition(func() bool { return true }, "Truth") { - t.Error("Condition should return true") - } - - if assert.Condition(func() bool { return false }, "Lie") { - t.Error("Condition should return false") - } - -} - -func TestDidPanicWrapper(t *testing.T) { - - if funcDidPanic, _ := didPanic(func() { - panic("Panic!") - }); !funcDidPanic { - t.Error("didPanic should return true") - } - - if funcDidPanic, _ := didPanic(func() { - }); funcDidPanic { - t.Error("didPanic should return false") - } - -} - -func TestPanicsWrapper(t *testing.T) { - - assert := New(new(testing.T)) - - if !assert.Panics(func() { - panic("Panic!") - }) { - t.Error("Panics should return true") - } - - if assert.Panics(func() { - }) { - t.Error("Panics should return false") - } - -} - -func TestNotPanicsWrapper(t *testing.T) { - - assert := New(new(testing.T)) - - if !assert.NotPanics(func() { - }) { - t.Error("NotPanics should return true") - } - - if assert.NotPanics(func() { - panic("Panic!") - }) { - t.Error("NotPanics should return false") - } - -} - -func TestNoErrorWrapper(t *testing.T) { - assert := New(t) - mockAssert := New(new(testing.T)) - - // start with a nil error - var err error - - assert.True(mockAssert.NoError(err), "NoError should return True for nil arg") - - // now set an error - err = errors.New("Some error") - - assert.False(mockAssert.NoError(err), "NoError with error should return False") - -} - -func TestErrorWrapper(t *testing.T) { - assert := New(t) - mockAssert := New(new(testing.T)) - - // start with a nil error - var err error - - assert.False(mockAssert.Error(err), "Error should return False for nil arg") - - // now set an error - err = errors.New("Some error") - - assert.True(mockAssert.Error(err), "Error with error should return True") - -} - -func TestEqualErrorWrapper(t *testing.T) { - assert := New(t) - mockAssert := New(new(testing.T)) - - // start with a nil error - var err error - assert.False(mockAssert.EqualError(err, ""), - "EqualError should return false for nil arg") - - // now set an error - err = errors.New("some error") - assert.False(mockAssert.EqualError(err, "Not some error"), - "EqualError should return false for different error string") - assert.True(mockAssert.EqualError(err, "some error"), - "EqualError should return true") -} - -func TestEmptyWrapper(t *testing.T) { - assert := New(t) - mockAssert := New(new(testing.T)) - - assert.True(mockAssert.Empty(""), "Empty string is empty") - assert.True(mockAssert.Empty(nil), "Nil is empty") - assert.True(mockAssert.Empty([]string{}), "Empty string array is empty") - assert.True(mockAssert.Empty(0), "Zero int value is empty") - assert.True(mockAssert.Empty(false), "False value is empty") - - assert.False(mockAssert.Empty("something"), "Non Empty string is not empty") - assert.False(mockAssert.Empty(errors.New("something")), "Non nil object is not empty") - assert.False(mockAssert.Empty([]string{"something"}), "Non empty string array is not empty") - assert.False(mockAssert.Empty(1), "Non-zero int value is not empty") - assert.False(mockAssert.Empty(true), "True value is not empty") - -} - -func TestNotEmptyWrapper(t *testing.T) { - assert := New(t) - mockAssert := New(new(testing.T)) - - assert.False(mockAssert.NotEmpty(""), "Empty string is empty") - assert.False(mockAssert.NotEmpty(nil), "Nil is empty") - assert.False(mockAssert.NotEmpty([]string{}), "Empty string array is empty") - assert.False(mockAssert.NotEmpty(0), "Zero int value is empty") - assert.False(mockAssert.NotEmpty(false), "False value is empty") - - assert.True(mockAssert.NotEmpty("something"), "Non Empty string is not empty") - assert.True(mockAssert.NotEmpty(errors.New("something")), "Non nil object is not empty") - assert.True(mockAssert.NotEmpty([]string{"something"}), "Non empty string array is not empty") - assert.True(mockAssert.NotEmpty(1), "Non-zero int value is not empty") - assert.True(mockAssert.NotEmpty(true), "True value is not empty") - -} - -func TestLenWrapper(t *testing.T) { - assert := New(t) - mockAssert := New(new(testing.T)) - - assert.False(mockAssert.Len(nil, 0), "nil does not have length") - assert.False(mockAssert.Len(0, 0), "int does not have length") - assert.False(mockAssert.Len(true, 0), "true does not have length") - assert.False(mockAssert.Len(false, 0), "false does not have length") - assert.False(mockAssert.Len('A', 0), "Rune does not have length") - assert.False(mockAssert.Len(struct{}{}, 0), "Struct does not have length") - - ch := make(chan int, 5) - ch <- 1 - ch <- 2 - ch <- 3 - - cases := []struct { - v interface{} - l int - }{ - {[]int{1, 2, 3}, 3}, - {[...]int{1, 2, 3}, 3}, - {"ABC", 3}, - {map[int]int{1: 2, 2: 4, 3: 6}, 3}, - {ch, 3}, - - {[]int{}, 0}, - {map[int]int{}, 0}, - {make(chan int), 0}, - - {[]int(nil), 0}, - {map[int]int(nil), 0}, - {(chan int)(nil), 0}, - } - - for _, c := range cases { - assert.True(mockAssert.Len(c.v, c.l), "%#v have %d items", c.v, c.l) - } -} - -func TestWithinDurationWrapper(t *testing.T) { - assert := New(t) - mockAssert := New(new(testing.T)) - a := time.Now() - b := a.Add(10 * time.Second) - - assert.True(mockAssert.WithinDuration(a, b, 10*time.Second), "A 10s difference is within a 10s time difference") - assert.True(mockAssert.WithinDuration(b, a, 10*time.Second), "A 10s difference is within a 10s time difference") - - assert.False(mockAssert.WithinDuration(a, b, 9*time.Second), "A 10s difference is not within a 9s time difference") - assert.False(mockAssert.WithinDuration(b, a, 9*time.Second), "A 10s difference is not within a 9s time difference") - - assert.False(mockAssert.WithinDuration(a, b, -9*time.Second), "A 10s difference is not within a 9s time difference") - assert.False(mockAssert.WithinDuration(b, a, -9*time.Second), "A 10s difference is not within a 9s time difference") - - assert.False(mockAssert.WithinDuration(a, b, -11*time.Second), "A 10s difference is not within a 9s time difference") - assert.False(mockAssert.WithinDuration(b, a, -11*time.Second), "A 10s difference is not within a 9s time difference") -} - -func TestInDeltaWrapper(t *testing.T) { - assert := New(new(testing.T)) - - True(t, assert.InDelta(1.001, 1, 0.01), "|1.001 - 1| <= 0.01") - True(t, assert.InDelta(1, 1.001, 0.01), "|1 - 1.001| <= 0.01") - True(t, assert.InDelta(1, 2, 1), "|1 - 2| <= 1") - False(t, assert.InDelta(1, 2, 0.5), "Expected |1 - 2| <= 0.5 to fail") - False(t, assert.InDelta(2, 1, 0.5), "Expected |2 - 1| <= 0.5 to fail") - False(t, assert.InDelta("", nil, 1), "Expected non numerals to fail") - - cases := []struct { - a, b interface{} - delta float64 - }{ - {uint8(2), uint8(1), 1}, - {uint16(2), uint16(1), 1}, - {uint32(2), uint32(1), 1}, - {uint64(2), uint64(1), 1}, - - {int(2), int(1), 1}, - {int8(2), int8(1), 1}, - {int16(2), int16(1), 1}, - {int32(2), int32(1), 1}, - {int64(2), int64(1), 1}, - - {float32(2), float32(1), 1}, - {float64(2), float64(1), 1}, - } - - for _, tc := range cases { - True(t, assert.InDelta(tc.a, tc.b, tc.delta), "Expected |%V - %V| <= %v", tc.a, tc.b, tc.delta) - } -} - -func TestInEpsilonWrapper(t *testing.T) { - assert := New(new(testing.T)) - - cases := []struct { - a, b interface{} - epsilon float64 - }{ - {uint8(2), uint16(2), .001}, - {2.1, 2.2, 0.1}, - {2.2, 2.1, 0.1}, - {-2.1, -2.2, 0.1}, - {-2.2, -2.1, 0.1}, - {uint64(100), uint8(101), 0.01}, - {0.1, -0.1, 2}, - } - - for _, tc := range cases { - True(t, assert.InEpsilon(tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon)) - } - - cases = []struct { - a, b interface{} - epsilon float64 - }{ - {uint8(2), int16(-2), .001}, - {uint64(100), uint8(102), 0.01}, - {2.1, 2.2, 0.001}, - {2.2, 2.1, 0.001}, - {2.1, -2.2, 1}, - {2.1, "bla-bla", 0}, - {0.1, -0.1, 1.99}, - } - - for _, tc := range cases { - False(t, assert.InEpsilon(tc.a, tc.b, tc.epsilon, "Expected %V and %V to have a relative difference of %v", tc.a, tc.b, tc.epsilon)) - } -} - -func TestRegexpWrapper(t *testing.T) { - - assert := New(new(testing.T)) - - cases := []struct { - rx, str string - }{ - {"^start", "start of the line"}, - {"end$", "in the end"}, - {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12.34"}, - } - - for _, tc := range cases { - True(t, assert.Regexp(tc.rx, tc.str)) - True(t, assert.Regexp(regexp.MustCompile(tc.rx), tc.str)) - False(t, assert.NotRegexp(tc.rx, tc.str)) - False(t, assert.NotRegexp(regexp.MustCompile(tc.rx), tc.str)) - } - - cases = []struct { - rx, str string - }{ - {"^asdfastart", "Not the start of the line"}, - {"end$", "in the end."}, - {"[0-9]{3}[.-]?[0-9]{2}[.-]?[0-9]{2}", "My phone number is 650.12a.34"}, - } - - for _, tc := range cases { - False(t, assert.Regexp(tc.rx, tc.str), "Expected \"%s\" to not match \"%s\"", tc.rx, tc.str) - False(t, assert.Regexp(regexp.MustCompile(tc.rx), tc.str)) - True(t, assert.NotRegexp(tc.rx, tc.str)) - True(t, assert.NotRegexp(regexp.MustCompile(tc.rx), tc.str)) - } -} - -func TestZeroWrapper(t *testing.T) { - assert := New(t) - mockAssert := New(new(testing.T)) - - for _, test := range zeros { - assert.True(mockAssert.Zero(test), "Zero should return true for %v", test) - } - - for _, test := range nonZeros { - assert.False(mockAssert.Zero(test), "Zero should return false for %v", test) - } -} - -func TestNotZeroWrapper(t *testing.T) { - assert := New(t) - mockAssert := New(new(testing.T)) - - for _, test := range zeros { - assert.False(mockAssert.NotZero(test), "Zero should return true for %v", test) - } - - for _, test := range nonZeros { - assert.True(mockAssert.NotZero(test), "Zero should return false for %v", test) - } -} - -func TestJSONEqWrapper_EqualSONString(t *testing.T) { - assert := New(new(testing.T)) - if !assert.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"hello": "world", "foo": "bar"}`) { - t.Error("JSONEq should return true") - } - -} - -func TestJSONEqWrapper_EquivalentButNotEqual(t *testing.T) { - assert := New(new(testing.T)) - if !assert.JSONEq(`{"hello": "world", "foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) { - t.Error("JSONEq should return true") - } - -} - -func TestJSONEqWrapper_HashOfArraysAndHashes(t *testing.T) { - assert := New(new(testing.T)) - if !assert.JSONEq("{\r\n\t\"numeric\": 1.5,\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]],\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\"\r\n}", - "{\r\n\t\"numeric\": 1.5,\r\n\t\"hash\": {\"nested\": \"hash\", \"nested_slice\": [\"this\", \"is\", \"nested\"]},\r\n\t\"string\": \"foo\",\r\n\t\"array\": [{\"foo\": \"bar\"}, 1, \"string\", [\"nested\", \"array\", 5.5]]\r\n}") { - t.Error("JSONEq should return true") - } -} - -func TestJSONEqWrapper_Array(t *testing.T) { - assert := New(new(testing.T)) - if !assert.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `["foo", {"nested": "hash", "hello": "world"}]`) { - t.Error("JSONEq should return true") - } - -} - -func TestJSONEqWrapper_HashAndArrayNotEquivalent(t *testing.T) { - assert := New(new(testing.T)) - if assert.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `{"foo": "bar", {"nested": "hash", "hello": "world"}}`) { - t.Error("JSONEq should return false") - } -} - -func TestJSONEqWrapper_HashesNotEquivalent(t *testing.T) { - assert := New(new(testing.T)) - if assert.JSONEq(`{"foo": "bar"}`, `{"foo": "bar", "hello": "world"}`) { - t.Error("JSONEq should return false") - } -} - -func TestJSONEqWrapper_ActualIsNotJSON(t *testing.T) { - assert := New(new(testing.T)) - if assert.JSONEq(`{"foo": "bar"}`, "Not JSON") { - t.Error("JSONEq should return false") - } -} - -func TestJSONEqWrapper_ExpectedIsNotJSON(t *testing.T) { - assert := New(new(testing.T)) - if assert.JSONEq("Not JSON", `{"foo": "bar", "hello": "world"}`) { - t.Error("JSONEq should return false") - } -} - -func TestJSONEqWrapper_ExpectedAndActualNotJSON(t *testing.T) { - assert := New(new(testing.T)) - if assert.JSONEq("Not JSON", "Not JSON") { - t.Error("JSONEq should return false") - } -} - -func TestJSONEqWrapper_ArraysOfDifferentOrder(t *testing.T) { - assert := New(new(testing.T)) - if assert.JSONEq(`["foo", {"hello": "world", "nested": "hash"}]`, `[{ "hello": "world", "nested": "hash"}, "foo"]`) { - t.Error("JSONEq should return false") - } -} diff --git a/vendor/github.com/stretchr/testify/assert/http_assertions.go b/vendor/github.com/stretchr/testify/assert/http_assertions.go deleted file mode 100644 index df46fa777acb..000000000000 --- a/vendor/github.com/stretchr/testify/assert/http_assertions.go +++ /dev/null @@ -1,143 +0,0 @@ -package assert - -import ( - "fmt" - "net/http" - "net/http/httptest" - "net/url" - "strings" -) - -// httpCode is a helper that returns HTTP code of the response. It returns -1 and -// an error if building a new request fails. -func httpCode(handler http.HandlerFunc, method, url string, values url.Values) (int, error) { - w := httptest.NewRecorder() - req, err := http.NewRequest(method, url, nil) - if err != nil { - return -1, err - } - req.URL.RawQuery = values.Encode() - handler(w, req) - return w.Code, nil -} - -// HTTPSuccess asserts that a specified handler returns a success status code. -// -// assert.HTTPSuccess(t, myHandler, "POST", "http://www.google.com", nil) -// -// Returns whether the assertion was successful (true) or not (false). -func HTTPSuccess(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - code, err := httpCode(handler, method, url, values) - if err != nil { - Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err)) - return false - } - - isSuccessCode := code >= http.StatusOK && code <= http.StatusPartialContent - if !isSuccessCode { - Fail(t, fmt.Sprintf("Expected HTTP success status code for %q but received %d", url+"?"+values.Encode(), code)) - } - - return isSuccessCode -} - -// HTTPRedirect asserts that a specified handler returns a redirect status code. -// -// assert.HTTPRedirect(t, myHandler, "GET", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// -// Returns whether the assertion was successful (true) or not (false). -func HTTPRedirect(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - code, err := httpCode(handler, method, url, values) - if err != nil { - Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err)) - return false - } - - isRedirectCode := code >= http.StatusMultipleChoices && code <= http.StatusTemporaryRedirect - if !isRedirectCode { - Fail(t, fmt.Sprintf("Expected HTTP redirect status code for %q but received %d", url+"?"+values.Encode(), code)) - } - - return isRedirectCode -} - -// HTTPError asserts that a specified handler returns an error status code. -// -// assert.HTTPError(t, myHandler, "POST", "/a/b/c", url.Values{"a": []string{"b", "c"}} -// -// Returns whether the assertion was successful (true) or not (false). -func HTTPError(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - code, err := httpCode(handler, method, url, values) - if err != nil { - Fail(t, fmt.Sprintf("Failed to build test request, got error: %s", err)) - return false - } - - isErrorCode := code >= http.StatusBadRequest - if !isErrorCode { - Fail(t, fmt.Sprintf("Expected HTTP error status code for %q but received %d", url+"?"+values.Encode(), code)) - } - - return isErrorCode -} - -// HTTPBody is a helper that returns HTTP body of the response. It returns -// empty string if building a new request fails. -func HTTPBody(handler http.HandlerFunc, method, url string, values url.Values) string { - w := httptest.NewRecorder() - req, err := http.NewRequest(method, url+"?"+values.Encode(), nil) - if err != nil { - return "" - } - handler(w, req) - return w.Body.String() -} - -// HTTPBodyContains asserts that a specified handler returns a -// body that contains a string. -// -// assert.HTTPBodyContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") -// -// Returns whether the assertion was successful (true) or not (false). -func HTTPBodyContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - body := HTTPBody(handler, method, url, values) - - contains := strings.Contains(body, fmt.Sprint(str)) - if !contains { - Fail(t, fmt.Sprintf("Expected response body for \"%s\" to contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body)) - } - - return contains -} - -// HTTPBodyNotContains asserts that a specified handler returns a -// body that does not contain a string. -// -// assert.HTTPBodyNotContains(t, myHandler, "GET", "www.google.com", nil, "I'm Feeling Lucky") -// -// Returns whether the assertion was successful (true) or not (false). -func HTTPBodyNotContains(t TestingT, handler http.HandlerFunc, method, url string, values url.Values, str interface{}, msgAndArgs ...interface{}) bool { - if h, ok := t.(tHelper); ok { - h.Helper() - } - body := HTTPBody(handler, method, url, values) - - contains := strings.Contains(body, fmt.Sprint(str)) - if contains { - Fail(t, fmt.Sprintf("Expected response body for \"%s\" to NOT contain \"%s\" but found \"%s\"", url+"?"+values.Encode(), str, body)) - } - - return !contains -} diff --git a/vendor/github.com/stretchr/testify/assert/http_assertions_test.go b/vendor/github.com/stretchr/testify/assert/http_assertions_test.go deleted file mode 100644 index 112beaf6429b..000000000000 --- a/vendor/github.com/stretchr/testify/assert/http_assertions_test.go +++ /dev/null @@ -1,146 +0,0 @@ -package assert - -import ( - "fmt" - "net/http" - "net/url" - "testing" -) - -func httpOK(w http.ResponseWriter, r *http.Request) { - w.WriteHeader(http.StatusOK) -} - -func httpRedirect(w http.ResponseWriter, r *http.Request) { - w.WriteHeader(http.StatusTemporaryRedirect) -} - -func httpError(w http.ResponseWriter, r *http.Request) { - w.WriteHeader(http.StatusInternalServerError) -} - -func TestHTTPSuccess(t *testing.T) { - assert := New(t) - - mockT1 := new(testing.T) - assert.Equal(HTTPSuccess(mockT1, httpOK, "GET", "/", nil), true) - assert.False(mockT1.Failed()) - - mockT2 := new(testing.T) - assert.Equal(HTTPSuccess(mockT2, httpRedirect, "GET", "/", nil), false) - assert.True(mockT2.Failed()) - - mockT3 := new(testing.T) - assert.Equal(HTTPSuccess(mockT3, httpError, "GET", "/", nil), false) - assert.True(mockT3.Failed()) -} - -func TestHTTPRedirect(t *testing.T) { - assert := New(t) - - mockT1 := new(testing.T) - assert.Equal(HTTPRedirect(mockT1, httpOK, "GET", "/", nil), false) - assert.True(mockT1.Failed()) - - mockT2 := new(testing.T) - assert.Equal(HTTPRedirect(mockT2, httpRedirect, "GET", "/", nil), true) - assert.False(mockT2.Failed()) - - mockT3 := new(testing.T) - assert.Equal(HTTPRedirect(mockT3, httpError, "GET", "/", nil), false) - assert.True(mockT3.Failed()) -} - -func TestHTTPError(t *testing.T) { - assert := New(t) - - mockT1 := new(testing.T) - assert.Equal(HTTPError(mockT1, httpOK, "GET", "/", nil), false) - assert.True(mockT1.Failed()) - - mockT2 := new(testing.T) - assert.Equal(HTTPError(mockT2, httpRedirect, "GET", "/", nil), false) - assert.True(mockT2.Failed()) - - mockT3 := new(testing.T) - assert.Equal(HTTPError(mockT3, httpError, "GET", "/", nil), true) - assert.False(mockT3.Failed()) -} - -func TestHTTPStatusesWrapper(t *testing.T) { - assert := New(t) - mockAssert := New(new(testing.T)) - - assert.Equal(mockAssert.HTTPSuccess(httpOK, "GET", "/", nil), true) - assert.Equal(mockAssert.HTTPSuccess(httpRedirect, "GET", "/", nil), false) - assert.Equal(mockAssert.HTTPSuccess(httpError, "GET", "/", nil), false) - - assert.Equal(mockAssert.HTTPRedirect(httpOK, "GET", "/", nil), false) - assert.Equal(mockAssert.HTTPRedirect(httpRedirect, "GET", "/", nil), true) - assert.Equal(mockAssert.HTTPRedirect(httpError, "GET", "/", nil), false) - - assert.Equal(mockAssert.HTTPError(httpOK, "GET", "/", nil), false) - assert.Equal(mockAssert.HTTPError(httpRedirect, "GET", "/", nil), false) - assert.Equal(mockAssert.HTTPError(httpError, "GET", "/", nil), true) -} - -func httpHelloName(w http.ResponseWriter, r *http.Request) { - name := r.FormValue("name") - w.Write([]byte(fmt.Sprintf("Hello, %s!", name))) -} - -func TestHTTPRequestWithNoParams(t *testing.T) { - var got *http.Request - handler := func(w http.ResponseWriter, r *http.Request) { - got = r - w.WriteHeader(http.StatusOK) - } - - True(t, HTTPSuccess(t, handler, "GET", "/url", nil)) - - Empty(t, got.URL.Query()) - Equal(t, "/url", got.URL.RequestURI()) -} - -func TestHTTPRequestWithParams(t *testing.T) { - var got *http.Request - handler := func(w http.ResponseWriter, r *http.Request) { - got = r - w.WriteHeader(http.StatusOK) - } - params := url.Values{} - params.Add("id", "12345") - - True(t, HTTPSuccess(t, handler, "GET", "/url", params)) - - Equal(t, url.Values{"id": []string{"12345"}}, got.URL.Query()) - Equal(t, "/url?id=12345", got.URL.String()) - Equal(t, "/url?id=12345", got.URL.RequestURI()) -} - -func TestHttpBody(t *testing.T) { - assert := New(t) - mockT := new(testing.T) - - assert.True(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!")) - assert.True(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World")) - assert.False(HTTPBodyContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world")) - - assert.False(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!")) - assert.False(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World")) - assert.True(HTTPBodyNotContains(mockT, httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world")) -} - -func TestHttpBodyWrappers(t *testing.T) { - assert := New(t) - mockAssert := New(new(testing.T)) - - assert.True(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!")) - assert.True(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World")) - assert.False(mockAssert.HTTPBodyContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world")) - - assert.False(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "Hello, World!")) - assert.False(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "World")) - assert.True(mockAssert.HTTPBodyNotContains(httpHelloName, "GET", "/", url.Values{"name": []string{"World"}}, "world")) - -} diff --git a/vendor/gopkg.in/ini.v1/.gitignore b/vendor/gopkg.in/ini.v1/.gitignore new file mode 100644 index 000000000000..12411127b39e --- /dev/null +++ b/vendor/gopkg.in/ini.v1/.gitignore @@ -0,0 +1,6 @@ +testdata/conf_out.ini +ini.sublime-project +ini.sublime-workspace +testdata/conf_reflect.ini +.idea +/.vscode diff --git a/vendor/gopkg.in/ini.v1/.travis.yml b/vendor/gopkg.in/ini.v1/.travis.yml new file mode 100644 index 000000000000..c8ea49ccc623 --- /dev/null +++ b/vendor/gopkg.in/ini.v1/.travis.yml @@ -0,0 +1,17 @@ +sudo: false +language: go +go: + - 1.6.x + - 1.7.x + - 1.8.x + - 1.9.x + - 1.10.x + - 1.11.x + +script: + - go get golang.org/x/tools/cmd/cover + - go get github.com/smartystreets/goconvey + - mkdir -p $HOME/gopath/src/gopkg.in + - ln -s $HOME/gopath/src/github.com/go-ini/ini $HOME/gopath/src/gopkg.in/ini.v1 + - cd $HOME/gopath/src/gopkg.in/ini.v1 + - go test -v -cover -race diff --git a/vendor/gopkg.in/ini.v1/LICENSE b/vendor/gopkg.in/ini.v1/LICENSE new file mode 100644 index 000000000000..d361bbcdf5c9 --- /dev/null +++ b/vendor/gopkg.in/ini.v1/LICENSE @@ -0,0 +1,191 @@ +Apache License +Version 2.0, January 2004 +http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + +"License" shall mean the terms and conditions for use, reproduction, and +distribution as defined by Sections 1 through 9 of this document. + +"Licensor" shall mean the copyright owner or entity authorized by the copyright +owner that is granting the License. + +"Legal Entity" shall mean the union of the acting entity and all other entities +that control, are controlled by, or are under common control with that entity. +For the purposes of this definition, "control" means (i) the power, direct or +indirect, to cause the direction or management of such entity, whether by +contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the +outstanding shares, or (iii) beneficial ownership of such entity. + +"You" (or "Your") shall mean an individual or Legal Entity exercising +permissions granted by this License. + +"Source" form shall mean the preferred form for making modifications, including +but not limited to software source code, documentation source, and configuration +files. + +"Object" form shall mean any form resulting from mechanical transformation or +translation of a Source form, including but not limited to compiled object code, +generated documentation, and conversions to other media types. + +"Work" shall mean the work of authorship, whether in Source or Object form, made +available under the License, as indicated by a copyright notice that is included +in or attached to the work (an example is provided in the Appendix below). + +"Derivative Works" shall mean any work, whether in Source or Object form, that +is based on (or derived from) the Work and for which the editorial revisions, +annotations, elaborations, or other modifications represent, as a whole, an +original work of authorship. For the purposes of this License, Derivative Works +shall not include works that remain separable from, or merely link (or bind by +name) to the interfaces of, the Work and Derivative Works thereof. + +"Contribution" shall mean any work of authorship, including the original version +of the Work and any modifications or additions to that Work or Derivative Works +thereof, that is intentionally submitted to Licensor for inclusion in the Work +by the copyright owner or by an individual or Legal Entity authorized to submit +on behalf of the copyright owner. For the purposes of this definition, +"submitted" means any form of electronic, verbal, or written communication sent +to the Licensor or its representatives, including but not limited to +communication on electronic mailing lists, source code control systems, and +issue tracking systems that are managed by, or on behalf of, the Licensor for +the purpose of discussing and improving the Work, but excluding communication +that is conspicuously marked or otherwise designated in writing by the copyright +owner as "Not a Contribution." + +"Contributor" shall mean Licensor and any individual or Legal Entity on behalf +of whom a Contribution has been received by Licensor and subsequently +incorporated within the Work. + +2. Grant of Copyright License. + +Subject to the terms and conditions of this License, each Contributor hereby +grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, +irrevocable copyright license to reproduce, prepare Derivative Works of, +publicly display, publicly perform, sublicense, and distribute the Work and such +Derivative Works in Source or Object form. + +3. Grant of Patent License. + +Subject to the terms and conditions of this License, each Contributor hereby +grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, +irrevocable (except as stated in this section) patent license to make, have +made, use, offer to sell, sell, import, and otherwise transfer the Work, where +such license applies only to those patent claims licensable by such Contributor +that are necessarily infringed by their Contribution(s) alone or by combination +of their Contribution(s) with the Work to which such Contribution(s) was +submitted. If You institute patent litigation against any entity (including a +cross-claim or counterclaim in a lawsuit) alleging that the Work or a +Contribution incorporated within the Work constitutes direct or contributory +patent infringement, then any patent licenses granted to You under this License +for that Work shall terminate as of the date such litigation is filed. + +4. Redistribution. + +You may reproduce and distribute copies of the Work or Derivative Works thereof +in any medium, with or without modifications, and in Source or Object form, +provided that You meet the following conditions: + +You must give any other recipients of the Work or Derivative Works a copy of +this License; and +You must cause any modified files to carry prominent notices stating that You +changed the files; and +You must retain, in the Source form of any Derivative Works that You distribute, +all copyright, patent, trademark, and attribution notices from the Source form +of the Work, excluding those notices that do not pertain to any part of the +Derivative Works; and +If the Work includes a "NOTICE" text file as part of its distribution, then any +Derivative Works that You distribute must include a readable copy of the +attribution notices contained within such NOTICE file, excluding those notices +that do not pertain to any part of the Derivative Works, in at least one of the +following places: within a NOTICE text file distributed as part of the +Derivative Works; within the Source form or documentation, if provided along +with the Derivative Works; or, within a display generated by the Derivative +Works, if and wherever such third-party notices normally appear. The contents of +the NOTICE file are for informational purposes only and do not modify the +License. You may add Your own attribution notices within Derivative Works that +You distribute, alongside or as an addendum to the NOTICE text from the Work, +provided that such additional attribution notices cannot be construed as +modifying the License. +You may add Your own copyright statement to Your modifications and may provide +additional or different license terms and conditions for use, reproduction, or +distribution of Your modifications, or for any such Derivative Works as a whole, +provided Your use, reproduction, and distribution of the Work otherwise complies +with the conditions stated in this License. + +5. Submission of Contributions. + +Unless You explicitly state otherwise, any Contribution intentionally submitted +for inclusion in the Work by You to the Licensor shall be under the terms and +conditions of this License, without any additional terms or conditions. +Notwithstanding the above, nothing herein shall supersede or modify the terms of +any separate license agreement you may have executed with Licensor regarding +such Contributions. + +6. Trademarks. + +This License does not grant permission to use the trade names, trademarks, +service marks, or product names of the Licensor, except as required for +reasonable and customary use in describing the origin of the Work and +reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. + +Unless required by applicable law or agreed to in writing, Licensor provides the +Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, +including, without limitation, any warranties or conditions of TITLE, +NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are +solely responsible for determining the appropriateness of using or +redistributing the Work and assume any risks associated with Your exercise of +permissions under this License. + +8. Limitation of Liability. + +In no event and under no legal theory, whether in tort (including negligence), +contract, or otherwise, unless required by applicable law (such as deliberate +and grossly negligent acts) or agreed to in writing, shall any Contributor be +liable to You for damages, including any direct, indirect, special, incidental, +or consequential damages of any character arising as a result of this License or +out of the use or inability to use the Work (including but not limited to +damages for loss of goodwill, work stoppage, computer failure or malfunction, or +any and all other commercial damages or losses), even if such Contributor has +been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. + +While redistributing the Work or Derivative Works thereof, You may choose to +offer, and charge a fee for, acceptance of support, warranty, indemnity, or +other liability obligations and/or rights consistent with this License. However, +in accepting such obligations, You may act only on Your own behalf and on Your +sole responsibility, not on behalf of any other Contributor, and only if You +agree to indemnify, defend, and hold each Contributor harmless for any liability +incurred by, or claims asserted against, such Contributor by reason of your +accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work + +To apply the Apache License to your work, attach the following boilerplate +notice, with the fields enclosed by brackets "[]" replaced with your own +identifying information. (Don't include the brackets!) The text should be +enclosed in the appropriate comment syntax for the file format. We also +recommend that a file or class name and description of purpose be included on +the same "printed page" as the copyright notice for easier identification within +third-party archives. + + Copyright 2014 Unknwon + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/vendor/gopkg.in/ini.v1/Makefile b/vendor/gopkg.in/ini.v1/Makefile new file mode 100644 index 000000000000..af27ff0768fa --- /dev/null +++ b/vendor/gopkg.in/ini.v1/Makefile @@ -0,0 +1,15 @@ +.PHONY: build test bench vet coverage + +build: vet bench + +test: + go test -v -cover -race + +bench: + go test -v -cover -race -test.bench=. -test.benchmem + +vet: + go vet + +coverage: + go test -coverprofile=c.out && go tool cover -html=c.out && rm c.out diff --git a/vendor/gopkg.in/ini.v1/README.md b/vendor/gopkg.in/ini.v1/README.md new file mode 100644 index 000000000000..ae4dfc3a5a82 --- /dev/null +++ b/vendor/gopkg.in/ini.v1/README.md @@ -0,0 +1,46 @@ +INI [![Build Status](https://travis-ci.org/go-ini/ini.svg?branch=master)](https://travis-ci.org/go-ini/ini) [![Sourcegraph](https://img.shields.io/badge/view%20on-Sourcegraph-brightgreen.svg)](https://sourcegraph.com/github.com/go-ini/ini) +=== + +![](https://avatars0.githubusercontent.com/u/10216035?v=3&s=200) + +Package ini provides INI file read and write functionality in Go. + +## Features + +- Load from multiple data sources(`[]byte`, file and `io.ReadCloser`) with overwrites. +- Read with recursion values. +- Read with parent-child sections. +- Read with auto-increment key names. +- Read with multiple-line values. +- Read with tons of helper methods. +- Read and convert values to Go types. +- Read and **WRITE** comments of sections and keys. +- Manipulate sections, keys and comments with ease. +- Keep sections and keys in order as you parse and save. + +## Installation + +The minimum requirement of Go is **1.6**. + +To use a tagged revision: + +```sh +$ go get gopkg.in/ini.v1 +``` + +To use with latest changes: + +```sh +$ go get github.com/go-ini/ini +``` + +Please add `-u` flag to update in the future. + +## Getting Help + +- [Getting Started](https://ini.unknwon.io/docs/intro/getting_started) +- [API Documentation](https://gowalker.org/gopkg.in/ini.v1) + +## License + +This project is under Apache v2 License. See the [LICENSE](LICENSE) file for the full license text. diff --git a/vendor/gopkg.in/ini.v1/error.go b/vendor/gopkg.in/ini.v1/error.go new file mode 100644 index 000000000000..80afe7431584 --- /dev/null +++ b/vendor/gopkg.in/ini.v1/error.go @@ -0,0 +1,32 @@ +// Copyright 2016 Unknwon +// +// Licensed under the Apache License, Version 2.0 (the "License"): you may +// not use this file except in compliance with the License. You may obtain +// a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +// License for the specific language governing permissions and limitations +// under the License. + +package ini + +import ( + "fmt" +) + +type ErrDelimiterNotFound struct { + Line string +} + +func IsErrDelimiterNotFound(err error) bool { + _, ok := err.(ErrDelimiterNotFound) + return ok +} + +func (err ErrDelimiterNotFound) Error() string { + return fmt.Sprintf("key-value delimiter not found: %s", err.Line) +} diff --git a/vendor/gopkg.in/ini.v1/file.go b/vendor/gopkg.in/ini.v1/file.go new file mode 100644 index 000000000000..0ed0eafd0298 --- /dev/null +++ b/vendor/gopkg.in/ini.v1/file.go @@ -0,0 +1,418 @@ +// Copyright 2017 Unknwon +// +// Licensed under the Apache License, Version 2.0 (the "License"): you may +// not use this file except in compliance with the License. You may obtain +// a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +// License for the specific language governing permissions and limitations +// under the License. + +package ini + +import ( + "bytes" + "errors" + "fmt" + "io" + "io/ioutil" + "os" + "strings" + "sync" +) + +// File represents a combination of a or more INI file(s) in memory. +type File struct { + options LoadOptions + dataSources []dataSource + + // Should make things safe, but sometimes doesn't matter. + BlockMode bool + lock sync.RWMutex + + // To keep data in order. + sectionList []string + // Actual data is stored here. + sections map[string]*Section + + NameMapper + ValueMapper +} + +// newFile initializes File object with given data sources. +func newFile(dataSources []dataSource, opts LoadOptions) *File { + if len(opts.KeyValueDelimiters) == 0 { + opts.KeyValueDelimiters = "=:" + } + return &File{ + BlockMode: true, + dataSources: dataSources, + sections: make(map[string]*Section), + sectionList: make([]string, 0, 10), + options: opts, + } +} + +// Empty returns an empty file object. +func Empty() *File { + // Ignore error here, we sure our data is good. + f, _ := Load([]byte("")) + return f +} + +// NewSection creates a new section. +func (f *File) NewSection(name string) (*Section, error) { + if len(name) == 0 { + return nil, errors.New("error creating new section: empty section name") + } else if f.options.Insensitive && name != DEFAULT_SECTION { + name = strings.ToLower(name) + } + + if f.BlockMode { + f.lock.Lock() + defer f.lock.Unlock() + } + + if inSlice(name, f.sectionList) { + return f.sections[name], nil + } + + f.sectionList = append(f.sectionList, name) + f.sections[name] = newSection(f, name) + return f.sections[name], nil +} + +// NewRawSection creates a new section with an unparseable body. +func (f *File) NewRawSection(name, body string) (*Section, error) { + section, err := f.NewSection(name) + if err != nil { + return nil, err + } + + section.isRawSection = true + section.rawBody = body + return section, nil +} + +// NewSections creates a list of sections. +func (f *File) NewSections(names ...string) (err error) { + for _, name := range names { + if _, err = f.NewSection(name); err != nil { + return err + } + } + return nil +} + +// GetSection returns section by given name. +func (f *File) GetSection(name string) (*Section, error) { + if len(name) == 0 { + name = DEFAULT_SECTION + } + if f.options.Insensitive { + name = strings.ToLower(name) + } + + if f.BlockMode { + f.lock.RLock() + defer f.lock.RUnlock() + } + + sec := f.sections[name] + if sec == nil { + return nil, fmt.Errorf("section '%s' does not exist", name) + } + return sec, nil +} + +// Section assumes named section exists and returns a zero-value when not. +func (f *File) Section(name string) *Section { + sec, err := f.GetSection(name) + if err != nil { + // Note: It's OK here because the only possible error is empty section name, + // but if it's empty, this piece of code won't be executed. + sec, _ = f.NewSection(name) + return sec + } + return sec +} + +// Section returns list of Section. +func (f *File) Sections() []*Section { + if f.BlockMode { + f.lock.RLock() + defer f.lock.RUnlock() + } + + sections := make([]*Section, len(f.sectionList)) + for i, name := range f.sectionList { + sections[i] = f.sections[name] + } + return sections +} + +// ChildSections returns a list of child sections of given section name. +func (f *File) ChildSections(name string) []*Section { + return f.Section(name).ChildSections() +} + +// SectionStrings returns list of section names. +func (f *File) SectionStrings() []string { + list := make([]string, len(f.sectionList)) + copy(list, f.sectionList) + return list +} + +// DeleteSection deletes a section. +func (f *File) DeleteSection(name string) { + if f.BlockMode { + f.lock.Lock() + defer f.lock.Unlock() + } + + if len(name) == 0 { + name = DEFAULT_SECTION + } + + for i, s := range f.sectionList { + if s == name { + f.sectionList = append(f.sectionList[:i], f.sectionList[i+1:]...) + delete(f.sections, name) + return + } + } +} + +func (f *File) reload(s dataSource) error { + r, err := s.ReadCloser() + if err != nil { + return err + } + defer r.Close() + + return f.parse(r) +} + +// Reload reloads and parses all data sources. +func (f *File) Reload() (err error) { + for _, s := range f.dataSources { + if err = f.reload(s); err != nil { + // In loose mode, we create an empty default section for nonexistent files. + if os.IsNotExist(err) && f.options.Loose { + f.parse(bytes.NewBuffer(nil)) + continue + } + return err + } + } + return nil +} + +// Append appends one or more data sources and reloads automatically. +func (f *File) Append(source interface{}, others ...interface{}) error { + ds, err := parseDataSource(source) + if err != nil { + return err + } + f.dataSources = append(f.dataSources, ds) + for _, s := range others { + ds, err = parseDataSource(s) + if err != nil { + return err + } + f.dataSources = append(f.dataSources, ds) + } + return f.Reload() +} + +func (f *File) writeToBuffer(indent string) (*bytes.Buffer, error) { + equalSign := DefaultFormatLeft + "=" + DefaultFormatRight + + if PrettyFormat || PrettyEqual { + equalSign = " = " + } + + // Use buffer to make sure target is safe until finish encoding. + buf := bytes.NewBuffer(nil) + for i, sname := range f.sectionList { + sec := f.Section(sname) + if len(sec.Comment) > 0 { + // Support multiline comments + lines := strings.Split(sec.Comment, LineBreak) + for i := range lines { + if lines[i][0] != '#' && lines[i][0] != ';' { + lines[i] = "; " + lines[i] + } else { + lines[i] = lines[i][:1] + " " + strings.TrimSpace(lines[i][1:]) + } + + if _, err := buf.WriteString(lines[i] + LineBreak); err != nil { + return nil, err + } + } + } + + if i > 0 || DefaultHeader { + if _, err := buf.WriteString("[" + sname + "]" + LineBreak); err != nil { + return nil, err + } + } else { + // Write nothing if default section is empty + if len(sec.keyList) == 0 { + continue + } + } + + if sec.isRawSection { + if _, err := buf.WriteString(sec.rawBody); err != nil { + return nil, err + } + + if PrettySection { + // Put a line between sections + if _, err := buf.WriteString(LineBreak); err != nil { + return nil, err + } + } + continue + } + + // Count and generate alignment length and buffer spaces using the + // longest key. Keys may be modifed if they contain certain characters so + // we need to take that into account in our calculation. + alignLength := 0 + if PrettyFormat { + for _, kname := range sec.keyList { + keyLength := len(kname) + // First case will surround key by ` and second by """ + if strings.Contains(kname, "\"") || strings.ContainsAny(kname, f.options.KeyValueDelimiters) { + keyLength += 2 + } else if strings.Contains(kname, "`") { + keyLength += 6 + } + + if keyLength > alignLength { + alignLength = keyLength + } + } + } + alignSpaces := bytes.Repeat([]byte(" "), alignLength) + + KEY_LIST: + for _, kname := range sec.keyList { + key := sec.Key(kname) + if len(key.Comment) > 0 { + if len(indent) > 0 && sname != DEFAULT_SECTION { + buf.WriteString(indent) + } + + // Support multiline comments + lines := strings.Split(key.Comment, LineBreak) + for i := range lines { + if lines[i][0] != '#' && lines[i][0] != ';' { + lines[i] = "; " + strings.TrimSpace(lines[i]) + } else { + lines[i] = lines[i][:1] + " " + strings.TrimSpace(lines[i][1:]) + } + + if _, err := buf.WriteString(lines[i] + LineBreak); err != nil { + return nil, err + } + } + } + + if len(indent) > 0 && sname != DEFAULT_SECTION { + buf.WriteString(indent) + } + + switch { + case key.isAutoIncrement: + kname = "-" + case strings.Contains(kname, "\"") || strings.ContainsAny(kname, f.options.KeyValueDelimiters): + kname = "`" + kname + "`" + case strings.Contains(kname, "`"): + kname = `"""` + kname + `"""` + } + + for _, val := range key.ValueWithShadows() { + if _, err := buf.WriteString(kname); err != nil { + return nil, err + } + + if key.isBooleanType { + if kname != sec.keyList[len(sec.keyList)-1] { + buf.WriteString(LineBreak) + } + continue KEY_LIST + } + + // Write out alignment spaces before "=" sign + if PrettyFormat { + buf.Write(alignSpaces[:alignLength-len(kname)]) + } + + // In case key value contains "\n", "`", "\"", "#" or ";" + if strings.ContainsAny(val, "\n`") { + val = `"""` + val + `"""` + } else if !f.options.IgnoreInlineComment && strings.ContainsAny(val, "#;") { + val = "`" + val + "`" + } + if _, err := buf.WriteString(equalSign + val + LineBreak); err != nil { + return nil, err + } + } + + for _, val := range key.nestedValues { + if _, err := buf.WriteString(indent + " " + val + LineBreak); err != nil { + return nil, err + } + } + } + + if PrettySection { + // Put a line between sections + if _, err := buf.WriteString(LineBreak); err != nil { + return nil, err + } + } + } + + return buf, nil +} + +// WriteToIndent writes content into io.Writer with given indention. +// If PrettyFormat has been set to be true, +// it will align "=" sign with spaces under each section. +func (f *File) WriteToIndent(w io.Writer, indent string) (int64, error) { + buf, err := f.writeToBuffer(indent) + if err != nil { + return 0, err + } + return buf.WriteTo(w) +} + +// WriteTo writes file content into io.Writer. +func (f *File) WriteTo(w io.Writer) (int64, error) { + return f.WriteToIndent(w, "") +} + +// SaveToIndent writes content to file system with given value indention. +func (f *File) SaveToIndent(filename, indent string) error { + // Note: Because we are truncating with os.Create, + // so it's safer to save to a temporary file location and rename afte done. + buf, err := f.writeToBuffer(indent) + if err != nil { + return err + } + + return ioutil.WriteFile(filename, buf.Bytes(), 0666) +} + +// SaveTo writes content to file system. +func (f *File) SaveTo(filename string) error { + return f.SaveToIndent(filename, "") +} diff --git a/vendor/gopkg.in/ini.v1/ini.go b/vendor/gopkg.in/ini.v1/ini.go new file mode 100644 index 000000000000..f827a1ef99f1 --- /dev/null +++ b/vendor/gopkg.in/ini.v1/ini.go @@ -0,0 +1,219 @@ +// +build go1.6 + +// Copyright 2014 Unknwon +// +// Licensed under the Apache License, Version 2.0 (the "License"): you may +// not use this file except in compliance with the License. You may obtain +// a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +// License for the specific language governing permissions and limitations +// under the License. + +// Package ini provides INI file read and write functionality in Go. +package ini + +import ( + "bytes" + "fmt" + "io" + "io/ioutil" + "os" + "regexp" + "runtime" +) + +const ( + // Name for default section. You can use this constant or the string literal. + // In most of cases, an empty string is all you need to access the section. + DEFAULT_SECTION = "DEFAULT" + + // Maximum allowed depth when recursively substituing variable names. + _DEPTH_VALUES = 99 + _VERSION = "1.42.0" +) + +// Version returns current package version literal. +func Version() string { + return _VERSION +} + +var ( + // Delimiter to determine or compose a new line. + // This variable will be changed to "\r\n" automatically on Windows + // at package init time. + LineBreak = "\n" + + // Place custom spaces when PrettyFormat and PrettyEqual are both disabled + DefaultFormatLeft = "" + DefaultFormatRight = "" + + // Variable regexp pattern: %(variable)s + varPattern = regexp.MustCompile(`%\(([^\)]+)\)s`) + + // Indicate whether to align "=" sign with spaces to produce pretty output + // or reduce all possible spaces for compact format. + PrettyFormat = true + + // Place spaces around "=" sign even when PrettyFormat is false + PrettyEqual = false + + // Explicitly write DEFAULT section header + DefaultHeader = false + + // Indicate whether to put a line between sections + PrettySection = true +) + +func init() { + if runtime.GOOS == "windows" { + LineBreak = "\r\n" + } +} + +func inSlice(str string, s []string) bool { + for _, v := range s { + if str == v { + return true + } + } + return false +} + +// dataSource is an interface that returns object which can be read and closed. +type dataSource interface { + ReadCloser() (io.ReadCloser, error) +} + +// sourceFile represents an object that contains content on the local file system. +type sourceFile struct { + name string +} + +func (s sourceFile) ReadCloser() (_ io.ReadCloser, err error) { + return os.Open(s.name) +} + +// sourceData represents an object that contains content in memory. +type sourceData struct { + data []byte +} + +func (s *sourceData) ReadCloser() (io.ReadCloser, error) { + return ioutil.NopCloser(bytes.NewReader(s.data)), nil +} + +// sourceReadCloser represents an input stream with Close method. +type sourceReadCloser struct { + reader io.ReadCloser +} + +func (s *sourceReadCloser) ReadCloser() (io.ReadCloser, error) { + return s.reader, nil +} + +func parseDataSource(source interface{}) (dataSource, error) { + switch s := source.(type) { + case string: + return sourceFile{s}, nil + case []byte: + return &sourceData{s}, nil + case io.ReadCloser: + return &sourceReadCloser{s}, nil + default: + return nil, fmt.Errorf("error parsing data source: unknown type '%s'", s) + } +} + +type LoadOptions struct { + // Loose indicates whether the parser should ignore nonexistent files or return error. + Loose bool + // Insensitive indicates whether the parser forces all section and key names to lowercase. + Insensitive bool + // IgnoreContinuation indicates whether to ignore continuation lines while parsing. + IgnoreContinuation bool + // IgnoreInlineComment indicates whether to ignore comments at the end of value and treat it as part of value. + IgnoreInlineComment bool + // SkipUnrecognizableLines indicates whether to skip unrecognizable lines that do not conform to key/value pairs. + SkipUnrecognizableLines bool + // AllowBooleanKeys indicates whether to allow boolean type keys or treat as value is missing. + // This type of keys are mostly used in my.cnf. + AllowBooleanKeys bool + // AllowShadows indicates whether to keep track of keys with same name under same section. + AllowShadows bool + // AllowNestedValues indicates whether to allow AWS-like nested values. + // Docs: http://docs.aws.amazon.com/cli/latest/topic/config-vars.html#nested-values + AllowNestedValues bool + // AllowPythonMultilineValues indicates whether to allow Python-like multi-line values. + // Docs: https://docs.python.org/3/library/configparser.html#supported-ini-file-structure + // Relevant quote: Values can also span multiple lines, as long as they are indented deeper + // than the first line of the value. + AllowPythonMultilineValues bool + // SpaceBeforeInlineComment indicates whether to allow comment symbols (\# and \;) inside value. + // Docs: https://docs.python.org/2/library/configparser.html + // Quote: Comments may appear on their own in an otherwise empty line, or may be entered in lines holding values or section names. + // In the latter case, they need to be preceded by a whitespace character to be recognized as a comment. + SpaceBeforeInlineComment bool + // UnescapeValueDoubleQuotes indicates whether to unescape double quotes inside value to regular format + // when value is surrounded by double quotes, e.g. key="a \"value\"" => key=a "value" + UnescapeValueDoubleQuotes bool + // UnescapeValueCommentSymbols indicates to unescape comment symbols (\# and \;) inside value to regular format + // when value is NOT surrounded by any quotes. + // Note: UNSTABLE, behavior might change to only unescape inside double quotes but may noy necessary at all. + UnescapeValueCommentSymbols bool + // UnparseableSections stores a list of blocks that are allowed with raw content which do not otherwise + // conform to key/value pairs. Specify the names of those blocks here. + UnparseableSections []string + // KeyValueDelimiters is the sequence of delimiters that are used to separate key and value. By default, it is "=:". + KeyValueDelimiters string + // PreserveSurroundedQuote indicates whether to preserve surrounded quote (single and double quotes). + PreserveSurroundedQuote bool +} + +func LoadSources(opts LoadOptions, source interface{}, others ...interface{}) (_ *File, err error) { + sources := make([]dataSource, len(others)+1) + sources[0], err = parseDataSource(source) + if err != nil { + return nil, err + } + for i := range others { + sources[i+1], err = parseDataSource(others[i]) + if err != nil { + return nil, err + } + } + f := newFile(sources, opts) + if err = f.Reload(); err != nil { + return nil, err + } + return f, nil +} + +// Load loads and parses from INI data sources. +// Arguments can be mixed of file name with string type, or raw data in []byte. +// It will return error if list contains nonexistent files. +func Load(source interface{}, others ...interface{}) (*File, error) { + return LoadSources(LoadOptions{}, source, others...) +} + +// LooseLoad has exactly same functionality as Load function +// except it ignores nonexistent files instead of returning error. +func LooseLoad(source interface{}, others ...interface{}) (*File, error) { + return LoadSources(LoadOptions{Loose: true}, source, others...) +} + +// InsensitiveLoad has exactly same functionality as Load function +// except it forces all section and key names to be lowercased. +func InsensitiveLoad(source interface{}, others ...interface{}) (*File, error) { + return LoadSources(LoadOptions{Insensitive: true}, source, others...) +} + +// ShadowLoad has exactly same functionality as Load function +// except it allows have shadow keys. +func ShadowLoad(source interface{}, others ...interface{}) (*File, error) { + return LoadSources(LoadOptions{AllowShadows: true}, source, others...) +} diff --git a/vendor/gopkg.in/ini.v1/key.go b/vendor/gopkg.in/ini.v1/key.go new file mode 100644 index 000000000000..0fee0dc7e407 --- /dev/null +++ b/vendor/gopkg.in/ini.v1/key.go @@ -0,0 +1,752 @@ +// Copyright 2014 Unknwon +// +// Licensed under the Apache License, Version 2.0 (the "License"): you may +// not use this file except in compliance with the License. You may obtain +// a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +// License for the specific language governing permissions and limitations +// under the License. + +package ini + +import ( + "bytes" + "errors" + "fmt" + "strconv" + "strings" + "time" +) + +// Key represents a key under a section. +type Key struct { + s *Section + Comment string + name string + value string + isAutoIncrement bool + isBooleanType bool + + isShadow bool + shadows []*Key + + nestedValues []string +} + +// newKey simply return a key object with given values. +func newKey(s *Section, name, val string) *Key { + return &Key{ + s: s, + name: name, + value: val, + } +} + +func (k *Key) addShadow(val string) error { + if k.isShadow { + return errors.New("cannot add shadow to another shadow key") + } else if k.isAutoIncrement || k.isBooleanType { + return errors.New("cannot add shadow to auto-increment or boolean key") + } + + shadow := newKey(k.s, k.name, val) + shadow.isShadow = true + k.shadows = append(k.shadows, shadow) + return nil +} + +// AddShadow adds a new shadow key to itself. +func (k *Key) AddShadow(val string) error { + if !k.s.f.options.AllowShadows { + return errors.New("shadow key is not allowed") + } + return k.addShadow(val) +} + +func (k *Key) addNestedValue(val string) error { + if k.isAutoIncrement || k.isBooleanType { + return errors.New("cannot add nested value to auto-increment or boolean key") + } + + k.nestedValues = append(k.nestedValues, val) + return nil +} + +func (k *Key) AddNestedValue(val string) error { + if !k.s.f.options.AllowNestedValues { + return errors.New("nested value is not allowed") + } + return k.addNestedValue(val) +} + +// ValueMapper represents a mapping function for values, e.g. os.ExpandEnv +type ValueMapper func(string) string + +// Name returns name of key. +func (k *Key) Name() string { + return k.name +} + +// Value returns raw value of key for performance purpose. +func (k *Key) Value() string { + return k.value +} + +// ValueWithShadows returns raw values of key and its shadows if any. +func (k *Key) ValueWithShadows() []string { + if len(k.shadows) == 0 { + return []string{k.value} + } + vals := make([]string, len(k.shadows)+1) + vals[0] = k.value + for i := range k.shadows { + vals[i+1] = k.shadows[i].value + } + return vals +} + +// NestedValues returns nested values stored in the key. +// It is possible returned value is nil if no nested values stored in the key. +func (k *Key) NestedValues() []string { + return k.nestedValues +} + +// transformValue takes a raw value and transforms to its final string. +func (k *Key) transformValue(val string) string { + if k.s.f.ValueMapper != nil { + val = k.s.f.ValueMapper(val) + } + + // Fail-fast if no indicate char found for recursive value + if !strings.Contains(val, "%") { + return val + } + for i := 0; i < _DEPTH_VALUES; i++ { + vr := varPattern.FindString(val) + if len(vr) == 0 { + break + } + + // Take off leading '%(' and trailing ')s'. + noption := vr[2 : len(vr)-2] + + // Search in the same section. + nk, err := k.s.GetKey(noption) + if err != nil || k == nk { + // Search again in default section. + nk, _ = k.s.f.Section("").GetKey(noption) + } + + // Substitute by new value and take off leading '%(' and trailing ')s'. + val = strings.Replace(val, vr, nk.value, -1) + } + return val +} + +// String returns string representation of value. +func (k *Key) String() string { + return k.transformValue(k.value) +} + +// Validate accepts a validate function which can +// return modifed result as key value. +func (k *Key) Validate(fn func(string) string) string { + return fn(k.String()) +} + +// parseBool returns the boolean value represented by the string. +// +// It accepts 1, t, T, TRUE, true, True, YES, yes, Yes, y, ON, on, On, +// 0, f, F, FALSE, false, False, NO, no, No, n, OFF, off, Off. +// Any other value returns an error. +func parseBool(str string) (value bool, err error) { + switch str { + case "1", "t", "T", "true", "TRUE", "True", "YES", "yes", "Yes", "y", "ON", "on", "On": + return true, nil + case "0", "f", "F", "false", "FALSE", "False", "NO", "no", "No", "n", "OFF", "off", "Off": + return false, nil + } + return false, fmt.Errorf("parsing \"%s\": invalid syntax", str) +} + +// Bool returns bool type value. +func (k *Key) Bool() (bool, error) { + return parseBool(k.String()) +} + +// Float64 returns float64 type value. +func (k *Key) Float64() (float64, error) { + return strconv.ParseFloat(k.String(), 64) +} + +// Int returns int type value. +func (k *Key) Int() (int, error) { + v, err := strconv.ParseInt(k.String(), 0, 64) + return int(v), err +} + +// Int64 returns int64 type value. +func (k *Key) Int64() (int64, error) { + return strconv.ParseInt(k.String(), 0, 64) +} + +// Uint returns uint type valued. +func (k *Key) Uint() (uint, error) { + u, e := strconv.ParseUint(k.String(), 0, 64) + return uint(u), e +} + +// Uint64 returns uint64 type value. +func (k *Key) Uint64() (uint64, error) { + return strconv.ParseUint(k.String(), 0, 64) +} + +// Duration returns time.Duration type value. +func (k *Key) Duration() (time.Duration, error) { + return time.ParseDuration(k.String()) +} + +// TimeFormat parses with given format and returns time.Time type value. +func (k *Key) TimeFormat(format string) (time.Time, error) { + return time.Parse(format, k.String()) +} + +// Time parses with RFC3339 format and returns time.Time type value. +func (k *Key) Time() (time.Time, error) { + return k.TimeFormat(time.RFC3339) +} + +// MustString returns default value if key value is empty. +func (k *Key) MustString(defaultVal string) string { + val := k.String() + if len(val) == 0 { + k.value = defaultVal + return defaultVal + } + return val +} + +// MustBool always returns value without error, +// it returns false if error occurs. +func (k *Key) MustBool(defaultVal ...bool) bool { + val, err := k.Bool() + if len(defaultVal) > 0 && err != nil { + k.value = strconv.FormatBool(defaultVal[0]) + return defaultVal[0] + } + return val +} + +// MustFloat64 always returns value without error, +// it returns 0.0 if error occurs. +func (k *Key) MustFloat64(defaultVal ...float64) float64 { + val, err := k.Float64() + if len(defaultVal) > 0 && err != nil { + k.value = strconv.FormatFloat(defaultVal[0], 'f', -1, 64) + return defaultVal[0] + } + return val +} + +// MustInt always returns value without error, +// it returns 0 if error occurs. +func (k *Key) MustInt(defaultVal ...int) int { + val, err := k.Int() + if len(defaultVal) > 0 && err != nil { + k.value = strconv.FormatInt(int64(defaultVal[0]), 10) + return defaultVal[0] + } + return val +} + +// MustInt64 always returns value without error, +// it returns 0 if error occurs. +func (k *Key) MustInt64(defaultVal ...int64) int64 { + val, err := k.Int64() + if len(defaultVal) > 0 && err != nil { + k.value = strconv.FormatInt(defaultVal[0], 10) + return defaultVal[0] + } + return val +} + +// MustUint always returns value without error, +// it returns 0 if error occurs. +func (k *Key) MustUint(defaultVal ...uint) uint { + val, err := k.Uint() + if len(defaultVal) > 0 && err != nil { + k.value = strconv.FormatUint(uint64(defaultVal[0]), 10) + return defaultVal[0] + } + return val +} + +// MustUint64 always returns value without error, +// it returns 0 if error occurs. +func (k *Key) MustUint64(defaultVal ...uint64) uint64 { + val, err := k.Uint64() + if len(defaultVal) > 0 && err != nil { + k.value = strconv.FormatUint(defaultVal[0], 10) + return defaultVal[0] + } + return val +} + +// MustDuration always returns value without error, +// it returns zero value if error occurs. +func (k *Key) MustDuration(defaultVal ...time.Duration) time.Duration { + val, err := k.Duration() + if len(defaultVal) > 0 && err != nil { + k.value = defaultVal[0].String() + return defaultVal[0] + } + return val +} + +// MustTimeFormat always parses with given format and returns value without error, +// it returns zero value if error occurs. +func (k *Key) MustTimeFormat(format string, defaultVal ...time.Time) time.Time { + val, err := k.TimeFormat(format) + if len(defaultVal) > 0 && err != nil { + k.value = defaultVal[0].Format(format) + return defaultVal[0] + } + return val +} + +// MustTime always parses with RFC3339 format and returns value without error, +// it returns zero value if error occurs. +func (k *Key) MustTime(defaultVal ...time.Time) time.Time { + return k.MustTimeFormat(time.RFC3339, defaultVal...) +} + +// In always returns value without error, +// it returns default value if error occurs or doesn't fit into candidates. +func (k *Key) In(defaultVal string, candidates []string) string { + val := k.String() + for _, cand := range candidates { + if val == cand { + return val + } + } + return defaultVal +} + +// InFloat64 always returns value without error, +// it returns default value if error occurs or doesn't fit into candidates. +func (k *Key) InFloat64(defaultVal float64, candidates []float64) float64 { + val := k.MustFloat64() + for _, cand := range candidates { + if val == cand { + return val + } + } + return defaultVal +} + +// InInt always returns value without error, +// it returns default value if error occurs or doesn't fit into candidates. +func (k *Key) InInt(defaultVal int, candidates []int) int { + val := k.MustInt() + for _, cand := range candidates { + if val == cand { + return val + } + } + return defaultVal +} + +// InInt64 always returns value without error, +// it returns default value if error occurs or doesn't fit into candidates. +func (k *Key) InInt64(defaultVal int64, candidates []int64) int64 { + val := k.MustInt64() + for _, cand := range candidates { + if val == cand { + return val + } + } + return defaultVal +} + +// InUint always returns value without error, +// it returns default value if error occurs or doesn't fit into candidates. +func (k *Key) InUint(defaultVal uint, candidates []uint) uint { + val := k.MustUint() + for _, cand := range candidates { + if val == cand { + return val + } + } + return defaultVal +} + +// InUint64 always returns value without error, +// it returns default value if error occurs or doesn't fit into candidates. +func (k *Key) InUint64(defaultVal uint64, candidates []uint64) uint64 { + val := k.MustUint64() + for _, cand := range candidates { + if val == cand { + return val + } + } + return defaultVal +} + +// InTimeFormat always parses with given format and returns value without error, +// it returns default value if error occurs or doesn't fit into candidates. +func (k *Key) InTimeFormat(format string, defaultVal time.Time, candidates []time.Time) time.Time { + val := k.MustTimeFormat(format) + for _, cand := range candidates { + if val == cand { + return val + } + } + return defaultVal +} + +// InTime always parses with RFC3339 format and returns value without error, +// it returns default value if error occurs or doesn't fit into candidates. +func (k *Key) InTime(defaultVal time.Time, candidates []time.Time) time.Time { + return k.InTimeFormat(time.RFC3339, defaultVal, candidates) +} + +// RangeFloat64 checks if value is in given range inclusively, +// and returns default value if it's not. +func (k *Key) RangeFloat64(defaultVal, min, max float64) float64 { + val := k.MustFloat64() + if val < min || val > max { + return defaultVal + } + return val +} + +// RangeInt checks if value is in given range inclusively, +// and returns default value if it's not. +func (k *Key) RangeInt(defaultVal, min, max int) int { + val := k.MustInt() + if val < min || val > max { + return defaultVal + } + return val +} + +// RangeInt64 checks if value is in given range inclusively, +// and returns default value if it's not. +func (k *Key) RangeInt64(defaultVal, min, max int64) int64 { + val := k.MustInt64() + if val < min || val > max { + return defaultVal + } + return val +} + +// RangeTimeFormat checks if value with given format is in given range inclusively, +// and returns default value if it's not. +func (k *Key) RangeTimeFormat(format string, defaultVal, min, max time.Time) time.Time { + val := k.MustTimeFormat(format) + if val.Unix() < min.Unix() || val.Unix() > max.Unix() { + return defaultVal + } + return val +} + +// RangeTime checks if value with RFC3339 format is in given range inclusively, +// and returns default value if it's not. +func (k *Key) RangeTime(defaultVal, min, max time.Time) time.Time { + return k.RangeTimeFormat(time.RFC3339, defaultVal, min, max) +} + +// Strings returns list of string divided by given delimiter. +func (k *Key) Strings(delim string) []string { + str := k.String() + if len(str) == 0 { + return []string{} + } + + runes := []rune(str) + vals := make([]string, 0, 2) + var buf bytes.Buffer + escape := false + idx := 0 + for { + if escape { + escape = false + if runes[idx] != '\\' && !strings.HasPrefix(string(runes[idx:]), delim) { + buf.WriteRune('\\') + } + buf.WriteRune(runes[idx]) + } else { + if runes[idx] == '\\' { + escape = true + } else if strings.HasPrefix(string(runes[idx:]), delim) { + idx += len(delim) - 1 + vals = append(vals, strings.TrimSpace(buf.String())) + buf.Reset() + } else { + buf.WriteRune(runes[idx]) + } + } + idx += 1 + if idx == len(runes) { + break + } + } + + if buf.Len() > 0 { + vals = append(vals, strings.TrimSpace(buf.String())) + } + + return vals +} + +// StringsWithShadows returns list of string divided by given delimiter. +// Shadows will also be appended if any. +func (k *Key) StringsWithShadows(delim string) []string { + vals := k.ValueWithShadows() + results := make([]string, 0, len(vals)*2) + for i := range vals { + if len(vals) == 0 { + continue + } + + results = append(results, strings.Split(vals[i], delim)...) + } + + for i := range results { + results[i] = k.transformValue(strings.TrimSpace(results[i])) + } + return results +} + +// Float64s returns list of float64 divided by given delimiter. Any invalid input will be treated as zero value. +func (k *Key) Float64s(delim string) []float64 { + vals, _ := k.parseFloat64s(k.Strings(delim), true, false) + return vals +} + +// Ints returns list of int divided by given delimiter. Any invalid input will be treated as zero value. +func (k *Key) Ints(delim string) []int { + vals, _ := k.parseInts(k.Strings(delim), true, false) + return vals +} + +// Int64s returns list of int64 divided by given delimiter. Any invalid input will be treated as zero value. +func (k *Key) Int64s(delim string) []int64 { + vals, _ := k.parseInt64s(k.Strings(delim), true, false) + return vals +} + +// Uints returns list of uint divided by given delimiter. Any invalid input will be treated as zero value. +func (k *Key) Uints(delim string) []uint { + vals, _ := k.parseUints(k.Strings(delim), true, false) + return vals +} + +// Uint64s returns list of uint64 divided by given delimiter. Any invalid input will be treated as zero value. +func (k *Key) Uint64s(delim string) []uint64 { + vals, _ := k.parseUint64s(k.Strings(delim), true, false) + return vals +} + +// TimesFormat parses with given format and returns list of time.Time divided by given delimiter. +// Any invalid input will be treated as zero value (0001-01-01 00:00:00 +0000 UTC). +func (k *Key) TimesFormat(format, delim string) []time.Time { + vals, _ := k.parseTimesFormat(format, k.Strings(delim), true, false) + return vals +} + +// Times parses with RFC3339 format and returns list of time.Time divided by given delimiter. +// Any invalid input will be treated as zero value (0001-01-01 00:00:00 +0000 UTC). +func (k *Key) Times(delim string) []time.Time { + return k.TimesFormat(time.RFC3339, delim) +} + +// ValidFloat64s returns list of float64 divided by given delimiter. If some value is not float, then +// it will not be included to result list. +func (k *Key) ValidFloat64s(delim string) []float64 { + vals, _ := k.parseFloat64s(k.Strings(delim), false, false) + return vals +} + +// ValidInts returns list of int divided by given delimiter. If some value is not integer, then it will +// not be included to result list. +func (k *Key) ValidInts(delim string) []int { + vals, _ := k.parseInts(k.Strings(delim), false, false) + return vals +} + +// ValidInt64s returns list of int64 divided by given delimiter. If some value is not 64-bit integer, +// then it will not be included to result list. +func (k *Key) ValidInt64s(delim string) []int64 { + vals, _ := k.parseInt64s(k.Strings(delim), false, false) + return vals +} + +// ValidUints returns list of uint divided by given delimiter. If some value is not unsigned integer, +// then it will not be included to result list. +func (k *Key) ValidUints(delim string) []uint { + vals, _ := k.parseUints(k.Strings(delim), false, false) + return vals +} + +// ValidUint64s returns list of uint64 divided by given delimiter. If some value is not 64-bit unsigned +// integer, then it will not be included to result list. +func (k *Key) ValidUint64s(delim string) []uint64 { + vals, _ := k.parseUint64s(k.Strings(delim), false, false) + return vals +} + +// ValidTimesFormat parses with given format and returns list of time.Time divided by given delimiter. +func (k *Key) ValidTimesFormat(format, delim string) []time.Time { + vals, _ := k.parseTimesFormat(format, k.Strings(delim), false, false) + return vals +} + +// ValidTimes parses with RFC3339 format and returns list of time.Time divided by given delimiter. +func (k *Key) ValidTimes(delim string) []time.Time { + return k.ValidTimesFormat(time.RFC3339, delim) +} + +// StrictFloat64s returns list of float64 divided by given delimiter or error on first invalid input. +func (k *Key) StrictFloat64s(delim string) ([]float64, error) { + return k.parseFloat64s(k.Strings(delim), false, true) +} + +// StrictInts returns list of int divided by given delimiter or error on first invalid input. +func (k *Key) StrictInts(delim string) ([]int, error) { + return k.parseInts(k.Strings(delim), false, true) +} + +// StrictInt64s returns list of int64 divided by given delimiter or error on first invalid input. +func (k *Key) StrictInt64s(delim string) ([]int64, error) { + return k.parseInt64s(k.Strings(delim), false, true) +} + +// StrictUints returns list of uint divided by given delimiter or error on first invalid input. +func (k *Key) StrictUints(delim string) ([]uint, error) { + return k.parseUints(k.Strings(delim), false, true) +} + +// StrictUint64s returns list of uint64 divided by given delimiter or error on first invalid input. +func (k *Key) StrictUint64s(delim string) ([]uint64, error) { + return k.parseUint64s(k.Strings(delim), false, true) +} + +// StrictTimesFormat parses with given format and returns list of time.Time divided by given delimiter +// or error on first invalid input. +func (k *Key) StrictTimesFormat(format, delim string) ([]time.Time, error) { + return k.parseTimesFormat(format, k.Strings(delim), false, true) +} + +// StrictTimes parses with RFC3339 format and returns list of time.Time divided by given delimiter +// or error on first invalid input. +func (k *Key) StrictTimes(delim string) ([]time.Time, error) { + return k.StrictTimesFormat(time.RFC3339, delim) +} + +// parseFloat64s transforms strings to float64s. +func (k *Key) parseFloat64s(strs []string, addInvalid, returnOnInvalid bool) ([]float64, error) { + vals := make([]float64, 0, len(strs)) + for _, str := range strs { + val, err := strconv.ParseFloat(str, 64) + if err != nil && returnOnInvalid { + return nil, err + } + if err == nil || addInvalid { + vals = append(vals, val) + } + } + return vals, nil +} + +// parseInts transforms strings to ints. +func (k *Key) parseInts(strs []string, addInvalid, returnOnInvalid bool) ([]int, error) { + vals := make([]int, 0, len(strs)) + for _, str := range strs { + valInt64, err := strconv.ParseInt(str, 0, 64) + val := int(valInt64) + if err != nil && returnOnInvalid { + return nil, err + } + if err == nil || addInvalid { + vals = append(vals, val) + } + } + return vals, nil +} + +// parseInt64s transforms strings to int64s. +func (k *Key) parseInt64s(strs []string, addInvalid, returnOnInvalid bool) ([]int64, error) { + vals := make([]int64, 0, len(strs)) + for _, str := range strs { + val, err := strconv.ParseInt(str, 0, 64) + if err != nil && returnOnInvalid { + return nil, err + } + if err == nil || addInvalid { + vals = append(vals, val) + } + } + return vals, nil +} + +// parseUints transforms strings to uints. +func (k *Key) parseUints(strs []string, addInvalid, returnOnInvalid bool) ([]uint, error) { + vals := make([]uint, 0, len(strs)) + for _, str := range strs { + val, err := strconv.ParseUint(str, 0, 0) + if err != nil && returnOnInvalid { + return nil, err + } + if err == nil || addInvalid { + vals = append(vals, uint(val)) + } + } + return vals, nil +} + +// parseUint64s transforms strings to uint64s. +func (k *Key) parseUint64s(strs []string, addInvalid, returnOnInvalid bool) ([]uint64, error) { + vals := make([]uint64, 0, len(strs)) + for _, str := range strs { + val, err := strconv.ParseUint(str, 0, 64) + if err != nil && returnOnInvalid { + return nil, err + } + if err == nil || addInvalid { + vals = append(vals, val) + } + } + return vals, nil +} + +// parseTimesFormat transforms strings to times in given format. +func (k *Key) parseTimesFormat(format string, strs []string, addInvalid, returnOnInvalid bool) ([]time.Time, error) { + vals := make([]time.Time, 0, len(strs)) + for _, str := range strs { + val, err := time.Parse(format, str) + if err != nil && returnOnInvalid { + return nil, err + } + if err == nil || addInvalid { + vals = append(vals, val) + } + } + return vals, nil +} + +// SetValue changes key value. +func (k *Key) SetValue(v string) { + if k.s.f.BlockMode { + k.s.f.lock.Lock() + defer k.s.f.lock.Unlock() + } + + k.value = v + k.s.keysHash[k.name] = v +} diff --git a/vendor/gopkg.in/ini.v1/parser.go b/vendor/gopkg.in/ini.v1/parser.go new file mode 100644 index 000000000000..f20073d1b4cd --- /dev/null +++ b/vendor/gopkg.in/ini.v1/parser.go @@ -0,0 +1,488 @@ +// Copyright 2015 Unknwon +// +// Licensed under the Apache License, Version 2.0 (the "License"): you may +// not use this file except in compliance with the License. You may obtain +// a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +// License for the specific language governing permissions and limitations +// under the License. + +package ini + +import ( + "bufio" + "bytes" + "fmt" + "io" + "regexp" + "strconv" + "strings" + "unicode" +) + +var pythonMultiline = regexp.MustCompile("^(\\s+)([^\n]+)") + +type tokenType int + +const ( + _TOKEN_INVALID tokenType = iota + _TOKEN_COMMENT + _TOKEN_SECTION + _TOKEN_KEY +) + +type parser struct { + buf *bufio.Reader + isEOF bool + count int + comment *bytes.Buffer +} + +func newParser(r io.Reader) *parser { + return &parser{ + buf: bufio.NewReader(r), + count: 1, + comment: &bytes.Buffer{}, + } +} + +// BOM handles header of UTF-8, UTF-16 LE and UTF-16 BE's BOM format. +// http://en.wikipedia.org/wiki/Byte_order_mark#Representations_of_byte_order_marks_by_encoding +func (p *parser) BOM() error { + mask, err := p.buf.Peek(2) + if err != nil && err != io.EOF { + return err + } else if len(mask) < 2 { + return nil + } + + switch { + case mask[0] == 254 && mask[1] == 255: + fallthrough + case mask[0] == 255 && mask[1] == 254: + p.buf.Read(mask) + case mask[0] == 239 && mask[1] == 187: + mask, err := p.buf.Peek(3) + if err != nil && err != io.EOF { + return err + } else if len(mask) < 3 { + return nil + } + if mask[2] == 191 { + p.buf.Read(mask) + } + } + return nil +} + +func (p *parser) readUntil(delim byte) ([]byte, error) { + data, err := p.buf.ReadBytes(delim) + if err != nil { + if err == io.EOF { + p.isEOF = true + } else { + return nil, err + } + } + return data, nil +} + +func cleanComment(in []byte) ([]byte, bool) { + i := bytes.IndexAny(in, "#;") + if i == -1 { + return nil, false + } + return in[i:], true +} + +func readKeyName(delimiters string, in []byte) (string, int, error) { + line := string(in) + + // Check if key name surrounded by quotes. + var keyQuote string + if line[0] == '"' { + if len(line) > 6 && string(line[0:3]) == `"""` { + keyQuote = `"""` + } else { + keyQuote = `"` + } + } else if line[0] == '`' { + keyQuote = "`" + } + + // Get out key name + endIdx := -1 + if len(keyQuote) > 0 { + startIdx := len(keyQuote) + // FIXME: fail case -> """"""name"""=value + pos := strings.Index(line[startIdx:], keyQuote) + if pos == -1 { + return "", -1, fmt.Errorf("missing closing key quote: %s", line) + } + pos += startIdx + + // Find key-value delimiter + i := strings.IndexAny(line[pos+startIdx:], delimiters) + if i < 0 { + return "", -1, ErrDelimiterNotFound{line} + } + endIdx = pos + i + return strings.TrimSpace(line[startIdx:pos]), endIdx + startIdx + 1, nil + } + + endIdx = strings.IndexAny(line, delimiters) + if endIdx < 0 { + return "", -1, ErrDelimiterNotFound{line} + } + return strings.TrimSpace(line[0:endIdx]), endIdx + 1, nil +} + +func (p *parser) readMultilines(line, val, valQuote string) (string, error) { + for { + data, err := p.readUntil('\n') + if err != nil { + return "", err + } + next := string(data) + + pos := strings.LastIndex(next, valQuote) + if pos > -1 { + val += next[:pos] + + comment, has := cleanComment([]byte(next[pos:])) + if has { + p.comment.Write(bytes.TrimSpace(comment)) + } + break + } + val += next + if p.isEOF { + return "", fmt.Errorf("missing closing key quote from '%s' to '%s'", line, next) + } + } + return val, nil +} + +func (p *parser) readContinuationLines(val string) (string, error) { + for { + data, err := p.readUntil('\n') + if err != nil { + return "", err + } + next := strings.TrimSpace(string(data)) + + if len(next) == 0 { + break + } + val += next + if val[len(val)-1] != '\\' { + break + } + val = val[:len(val)-1] + } + return val, nil +} + +// hasSurroundedQuote check if and only if the first and last characters +// are quotes \" or \'. +// It returns false if any other parts also contain same kind of quotes. +func hasSurroundedQuote(in string, quote byte) bool { + return len(in) >= 2 && in[0] == quote && in[len(in)-1] == quote && + strings.IndexByte(in[1:], quote) == len(in)-2 +} + +func (p *parser) readValue(in []byte, + parserBufferSize int, + ignoreContinuation, ignoreInlineComment, unescapeValueDoubleQuotes, unescapeValueCommentSymbols, allowPythonMultilines, spaceBeforeInlineComment, preserveSurroundedQuote bool) (string, error) { + + line := strings.TrimLeftFunc(string(in), unicode.IsSpace) + if len(line) == 0 { + return "", nil + } + + var valQuote string + if len(line) > 3 && string(line[0:3]) == `"""` { + valQuote = `"""` + } else if line[0] == '`' { + valQuote = "`" + } else if unescapeValueDoubleQuotes && line[0] == '"' { + valQuote = `"` + } + + if len(valQuote) > 0 { + startIdx := len(valQuote) + pos := strings.LastIndex(line[startIdx:], valQuote) + // Check for multi-line value + if pos == -1 { + return p.readMultilines(line, line[startIdx:], valQuote) + } + + if unescapeValueDoubleQuotes && valQuote == `"` { + return strings.Replace(line[startIdx:pos+startIdx], `\"`, `"`, -1), nil + } + return line[startIdx : pos+startIdx], nil + } + + lastChar := line[len(line)-1] + // Won't be able to reach here if value only contains whitespace + line = strings.TrimSpace(line) + trimmedLastChar := line[len(line)-1] + + // Check continuation lines when desired + if !ignoreContinuation && trimmedLastChar == '\\' { + return p.readContinuationLines(line[:len(line)-1]) + } + + // Check if ignore inline comment + if !ignoreInlineComment { + var i int + if spaceBeforeInlineComment { + i = strings.Index(line, " #") + if i == -1 { + i = strings.Index(line, " ;") + } + + } else { + i = strings.IndexAny(line, "#;") + } + + if i > -1 { + p.comment.WriteString(line[i:]) + line = strings.TrimSpace(line[:i]) + } + + } + + // Trim single and double quotes + if (hasSurroundedQuote(line, '\'') || + hasSurroundedQuote(line, '"')) && !preserveSurroundedQuote { + line = line[1 : len(line)-1] + } else if len(valQuote) == 0 && unescapeValueCommentSymbols { + if strings.Contains(line, `\;`) { + line = strings.Replace(line, `\;`, ";", -1) + } + if strings.Contains(line, `\#`) { + line = strings.Replace(line, `\#`, "#", -1) + } + } else if allowPythonMultilines && lastChar == '\n' { + parserBufferPeekResult, _ := p.buf.Peek(parserBufferSize) + peekBuffer := bytes.NewBuffer(parserBufferPeekResult) + + val := line + + for { + peekData, peekErr := peekBuffer.ReadBytes('\n') + if peekErr != nil { + if peekErr == io.EOF { + return val, nil + } + return "", peekErr + } + + peekMatches := pythonMultiline.FindStringSubmatch(string(peekData)) + if len(peekMatches) != 3 { + return val, nil + } + + // NOTE: Return if not a python-ini multi-line value. + currentIdentSize := len(peekMatches[1]) + if currentIdentSize <= 0 { + return val, nil + } + + // NOTE: Just advance the parser reader (buffer) in-sync with the peek buffer. + _, err := p.readUntil('\n') + if err != nil { + return "", err + } + + val += fmt.Sprintf("\n%s", peekMatches[2]) + } + } + + return line, nil +} + +// parse parses data through an io.Reader. +func (f *File) parse(reader io.Reader) (err error) { + p := newParser(reader) + if err = p.BOM(); err != nil { + return fmt.Errorf("BOM: %v", err) + } + + // Ignore error because default section name is never empty string. + name := DEFAULT_SECTION + if f.options.Insensitive { + name = strings.ToLower(DEFAULT_SECTION) + } + section, _ := f.NewSection(name) + + // This "last" is not strictly equivalent to "previous one" if current key is not the first nested key + var isLastValueEmpty bool + var lastRegularKey *Key + + var line []byte + var inUnparseableSection bool + + // NOTE: Iterate and increase `currentPeekSize` until + // the size of the parser buffer is found. + // TODO(unknwon): When Golang 1.10 is the lowest version supported, replace with `parserBufferSize := p.buf.Size()`. + parserBufferSize := 0 + // NOTE: Peek 1kb at a time. + currentPeekSize := 1024 + + if f.options.AllowPythonMultilineValues { + for { + peekBytes, _ := p.buf.Peek(currentPeekSize) + peekBytesLength := len(peekBytes) + + if parserBufferSize >= peekBytesLength { + break + } + + currentPeekSize *= 2 + parserBufferSize = peekBytesLength + } + } + + for !p.isEOF { + line, err = p.readUntil('\n') + if err != nil { + return err + } + + if f.options.AllowNestedValues && + isLastValueEmpty && len(line) > 0 { + if line[0] == ' ' || line[0] == '\t' { + lastRegularKey.addNestedValue(string(bytes.TrimSpace(line))) + continue + } + } + + line = bytes.TrimLeftFunc(line, unicode.IsSpace) + if len(line) == 0 { + continue + } + + // Comments + if line[0] == '#' || line[0] == ';' { + // Note: we do not care ending line break, + // it is needed for adding second line, + // so just clean it once at the end when set to value. + p.comment.Write(line) + continue + } + + // Section + if line[0] == '[' { + // Read to the next ']' (TODO: support quoted strings) + closeIdx := bytes.LastIndexByte(line, ']') + if closeIdx == -1 { + return fmt.Errorf("unclosed section: %s", line) + } + + name := string(line[1:closeIdx]) + section, err = f.NewSection(name) + if err != nil { + return err + } + + comment, has := cleanComment(line[closeIdx+1:]) + if has { + p.comment.Write(comment) + } + + section.Comment = strings.TrimSpace(p.comment.String()) + + // Reset aotu-counter and comments + p.comment.Reset() + p.count = 1 + + inUnparseableSection = false + for i := range f.options.UnparseableSections { + if f.options.UnparseableSections[i] == name || + (f.options.Insensitive && strings.ToLower(f.options.UnparseableSections[i]) == strings.ToLower(name)) { + inUnparseableSection = true + continue + } + } + continue + } + + if inUnparseableSection { + section.isRawSection = true + section.rawBody += string(line) + continue + } + + kname, offset, err := readKeyName(f.options.KeyValueDelimiters, line) + if err != nil { + // Treat as boolean key when desired, and whole line is key name. + if IsErrDelimiterNotFound(err) { + switch { + case f.options.AllowBooleanKeys: + kname, err := p.readValue(line, + parserBufferSize, + f.options.IgnoreContinuation, + f.options.IgnoreInlineComment, + f.options.UnescapeValueDoubleQuotes, + f.options.UnescapeValueCommentSymbols, + f.options.AllowPythonMultilineValues, + f.options.SpaceBeforeInlineComment, + f.options.PreserveSurroundedQuote) + if err != nil { + return err + } + key, err := section.NewBooleanKey(kname) + if err != nil { + return err + } + key.Comment = strings.TrimSpace(p.comment.String()) + p.comment.Reset() + continue + + case f.options.SkipUnrecognizableLines: + continue + } + } + return err + } + + // Auto increment. + isAutoIncr := false + if kname == "-" { + isAutoIncr = true + kname = "#" + strconv.Itoa(p.count) + p.count++ + } + + value, err := p.readValue(line[offset:], + parserBufferSize, + f.options.IgnoreContinuation, + f.options.IgnoreInlineComment, + f.options.UnescapeValueDoubleQuotes, + f.options.UnescapeValueCommentSymbols, + f.options.AllowPythonMultilineValues, + f.options.SpaceBeforeInlineComment, + f.options.PreserveSurroundedQuote) + if err != nil { + return err + } + isLastValueEmpty = len(value) == 0 + + key, err := section.NewKey(kname, value) + if err != nil { + return err + } + key.isAutoIncrement = isAutoIncr + key.Comment = strings.TrimSpace(p.comment.String()) + p.comment.Reset() + lastRegularKey = key + } + return nil +} diff --git a/vendor/gopkg.in/ini.v1/section.go b/vendor/gopkg.in/ini.v1/section.go new file mode 100644 index 000000000000..bc32c620d6ed --- /dev/null +++ b/vendor/gopkg.in/ini.v1/section.go @@ -0,0 +1,259 @@ +// Copyright 2014 Unknwon +// +// Licensed under the Apache License, Version 2.0 (the "License"): you may +// not use this file except in compliance with the License. You may obtain +// a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +// License for the specific language governing permissions and limitations +// under the License. + +package ini + +import ( + "errors" + "fmt" + "strings" +) + +// Section represents a config section. +type Section struct { + f *File + Comment string + name string + keys map[string]*Key + keyList []string + keysHash map[string]string + + isRawSection bool + rawBody string +} + +func newSection(f *File, name string) *Section { + return &Section{ + f: f, + name: name, + keys: make(map[string]*Key), + keyList: make([]string, 0, 10), + keysHash: make(map[string]string), + } +} + +// Name returns name of Section. +func (s *Section) Name() string { + return s.name +} + +// Body returns rawBody of Section if the section was marked as unparseable. +// It still follows the other rules of the INI format surrounding leading/trailing whitespace. +func (s *Section) Body() string { + return strings.TrimSpace(s.rawBody) +} + +// SetBody updates body content only if section is raw. +func (s *Section) SetBody(body string) { + if !s.isRawSection { + return + } + s.rawBody = body +} + +// NewKey creates a new key to given section. +func (s *Section) NewKey(name, val string) (*Key, error) { + if len(name) == 0 { + return nil, errors.New("error creating new key: empty key name") + } else if s.f.options.Insensitive { + name = strings.ToLower(name) + } + + if s.f.BlockMode { + s.f.lock.Lock() + defer s.f.lock.Unlock() + } + + if inSlice(name, s.keyList) { + if s.f.options.AllowShadows { + if err := s.keys[name].addShadow(val); err != nil { + return nil, err + } + } else { + s.keys[name].value = val + s.keysHash[name] = val + } + return s.keys[name], nil + } + + s.keyList = append(s.keyList, name) + s.keys[name] = newKey(s, name, val) + s.keysHash[name] = val + return s.keys[name], nil +} + +// NewBooleanKey creates a new boolean type key to given section. +func (s *Section) NewBooleanKey(name string) (*Key, error) { + key, err := s.NewKey(name, "true") + if err != nil { + return nil, err + } + + key.isBooleanType = true + return key, nil +} + +// GetKey returns key in section by given name. +func (s *Section) GetKey(name string) (*Key, error) { + // FIXME: change to section level lock? + if s.f.BlockMode { + s.f.lock.RLock() + } + if s.f.options.Insensitive { + name = strings.ToLower(name) + } + key := s.keys[name] + if s.f.BlockMode { + s.f.lock.RUnlock() + } + + if key == nil { + // Check if it is a child-section. + sname := s.name + for { + if i := strings.LastIndex(sname, "."); i > -1 { + sname = sname[:i] + sec, err := s.f.GetSection(sname) + if err != nil { + continue + } + return sec.GetKey(name) + } else { + break + } + } + return nil, fmt.Errorf("error when getting key of section '%s': key '%s' not exists", s.name, name) + } + return key, nil +} + +// HasKey returns true if section contains a key with given name. +func (s *Section) HasKey(name string) bool { + key, _ := s.GetKey(name) + return key != nil +} + +// Haskey is a backwards-compatible name for HasKey. +// TODO: delete me in v2 +func (s *Section) Haskey(name string) bool { + return s.HasKey(name) +} + +// HasValue returns true if section contains given raw value. +func (s *Section) HasValue(value string) bool { + if s.f.BlockMode { + s.f.lock.RLock() + defer s.f.lock.RUnlock() + } + + for _, k := range s.keys { + if value == k.value { + return true + } + } + return false +} + +// Key assumes named Key exists in section and returns a zero-value when not. +func (s *Section) Key(name string) *Key { + key, err := s.GetKey(name) + if err != nil { + // It's OK here because the only possible error is empty key name, + // but if it's empty, this piece of code won't be executed. + key, _ = s.NewKey(name, "") + return key + } + return key +} + +// Keys returns list of keys of section. +func (s *Section) Keys() []*Key { + keys := make([]*Key, len(s.keyList)) + for i := range s.keyList { + keys[i] = s.Key(s.keyList[i]) + } + return keys +} + +// ParentKeys returns list of keys of parent section. +func (s *Section) ParentKeys() []*Key { + var parentKeys []*Key + sname := s.name + for { + if i := strings.LastIndex(sname, "."); i > -1 { + sname = sname[:i] + sec, err := s.f.GetSection(sname) + if err != nil { + continue + } + parentKeys = append(parentKeys, sec.Keys()...) + } else { + break + } + + } + return parentKeys +} + +// KeyStrings returns list of key names of section. +func (s *Section) KeyStrings() []string { + list := make([]string, len(s.keyList)) + copy(list, s.keyList) + return list +} + +// KeysHash returns keys hash consisting of names and values. +func (s *Section) KeysHash() map[string]string { + if s.f.BlockMode { + s.f.lock.RLock() + defer s.f.lock.RUnlock() + } + + hash := map[string]string{} + for key, value := range s.keysHash { + hash[key] = value + } + return hash +} + +// DeleteKey deletes a key from section. +func (s *Section) DeleteKey(name string) { + if s.f.BlockMode { + s.f.lock.Lock() + defer s.f.lock.Unlock() + } + + for i, k := range s.keyList { + if k == name { + s.keyList = append(s.keyList[:i], s.keyList[i+1:]...) + delete(s.keys, name) + delete(s.keysHash, name) + return + } + } +} + +// ChildSections returns a list of child sections of current section. +// For example, "[parent.child1]" and "[parent.child12]" are child sections +// of section "[parent]". +func (s *Section) ChildSections() []*Section { + prefix := s.name + "." + children := make([]*Section, 0, 3) + for _, name := range s.f.sectionList { + if strings.HasPrefix(name, prefix) { + children = append(children, s.f.sections[name]) + } + } + return children +} diff --git a/vendor/gopkg.in/ini.v1/struct.go b/vendor/gopkg.in/ini.v1/struct.go new file mode 100644 index 000000000000..a9dfed078ab6 --- /dev/null +++ b/vendor/gopkg.in/ini.v1/struct.go @@ -0,0 +1,512 @@ +// Copyright 2014 Unknwon +// +// Licensed under the Apache License, Version 2.0 (the "License"): you may +// not use this file except in compliance with the License. You may obtain +// a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT +// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the +// License for the specific language governing permissions and limitations +// under the License. + +package ini + +import ( + "bytes" + "errors" + "fmt" + "reflect" + "strings" + "time" + "unicode" +) + +// NameMapper represents a ini tag name mapper. +type NameMapper func(string) string + +// Built-in name getters. +var ( + // AllCapsUnderscore converts to format ALL_CAPS_UNDERSCORE. + AllCapsUnderscore NameMapper = func(raw string) string { + newstr := make([]rune, 0, len(raw)) + for i, chr := range raw { + if isUpper := 'A' <= chr && chr <= 'Z'; isUpper { + if i > 0 { + newstr = append(newstr, '_') + } + } + newstr = append(newstr, unicode.ToUpper(chr)) + } + return string(newstr) + } + // TitleUnderscore converts to format title_underscore. + TitleUnderscore NameMapper = func(raw string) string { + newstr := make([]rune, 0, len(raw)) + for i, chr := range raw { + if isUpper := 'A' <= chr && chr <= 'Z'; isUpper { + if i > 0 { + newstr = append(newstr, '_') + } + chr -= ('A' - 'a') + } + newstr = append(newstr, chr) + } + return string(newstr) + } +) + +func (s *Section) parseFieldName(raw, actual string) string { + if len(actual) > 0 { + return actual + } + if s.f.NameMapper != nil { + return s.f.NameMapper(raw) + } + return raw +} + +func parseDelim(actual string) string { + if len(actual) > 0 { + return actual + } + return "," +} + +var reflectTime = reflect.TypeOf(time.Now()).Kind() + +// setSliceWithProperType sets proper values to slice based on its type. +func setSliceWithProperType(key *Key, field reflect.Value, delim string, allowShadow, isStrict bool) error { + var strs []string + if allowShadow { + strs = key.StringsWithShadows(delim) + } else { + strs = key.Strings(delim) + } + + numVals := len(strs) + if numVals == 0 { + return nil + } + + var vals interface{} + var err error + + sliceOf := field.Type().Elem().Kind() + switch sliceOf { + case reflect.String: + vals = strs + case reflect.Int: + vals, err = key.parseInts(strs, true, false) + case reflect.Int64: + vals, err = key.parseInt64s(strs, true, false) + case reflect.Uint: + vals, err = key.parseUints(strs, true, false) + case reflect.Uint64: + vals, err = key.parseUint64s(strs, true, false) + case reflect.Float64: + vals, err = key.parseFloat64s(strs, true, false) + case reflectTime: + vals, err = key.parseTimesFormat(time.RFC3339, strs, true, false) + default: + return fmt.Errorf("unsupported type '[]%s'", sliceOf) + } + if err != nil && isStrict { + return err + } + + slice := reflect.MakeSlice(field.Type(), numVals, numVals) + for i := 0; i < numVals; i++ { + switch sliceOf { + case reflect.String: + slice.Index(i).Set(reflect.ValueOf(vals.([]string)[i])) + case reflect.Int: + slice.Index(i).Set(reflect.ValueOf(vals.([]int)[i])) + case reflect.Int64: + slice.Index(i).Set(reflect.ValueOf(vals.([]int64)[i])) + case reflect.Uint: + slice.Index(i).Set(reflect.ValueOf(vals.([]uint)[i])) + case reflect.Uint64: + slice.Index(i).Set(reflect.ValueOf(vals.([]uint64)[i])) + case reflect.Float64: + slice.Index(i).Set(reflect.ValueOf(vals.([]float64)[i])) + case reflectTime: + slice.Index(i).Set(reflect.ValueOf(vals.([]time.Time)[i])) + } + } + field.Set(slice) + return nil +} + +func wrapStrictError(err error, isStrict bool) error { + if isStrict { + return err + } + return nil +} + +// setWithProperType sets proper value to field based on its type, +// but it does not return error for failing parsing, +// because we want to use default value that is already assigned to strcut. +func setWithProperType(t reflect.Type, key *Key, field reflect.Value, delim string, allowShadow, isStrict bool) error { + switch t.Kind() { + case reflect.String: + if len(key.String()) == 0 { + return nil + } + field.SetString(key.String()) + case reflect.Bool: + boolVal, err := key.Bool() + if err != nil { + return wrapStrictError(err, isStrict) + } + field.SetBool(boolVal) + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + durationVal, err := key.Duration() + // Skip zero value + if err == nil && int64(durationVal) > 0 { + field.Set(reflect.ValueOf(durationVal)) + return nil + } + + intVal, err := key.Int64() + if err != nil { + return wrapStrictError(err, isStrict) + } + field.SetInt(intVal) + // byte is an alias for uint8, so supporting uint8 breaks support for byte + case reflect.Uint, reflect.Uint16, reflect.Uint32, reflect.Uint64: + durationVal, err := key.Duration() + // Skip zero value + if err == nil && uint64(durationVal) > 0 { + field.Set(reflect.ValueOf(durationVal)) + return nil + } + + uintVal, err := key.Uint64() + if err != nil { + return wrapStrictError(err, isStrict) + } + field.SetUint(uintVal) + + case reflect.Float32, reflect.Float64: + floatVal, err := key.Float64() + if err != nil { + return wrapStrictError(err, isStrict) + } + field.SetFloat(floatVal) + case reflectTime: + timeVal, err := key.Time() + if err != nil { + return wrapStrictError(err, isStrict) + } + field.Set(reflect.ValueOf(timeVal)) + case reflect.Slice: + return setSliceWithProperType(key, field, delim, allowShadow, isStrict) + default: + return fmt.Errorf("unsupported type '%s'", t) + } + return nil +} + +func parseTagOptions(tag string) (rawName string, omitEmpty bool, allowShadow bool) { + opts := strings.SplitN(tag, ",", 3) + rawName = opts[0] + if len(opts) > 1 { + omitEmpty = opts[1] == "omitempty" + } + if len(opts) > 2 { + allowShadow = opts[2] == "allowshadow" + } + return rawName, omitEmpty, allowShadow +} + +func (s *Section) mapTo(val reflect.Value, isStrict bool) error { + if val.Kind() == reflect.Ptr { + val = val.Elem() + } + typ := val.Type() + + for i := 0; i < typ.NumField(); i++ { + field := val.Field(i) + tpField := typ.Field(i) + + tag := tpField.Tag.Get("ini") + if tag == "-" { + continue + } + + rawName, _, allowShadow := parseTagOptions(tag) + fieldName := s.parseFieldName(tpField.Name, rawName) + if len(fieldName) == 0 || !field.CanSet() { + continue + } + + isAnonymous := tpField.Type.Kind() == reflect.Ptr && tpField.Anonymous + isStruct := tpField.Type.Kind() == reflect.Struct + if isAnonymous { + field.Set(reflect.New(tpField.Type.Elem())) + } + + if isAnonymous || isStruct { + if sec, err := s.f.GetSection(fieldName); err == nil { + if err = sec.mapTo(field, isStrict); err != nil { + return fmt.Errorf("error mapping field(%s): %v", fieldName, err) + } + continue + } + } + + if key, err := s.GetKey(fieldName); err == nil { + delim := parseDelim(tpField.Tag.Get("delim")) + if err = setWithProperType(tpField.Type, key, field, delim, allowShadow, isStrict); err != nil { + return fmt.Errorf("error mapping field(%s): %v", fieldName, err) + } + } + } + return nil +} + +// MapTo maps section to given struct. +func (s *Section) MapTo(v interface{}) error { + typ := reflect.TypeOf(v) + val := reflect.ValueOf(v) + if typ.Kind() == reflect.Ptr { + typ = typ.Elem() + val = val.Elem() + } else { + return errors.New("cannot map to non-pointer struct") + } + + return s.mapTo(val, false) +} + +// MapTo maps section to given struct in strict mode, +// which returns all possible error including value parsing error. +func (s *Section) StrictMapTo(v interface{}) error { + typ := reflect.TypeOf(v) + val := reflect.ValueOf(v) + if typ.Kind() == reflect.Ptr { + typ = typ.Elem() + val = val.Elem() + } else { + return errors.New("cannot map to non-pointer struct") + } + + return s.mapTo(val, true) +} + +// MapTo maps file to given struct. +func (f *File) MapTo(v interface{}) error { + return f.Section("").MapTo(v) +} + +// MapTo maps file to given struct in strict mode, +// which returns all possible error including value parsing error. +func (f *File) StrictMapTo(v interface{}) error { + return f.Section("").StrictMapTo(v) +} + +// MapTo maps data sources to given struct with name mapper. +func MapToWithMapper(v interface{}, mapper NameMapper, source interface{}, others ...interface{}) error { + cfg, err := Load(source, others...) + if err != nil { + return err + } + cfg.NameMapper = mapper + return cfg.MapTo(v) +} + +// StrictMapToWithMapper maps data sources to given struct with name mapper in strict mode, +// which returns all possible error including value parsing error. +func StrictMapToWithMapper(v interface{}, mapper NameMapper, source interface{}, others ...interface{}) error { + cfg, err := Load(source, others...) + if err != nil { + return err + } + cfg.NameMapper = mapper + return cfg.StrictMapTo(v) +} + +// MapTo maps data sources to given struct. +func MapTo(v, source interface{}, others ...interface{}) error { + return MapToWithMapper(v, nil, source, others...) +} + +// StrictMapTo maps data sources to given struct in strict mode, +// which returns all possible error including value parsing error. +func StrictMapTo(v, source interface{}, others ...interface{}) error { + return StrictMapToWithMapper(v, nil, source, others...) +} + +// reflectSliceWithProperType does the opposite thing as setSliceWithProperType. +func reflectSliceWithProperType(key *Key, field reflect.Value, delim string) error { + slice := field.Slice(0, field.Len()) + if field.Len() == 0 { + return nil + } + + var buf bytes.Buffer + sliceOf := field.Type().Elem().Kind() + for i := 0; i < field.Len(); i++ { + switch sliceOf { + case reflect.String: + buf.WriteString(slice.Index(i).String()) + case reflect.Int, reflect.Int64: + buf.WriteString(fmt.Sprint(slice.Index(i).Int())) + case reflect.Uint, reflect.Uint64: + buf.WriteString(fmt.Sprint(slice.Index(i).Uint())) + case reflect.Float64: + buf.WriteString(fmt.Sprint(slice.Index(i).Float())) + case reflectTime: + buf.WriteString(slice.Index(i).Interface().(time.Time).Format(time.RFC3339)) + default: + return fmt.Errorf("unsupported type '[]%s'", sliceOf) + } + buf.WriteString(delim) + } + key.SetValue(buf.String()[:buf.Len()-1]) + return nil +} + +// reflectWithProperType does the opposite thing as setWithProperType. +func reflectWithProperType(t reflect.Type, key *Key, field reflect.Value, delim string) error { + switch t.Kind() { + case reflect.String: + key.SetValue(field.String()) + case reflect.Bool: + key.SetValue(fmt.Sprint(field.Bool())) + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + key.SetValue(fmt.Sprint(field.Int())) + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: + key.SetValue(fmt.Sprint(field.Uint())) + case reflect.Float32, reflect.Float64: + key.SetValue(fmt.Sprint(field.Float())) + case reflectTime: + key.SetValue(fmt.Sprint(field.Interface().(time.Time).Format(time.RFC3339))) + case reflect.Slice: + return reflectSliceWithProperType(key, field, delim) + default: + return fmt.Errorf("unsupported type '%s'", t) + } + return nil +} + +// CR: copied from encoding/json/encode.go with modifications of time.Time support. +// TODO: add more test coverage. +func isEmptyValue(v reflect.Value) bool { + switch v.Kind() { + case reflect.Array, reflect.Map, reflect.Slice, reflect.String: + return v.Len() == 0 + case reflect.Bool: + return !v.Bool() + case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: + return v.Int() == 0 + case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: + return v.Uint() == 0 + case reflect.Float32, reflect.Float64: + return v.Float() == 0 + case reflect.Interface, reflect.Ptr: + return v.IsNil() + case reflectTime: + t, ok := v.Interface().(time.Time) + return ok && t.IsZero() + } + return false +} + +func (s *Section) reflectFrom(val reflect.Value) error { + if val.Kind() == reflect.Ptr { + val = val.Elem() + } + typ := val.Type() + + for i := 0; i < typ.NumField(); i++ { + field := val.Field(i) + tpField := typ.Field(i) + + tag := tpField.Tag.Get("ini") + if tag == "-" { + continue + } + + opts := strings.SplitN(tag, ",", 2) + if len(opts) == 2 && opts[1] == "omitempty" && isEmptyValue(field) { + continue + } + + fieldName := s.parseFieldName(tpField.Name, opts[0]) + if len(fieldName) == 0 || !field.CanSet() { + continue + } + + if (tpField.Type.Kind() == reflect.Ptr && tpField.Anonymous) || + (tpField.Type.Kind() == reflect.Struct && tpField.Type.Name() != "Time") { + // Note: The only error here is section doesn't exist. + sec, err := s.f.GetSection(fieldName) + if err != nil { + // Note: fieldName can never be empty here, ignore error. + sec, _ = s.f.NewSection(fieldName) + } + + // Add comment from comment tag + if len(sec.Comment) == 0 { + sec.Comment = tpField.Tag.Get("comment") + } + + if err = sec.reflectFrom(field); err != nil { + return fmt.Errorf("error reflecting field (%s): %v", fieldName, err) + } + continue + } + + // Note: Same reason as secion. + key, err := s.GetKey(fieldName) + if err != nil { + key, _ = s.NewKey(fieldName, "") + } + + // Add comment from comment tag + if len(key.Comment) == 0 { + key.Comment = tpField.Tag.Get("comment") + } + + if err = reflectWithProperType(tpField.Type, key, field, parseDelim(tpField.Tag.Get("delim"))); err != nil { + return fmt.Errorf("error reflecting field (%s): %v", fieldName, err) + } + + } + return nil +} + +// ReflectFrom reflects secion from given struct. +func (s *Section) ReflectFrom(v interface{}) error { + typ := reflect.TypeOf(v) + val := reflect.ValueOf(v) + if typ.Kind() == reflect.Ptr { + typ = typ.Elem() + val = val.Elem() + } else { + return errors.New("cannot reflect from non-pointer struct") + } + + return s.reflectFrom(val) +} + +// ReflectFrom reflects file from given struct. +func (f *File) ReflectFrom(v interface{}) error { + return f.Section("").ReflectFrom(v) +} + +// ReflectFrom reflects data sources from given struct with name mapper. +func ReflectFromWithMapper(cfg *File, v interface{}, mapper NameMapper) error { + cfg.NameMapper = mapper + return cfg.ReflectFrom(v) +} + +// ReflectFrom reflects data sources from given struct. +func ReflectFrom(cfg *File, v interface{}) error { + return ReflectFromWithMapper(cfg, v, nil) +} diff --git a/vendor/modules.txt b/vendor/modules.txt index 207197e7c844..c4b083925b3a 100644 --- a/vendor/modules.txt +++ b/vendor/modules.txt @@ -47,20 +47,24 @@ github.com/agext/levenshtein # github.com/agl/ed25519 v0.0.0-20150830182803-278e1ec8e8a6 github.com/agl/ed25519 github.com/agl/ed25519/edwards25519 -# github.com/aliyun/alibaba-cloud-sdk-go v0.0.0-20190104080739-ef2ef6084d8f +# github.com/aliyun/alibaba-cloud-sdk-go v0.0.0-20190329064014-6e358769c32a github.com/aliyun/alibaba-cloud-sdk-go/sdk github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials -github.com/aliyun/alibaba-cloud-sdk-go/sdk/resource -github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils github.com/aliyun/alibaba-cloud-sdk-go/services/location github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth +github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/credentials/provider github.com/aliyun/alibaba-cloud-sdk-go/sdk/endpoints github.com/aliyun/alibaba-cloud-sdk-go/sdk/errors github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests github.com/aliyun/alibaba-cloud-sdk-go/sdk/responses +github.com/aliyun/alibaba-cloud-sdk-go/sdk/utils github.com/aliyun/alibaba-cloud-sdk-go/sdk/auth/signers # github.com/aliyun/aliyun-oss-go-sdk v0.0.0-20190103054945-8205d1f41e70 github.com/aliyun/aliyun-oss-go-sdk/oss +# github.com/aliyun/aliyun-tablestore-go-sdk v4.1.2+incompatible +github.com/aliyun/aliyun-tablestore-go-sdk/tablestore +github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/otsprotocol +github.com/aliyun/aliyun-tablestore-go-sdk/tablestore/search # github.com/antchfx/xpath v0.0.0-20190129040759-c8489ed3251e github.com/antchfx/xpath # github.com/antchfx/xquery v0.0.0-20180515051857-ad5b8c7a47b0 @@ -607,5 +611,7 @@ google.golang.org/grpc/credentials/internal google.golang.org/grpc/balancer/base google.golang.org/grpc/binarylog/grpc_binarylog_v1 google.golang.org/grpc/internal/syscall +# gopkg.in/ini.v1 v1.42.0 +gopkg.in/ini.v1 # gopkg.in/yaml.v2 v2.2.2 gopkg.in/yaml.v2 diff --git a/vendor/vendor.json b/vendor/vendor.json deleted file mode 100644 index f370a2f5201a..000000000000 --- a/vendor/vendor.json +++ /dev/null @@ -1,31 +0,0 @@ -{ - "comment": "", - "ignore": "", - "package": [ - { - "checksumSHA1": "Wmm1SXFd629zX1xCE4K+iBYFCxY=", - "path": "github.com/aliyun/alibaba-cloud-sdk-go/sdk", - "revision": "9e99ffa417c0449e257b7bbc8a2246e6bf12bed7", - "revisionTime": "2019-03-01T03:26:57Z" - }, - { - "checksumSHA1": "ZTRznMoc99cr5DOJJgx30ZTqQ1E=", - "path": "github.com/aliyun/alibaba-cloud-sdk-go/sdk/requests", - "revision": "9e99ffa417c0449e257b7bbc8a2246e6bf12bed7", - "revisionTime": "2019-03-01T03:26:57Z" - }, - { - "checksumSHA1": "RZOdTSZN/PgcTqko5LzIAzw+UT4=", - "path": "github.com/pmezard/go-difflib/difflib", - "revision": "5d4384ee4fb2527b0a1256a821ebfc92f91efefc", - "revisionTime": "2018-12-26T10:54:42Z" - }, - { - "checksumSHA1": "oWPQ2KICquwc7GyCdfqxce67geI=", - "path": "github.com/stretchr/testify/assert", - "revision": "21cb1c2932a2d04c6792d5ad106243c6e36a3a7d", - "revisionTime": "2019-01-10T02:11:10Z" - } - ], - "rootPath": "github.com/hashicorp/terraform" -} diff --git a/website/docs/backends/types/oss.html.md b/website/docs/backends/types/oss.html.md index c0d589a45587..2e4bf791bbe5 100644 --- a/website/docs/backends/types/oss.html.md +++ b/website/docs/backends/types/oss.html.md @@ -8,12 +8,13 @@ description: |- # OSS -**Kind: Standard (with locking via OSS)** +**Kind: Standard (with locking via TableStore)** Stores the state as a given key in a given bucket on Stores [Alibaba Cloud OSS](https://www.alibabacloud.com/help/product/31815.htm). -This backend also supports state locking and consistency checking via Alibaba Cloud OSS. - +This backend also supports state locking and consistency checking via +[Alibaba Cloud Table Store](https://www.alibabacloud.com/help/doc-detail/27280.htm), which can be enabled by setting +the `tablestore_table` field to an existing TableStore table name. ## Example Configuration @@ -21,14 +22,18 @@ This backend also supports state locking and consistency checking via Alibaba Cl terraform { backend "oss" { bucket = "bucket-for-terraform-state" - path = "path/mystate" - name = "version-1.tfstate" + prefix = "path/mystate" + key = "version-1.tfstate" region = "cn-beijing" + tablestore_endpoint = "https://terraform-remote.cn-hangzhou.ots.aliyuncs.com" + tablestore_table = "statelock" } } ``` -This assumes we have a bucket created called `bucket-for-terraform-state`. The +This assumes we have a [OSS Bucket](https://www.terraform.io/docs/providers/alicloud/r/oss_bucket.html) created called `bucket-for-terraform-state`, +a [OTS Instance](https://www.terraform.io/docs/providers/alicloud/r/ots_instance.html) called `terraform-remote` and +a [OTS TableStore](https://www.terraform.io/docs/providers/alicloud/r/ots_table.html) called `statelock`. The Terraform state will be written into the file `path/mystate/version-1.tfstate`. @@ -42,7 +47,8 @@ source](/docs/providers/terraform/d/remote_state.html). terraform { backend "oss" { bucket = "remote-state-dns" - path = "mystate/state" + prefix = "mystate/state" + key = "terraform.tfstate" region = "cn-beijing" } } @@ -52,16 +58,17 @@ The `terraform_remote_state` data source will return all of the root outputs defined in the referenced remote state, an example output might look like: ``` -terraform_remote_state.dns - id = 2018-4-16 09:13:55.309409899 +0000 UTC - backend = oss - config.% = 4 - config.bucket = remote-state-dns - config.path = mystate/state - config.name = terraform.tfstate - config.region = cn-beijing - environment = default - workspace = default +data "terraform_remote_state" "network" { + backend = "oss" + config = { + bucket = "remote-state-dns" + key = "terraform.tfstate" + prefix = "mystate/state" + region = "cn-beijing" + } + outputs = {} + workspace = "default" +} ``` ## Configuration variables @@ -74,9 +81,10 @@ The following configuration options or environment variables are supported: * `region` - (Optional) The region of the OSS bucket. It supports environment variables `ALICLOUD_REGION` and `ALICLOUD_DEFAULT_REGION`. * `endpoint` - (Optional) A custom endpoint for the OSS API. It supports environment variables `ALICLOUD_OSS_ENDPOINT` and `OSS_ENDPOINT`. * `bucket` - (Required) The name of the OSS bucket. - * `path` - (Required) The path directory of the state file will be stored. - * `name` - (Optional) The name of the state file. Defaults to `terraform.tfstate`. - * `lock` - (Optional) Whether to lock state access. Defaults to `true`. + * `prefix` - (Opeional) The path directory of the state file will be stored. Default to "env:". + * `key` - (Optional) The name of the state file. Defaults to `terraform.tfstate`. + * `tablestore_endpoint` / `ALICLOUD_TABLESTORE_ENDPOINT` - (Optional) A custom endpoint for the TableStore API. + * `tablestore_table` - (Optional) A TableStore table for state locking and consistency. * `encrypt` - (Optional) Whether to enable server side encryption of the state file. If it is true, OSS will use 'AES256' encryption algorithm to encrypt state file. * `acl` - (Optional) [Object