diff --git a/.travis.yml b/.travis.yml index 39a06a3137..aba4ea09cf 100644 --- a/.travis.yml +++ b/.travis.yml @@ -13,7 +13,7 @@ script: # test front-end - make clean - cd ui/app/ && make && cd ../.. -- make assets +- make assets apiv2 - git diff --exit-code # test back-end - make diff --git a/Makefile b/Makefile index f30a12f682..7a034c62e8 100644 --- a/Makefile +++ b/Makefile @@ -29,7 +29,7 @@ assets: ui/app/script.js ui/app/index.html ui/app/lib template/default.tmpl cd $(PREFIX)/asset && $(GO) generate @$(GOFMT) -w ./asset -ui/app/script.js: $(shell find ui/app/src -iname *.elm) +ui/app/script.js: $(shell find ui/app/src -iname *.elm) api/v2/openapi.yaml cd $(FRONTEND_DIR) && $(MAKE) script.js .PHONY: proto @@ -56,6 +56,7 @@ test/with_api_v2/api_v2_client/models test/with_api_v2/api_v2_client/client: api .PHONY: clean clean: rm -f asset/assets_vfsdata.go + rm -r api/v2/models api/v2/restapi test/with_api_v2/api_v2_client/models test/with_api_v2/api_v2_client/client cd $(FRONTEND_DIR) && $(MAKE) clean .PHONY: test diff --git a/api/v2/api.go b/api/v2/api.go index 10499c9a68..e543f47ac0 100644 --- a/api/v2/api.go +++ b/api/v2/api.go @@ -39,6 +39,7 @@ import ( "github.com/prometheus/alertmanager/types" prometheus_model "github.com/prometheus/common/model" + "github.com/prometheus/common/version" "github.com/prometheus/prometheus/pkg/labels" "github.com/go-kit/kit/log" @@ -54,6 +55,7 @@ type API struct { silences *silence.Silences alerts provider.Alerts getAlertStatus getAlertStatusFn + uptime time.Time // mtx protects resolveTimeout, alertmanagerConfig and route. mtx sync.RWMutex @@ -78,6 +80,7 @@ func NewAPI(alerts provider.Alerts, sf getAlertStatusFn, silences *silence.Silen peer: peer, silences: silences, logger: l, + uptime: time.Now(), } // load embedded swagger file @@ -122,16 +125,33 @@ func (api *API) getStatusHandler(params general_ops.GetStatusParams) middleware. name := api.peer.Name() status := api.peer.Status() + original := api.alertmanagerConfig.String() + uptime := strfmt.DateTime(api.uptime) resp := open_api_models.AlertmanagerStatus{ - Name: &name, - StatusInCluster: &status, - Peers: []*open_api_models.PeerStatus{}, + Uptime: &uptime, + VersionInfo: &open_api_models.VersionInfo{ + Version: &version.Version, + Revision: &version.Revision, + Branch: &version.Branch, + BuildUser: &version.BuildUser, + BuildDate: &version.BuildDate, + GoVersion: &version.GoVersion, + }, + Config: &open_api_models.AlertmanagerConfig{ + Original: &original, + }, + Cluster: &open_api_models.ClusterStatus{ + Name: &name, + Status: &status, + Peers: []*open_api_models.PeerStatus{}, + }, } for _, n := range api.peer.Peers() { - resp.Peers = append(resp.Peers, &open_api_models.PeerStatus{ - Name: n.Name, - Address: n.Address(), + address := n.Address() + resp.Cluster.Peers = append(resp.Cluster.Peers, &open_api_models.PeerStatus{ + Name: &n.Name, + Address: &address, }) } @@ -144,7 +164,7 @@ func (api *API) getReceiversHandler(params receiver_ops.GetReceiversParams) midd receivers := make([]*open_api_models.Receiver, 0, len(api.alertmanagerConfig.Receivers)) for _, r := range api.alertmanagerConfig.Receivers { - receivers = append(receivers, &open_api_models.Receiver{Name: r.Name}) + receivers = append(receivers, &open_api_models.Receiver{Name: &r.Name}) } return receiver_ops.NewGetReceiversOK().WithPayload(receivers) @@ -196,7 +216,7 @@ func (api *API) getAlertsHandler(params alert_ops.GetAlertsParams) middleware.Re routes := api.route.Match(a.Labels) receivers := make([]*open_api_models.Receiver, 0, len(routes)) for _, r := range routes { - receivers = append(receivers, &open_api_models.Receiver{Name: r.RouteOpts.Receiver}) + receivers = append(receivers, &open_api_models.Receiver{Name: &r.RouteOpts.Receiver}) } if receiverFilter != nil && !receiversMatchFilter(receivers, receiverFilter) { @@ -230,6 +250,8 @@ func (api *API) getAlertsHandler(params alert_ops.GetAlertsParams) middleware.Re continue } + state := string(status.State) + alert := open_api_models.Alert{ Annotations: modelLabelSetToAPILabelSet(a.Annotations), EndsAt: strfmt.DateTime(a.EndsAt), @@ -239,7 +261,7 @@ func (api *API) getAlertsHandler(params alert_ops.GetAlertsParams) middleware.Re Receivers: receivers, StartsAt: strfmt.DateTime(a.StartsAt), Status: &open_api_models.AlertStatus{ - State: string(status.State), + State: &state, SilencedBy: status.SilencedBy, InhibitedBy: status.InhibitedBy, }, @@ -368,7 +390,7 @@ func apiLabelSetToModelLabelSet(apiLabelSet open_api_models.LabelSet) prometheus func receiversMatchFilter(receivers []*open_api_models.Receiver, filter *regexp.Regexp) bool { for _, r := range receivers { - if filter.MatchString(string(r.Name)) { + if filter.MatchString(string(*r.Name)) { return true } } @@ -428,14 +450,14 @@ func (api *API) getSilencesHandler(params silence_ops.GetSilencesParams) middlew return silence_ops.NewGetSilencesInternalServerError().WithPayload(err.Error()) } - sils := []*open_api_models.Silence{} + sils := open_api_models.GettableSilences{} for _, ps := range psils { - silence, err := silenceFromProto(ps) + silence, err := gettableSilenceFromProto(ps) if err != nil { level.Error(api.logger).Log("msg", "failed to unmarshal silence from proto", "err", err) return silence_ops.NewGetSilencesInternalServerError().WithPayload(err.Error()) } - if !silenceMatchesFilterLabels(silence, matchers) { + if !gettableSilenceMatchesFilterLabels(silence, matchers) { continue } sils = append(sils, &silence) @@ -444,10 +466,10 @@ func (api *API) getSilencesHandler(params silence_ops.GetSilencesParams) middlew return silence_ops.NewGetSilencesOK().WithPayload(sils) } -func silenceMatchesFilterLabels(s open_api_models.Silence, matchers []*labels.Matcher) bool { +func gettableSilenceMatchesFilterLabels(s open_api_models.GettableSilence, matchers []*labels.Matcher) bool { sms := make(map[string]string) for _, m := range s.Matchers { - sms[m.Name] = m.Value + sms[*m.Name] = *m.Value } return matchFilterLabels(matchers, sms) @@ -465,7 +487,7 @@ func (api *API) getSilenceHandler(params silence_ops.GetSilenceParams) middlewar return silence_ops.NewGetSilenceNotFound() } - sil, err := silenceFromProto(sils[0]) + sil, err := gettableSilenceFromProto(sils[0]) if err != nil { level.Error(api.logger).Log("msg", "failed to convert unmarshal from proto", "err", err) return silence_ops.NewGetSilenceInternalServerError().WithPayload(err.Error()) @@ -484,29 +506,37 @@ func (api *API) deleteSilenceHandler(params silence_ops.DeleteSilenceParams) mid return silence_ops.NewDeleteSilenceOK() } -func silenceFromProto(s *silencepb.Silence) (open_api_models.Silence, error) { - sil := open_api_models.Silence{ - ID: s.Id, - StartsAt: strfmt.DateTime(s.StartsAt), - EndsAt: strfmt.DateTime(s.EndsAt), - UpdatedAt: strfmt.DateTime(s.UpdatedAt), +func gettableSilenceFromProto(s *silencepb.Silence) (open_api_models.GettableSilence, error) { + start := strfmt.DateTime(s.StartsAt) + end := strfmt.DateTime(s.EndsAt) + updated := strfmt.DateTime(s.UpdatedAt) + state := string(types.CalcSilenceState(s.StartsAt, s.EndsAt)) + sil := open_api_models.GettableSilence{ + Silence: open_api_models.Silence{ + StartsAt: &start, + EndsAt: &end, + Comment: &s.Comment, + CreatedBy: &s.CreatedBy, + }, + ID: &s.Id, + UpdatedAt: &updated, Status: &open_api_models.SilenceStatus{ - State: string(types.CalcSilenceState(s.StartsAt, s.EndsAt)), + State: &state, }, - Comment: s.Comment, - CreatedBy: s.CreatedBy, } for _, m := range s.Matchers { matcher := &open_api_models.Matcher{ - Name: m.Name, - Value: m.Pattern, - Regex: m.Pattern, + Name: &m.Name, + Value: &m.Pattern, } switch m.Type { case silencepb.Matcher_EQUAL: + f := false + matcher.IsRegex = &f case silencepb.Matcher_REGEXP: - matcher.IsRegex = true + t := true + matcher.IsRegex = &t default: return sil, fmt.Errorf( "unknown matcher type for matcher '%v' in silence '%v'", @@ -522,7 +552,7 @@ func silenceFromProto(s *silencepb.Silence) (open_api_models.Silence, error) { func (api *API) postSilencesHandler(params silence_ops.PostSilencesParams) middleware.Responder { - sil, err := silenceToProto(params.Silence) + sil, err := postableSilenceToProto(params.Silence) if err != nil { level.Error(api.logger).Log("msg", "failed to marshal silence to proto", "err", err) return silence_ops.NewPostSilencesBadRequest().WithPayload( @@ -553,22 +583,21 @@ func (api *API) postSilencesHandler(params silence_ops.PostSilencesParams) middl }) } -func silenceToProto(s *open_api_models.Silence) (*silencepb.Silence, error) { +func postableSilenceToProto(s *open_api_models.PostableSilence) (*silencepb.Silence, error) { sil := &silencepb.Silence{ Id: s.ID, - StartsAt: time.Time(s.StartsAt), - EndsAt: time.Time(s.EndsAt), - UpdatedAt: time.Time(s.UpdatedAt), - Comment: s.Comment, - CreatedBy: s.CreatedBy, + StartsAt: time.Time(*s.StartsAt), + EndsAt: time.Time(*s.EndsAt), + Comment: *s.Comment, + CreatedBy: *s.CreatedBy, } for _, m := range s.Matchers { matcher := &silencepb.Matcher{ - Name: m.Name, - Pattern: m.Value, + Name: *m.Name, + Pattern: *m.Value, Type: silencepb.Matcher_EQUAL, } - if m.IsRegex { + if *m.IsRegex { matcher.Type = silencepb.Matcher_REGEXP } sil.Matchers = append(sil.Matchers, matcher) diff --git a/api/v2/models/alert.go b/api/v2/models/alert.go index 4a399eed78..0755b385d3 100644 --- a/api/v2/models/alert.go +++ b/api/v2/models/alert.go @@ -6,7 +6,6 @@ package models // Editing this file might prove futile when you re-run the swagger generate command import ( - "encoding/json" "strconv" strfmt "github.com/go-openapi/strfmt" @@ -35,7 +34,8 @@ type Alert struct { GeneratorURL strfmt.URI `json:"generatorURL,omitempty"` // labels - Labels LabelSet `json:"labels,omitempty"` + // Required: true + Labels LabelSet `json:"labels"` // receivers Receivers []*Receiver `json:"receivers"` @@ -138,10 +138,6 @@ func (m *Alert) validateGeneratorURL(formats strfmt.Registry) error { func (m *Alert) validateLabels(formats strfmt.Registry) error { - if swag.IsZero(m.Labels) { // not required - return nil - } - if err := m.Labels.Validate(formats); err != nil { if ve, ok := err.(*errors.Validation); ok { return ve.ValidateName("labels") @@ -238,96 +234,3 @@ func (m *Alert) UnmarshalBinary(b []byte) error { *m = res return nil } - -// AlertStatus alert status -// swagger:model AlertStatus -type AlertStatus struct { - - // inhibited by - InhibitedBy []string `json:"inhibitedBy"` - - // silenced by - SilencedBy []string `json:"silencedBy"` - - // state - // Enum: [unprocessed active suppressed] - State string `json:"state,omitempty"` -} - -// Validate validates this alert status -func (m *AlertStatus) Validate(formats strfmt.Registry) error { - var res []error - - if err := m.validateState(formats); err != nil { - res = append(res, err) - } - - if len(res) > 0 { - return errors.CompositeValidationError(res...) - } - return nil -} - -var alertStatusTypeStatePropEnum []interface{} - -func init() { - var res []string - if err := json.Unmarshal([]byte(`["unprocessed","active","suppressed"]`), &res); err != nil { - panic(err) - } - for _, v := range res { - alertStatusTypeStatePropEnum = append(alertStatusTypeStatePropEnum, v) - } -} - -const ( - - // AlertStatusStateUnprocessed captures enum value "unprocessed" - AlertStatusStateUnprocessed string = "unprocessed" - - // AlertStatusStateActive captures enum value "active" - AlertStatusStateActive string = "active" - - // AlertStatusStateSuppressed captures enum value "suppressed" - AlertStatusStateSuppressed string = "suppressed" -) - -// prop value enum -func (m *AlertStatus) validateStateEnum(path, location string, value string) error { - if err := validate.Enum(path, location, value, alertStatusTypeStatePropEnum); err != nil { - return err - } - return nil -} - -func (m *AlertStatus) validateState(formats strfmt.Registry) error { - - if swag.IsZero(m.State) { // not required - return nil - } - - // value enum - if err := m.validateStateEnum("status"+"."+"state", "body", m.State); err != nil { - return err - } - - return nil -} - -// MarshalBinary interface implementation -func (m *AlertStatus) MarshalBinary() ([]byte, error) { - if m == nil { - return nil, nil - } - return swag.WriteJSON(m) -} - -// UnmarshalBinary interface implementation -func (m *AlertStatus) UnmarshalBinary(b []byte) error { - var res AlertStatus - if err := swag.ReadJSON(b, &res); err != nil { - return err - } - *m = res - return nil -} diff --git a/api/v2/models/alert_status.go b/api/v2/models/alert_status.go new file mode 100644 index 0000000000..673deaabda --- /dev/null +++ b/api/v2/models/alert_status.go @@ -0,0 +1,138 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// AlertStatus alert status +// swagger:model alertStatus +type AlertStatus struct { + + // inhibited by + // Required: true + InhibitedBy []string `json:"inhibitedBy"` + + // silenced by + // Required: true + SilencedBy []string `json:"silencedBy"` + + // state + // Required: true + // Enum: [unprocessed active suppressed] + State *string `json:"state"` +} + +// Validate validates this alert status +func (m *AlertStatus) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateInhibitedBy(formats); err != nil { + res = append(res, err) + } + + if err := m.validateSilencedBy(formats); err != nil { + res = append(res, err) + } + + if err := m.validateState(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *AlertStatus) validateInhibitedBy(formats strfmt.Registry) error { + + if err := validate.Required("inhibitedBy", "body", m.InhibitedBy); err != nil { + return err + } + + return nil +} + +func (m *AlertStatus) validateSilencedBy(formats strfmt.Registry) error { + + if err := validate.Required("silencedBy", "body", m.SilencedBy); err != nil { + return err + } + + return nil +} + +var alertStatusTypeStatePropEnum []interface{} + +func init() { + var res []string + if err := json.Unmarshal([]byte(`["unprocessed","active","suppressed"]`), &res); err != nil { + panic(err) + } + for _, v := range res { + alertStatusTypeStatePropEnum = append(alertStatusTypeStatePropEnum, v) + } +} + +const ( + + // AlertStatusStateUnprocessed captures enum value "unprocessed" + AlertStatusStateUnprocessed string = "unprocessed" + + // AlertStatusStateActive captures enum value "active" + AlertStatusStateActive string = "active" + + // AlertStatusStateSuppressed captures enum value "suppressed" + AlertStatusStateSuppressed string = "suppressed" +) + +// prop value enum +func (m *AlertStatus) validateStateEnum(path, location string, value string) error { + if err := validate.Enum(path, location, value, alertStatusTypeStatePropEnum); err != nil { + return err + } + return nil +} + +func (m *AlertStatus) validateState(formats strfmt.Registry) error { + + if err := validate.Required("state", "body", m.State); err != nil { + return err + } + + // value enum + if err := m.validateStateEnum("state", "body", *m.State); err != nil { + return err + } + + return nil +} + +// MarshalBinary interface implementation +func (m *AlertStatus) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *AlertStatus) UnmarshalBinary(b []byte) error { + var res AlertStatus + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/api/v2/models/alertmanager_config.go b/api/v2/models/alertmanager_config.go new file mode 100644 index 0000000000..6b41f1bcd3 --- /dev/null +++ b/api/v2/models/alertmanager_config.go @@ -0,0 +1,64 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// AlertmanagerConfig alertmanager config +// swagger:model alertmanagerConfig +type AlertmanagerConfig struct { + + // original + // Required: true + Original *string `json:"original"` +} + +// Validate validates this alertmanager config +func (m *AlertmanagerConfig) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateOriginal(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *AlertmanagerConfig) validateOriginal(formats strfmt.Registry) error { + + if err := validate.Required("original", "body", m.Original); err != nil { + return err + } + + return nil +} + +// MarshalBinary interface implementation +func (m *AlertmanagerConfig) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *AlertmanagerConfig) UnmarshalBinary(b []byte) error { + var res AlertmanagerConfig + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/api/v2/models/alertmanager_status.go b/api/v2/models/alertmanager_status.go index d205a60a39..5c6c785df0 100644 --- a/api/v2/models/alertmanager_status.go +++ b/api/v2/models/alertmanager_status.go @@ -6,8 +6,6 @@ package models // Editing this file might prove futile when you re-run the swagger generate command import ( - "strconv" - strfmt "github.com/go-openapi/strfmt" "github.com/go-openapi/errors" @@ -19,33 +17,41 @@ import ( // swagger:model alertmanagerStatus type AlertmanagerStatus struct { - // name + // cluster + // Required: true + Cluster *ClusterStatus `json:"cluster"` + + // config // Required: true - Name *string `json:"name"` + Config *AlertmanagerConfig `json:"config"` - // peers + // uptime // Required: true - // Minimum: 0 - Peers []*PeerStatus `json:"peers"` + // Format: date-time + Uptime *strfmt.DateTime `json:"uptime"` - // status in cluster + // version info // Required: true - StatusInCluster *string `json:"statusInCluster"` + VersionInfo *VersionInfo `json:"versionInfo"` } // Validate validates this alertmanager status func (m *AlertmanagerStatus) Validate(formats strfmt.Registry) error { var res []error - if err := m.validateName(formats); err != nil { + if err := m.validateCluster(formats); err != nil { res = append(res, err) } - if err := m.validatePeers(formats); err != nil { + if err := m.validateConfig(formats); err != nil { res = append(res, err) } - if err := m.validateStatusInCluster(formats); err != nil { + if err := m.validateUptime(formats); err != nil { + res = append(res, err) + } + + if err := m.validateVersionInfo(formats); err != nil { res = append(res, err) } @@ -55,46 +61,70 @@ func (m *AlertmanagerStatus) Validate(formats strfmt.Registry) error { return nil } -func (m *AlertmanagerStatus) validateName(formats strfmt.Registry) error { +func (m *AlertmanagerStatus) validateCluster(formats strfmt.Registry) error { - if err := validate.Required("name", "body", m.Name); err != nil { + if err := validate.Required("cluster", "body", m.Cluster); err != nil { return err } + if m.Cluster != nil { + if err := m.Cluster.Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("cluster") + } + return err + } + } + return nil } -func (m *AlertmanagerStatus) validatePeers(formats strfmt.Registry) error { +func (m *AlertmanagerStatus) validateConfig(formats strfmt.Registry) error { - if err := validate.Required("peers", "body", m.Peers); err != nil { + if err := validate.Required("config", "body", m.Config); err != nil { return err } - for i := 0; i < len(m.Peers); i++ { - if swag.IsZero(m.Peers[i]) { // not required - continue - } - - if m.Peers[i] != nil { - if err := m.Peers[i].Validate(formats); err != nil { - if ve, ok := err.(*errors.Validation); ok { - return ve.ValidateName("peers" + "." + strconv.Itoa(i)) - } - return err + if m.Config != nil { + if err := m.Config.Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("config") } + return err } + } + return nil +} + +func (m *AlertmanagerStatus) validateUptime(formats strfmt.Registry) error { + + if err := validate.Required("uptime", "body", m.Uptime); err != nil { + return err + } + + if err := validate.FormatOf("uptime", "body", "date-time", m.Uptime.String(), formats); err != nil { + return err } return nil } -func (m *AlertmanagerStatus) validateStatusInCluster(formats strfmt.Registry) error { +func (m *AlertmanagerStatus) validateVersionInfo(formats strfmt.Registry) error { - if err := validate.Required("statusInCluster", "body", m.StatusInCluster); err != nil { + if err := validate.Required("versionInfo", "body", m.VersionInfo); err != nil { return err } + if m.VersionInfo != nil { + if err := m.VersionInfo.Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("versionInfo") + } + return err + } + } + return nil } diff --git a/api/v2/models/cluster_status.go b/api/v2/models/cluster_status.go new file mode 100644 index 0000000000..2ce826ecca --- /dev/null +++ b/api/v2/models/cluster_status.go @@ -0,0 +1,117 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "strconv" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// ClusterStatus cluster status +// swagger:model clusterStatus +type ClusterStatus struct { + + // name + // Required: true + Name *string `json:"name"` + + // peers + // Required: true + // Minimum: 0 + Peers []*PeerStatus `json:"peers"` + + // status + // Required: true + Status *string `json:"status"` +} + +// Validate validates this cluster status +func (m *ClusterStatus) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateName(formats); err != nil { + res = append(res, err) + } + + if err := m.validatePeers(formats); err != nil { + res = append(res, err) + } + + if err := m.validateStatus(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *ClusterStatus) validateName(formats strfmt.Registry) error { + + if err := validate.Required("name", "body", m.Name); err != nil { + return err + } + + return nil +} + +func (m *ClusterStatus) validatePeers(formats strfmt.Registry) error { + + if err := validate.Required("peers", "body", m.Peers); err != nil { + return err + } + + for i := 0; i < len(m.Peers); i++ { + if swag.IsZero(m.Peers[i]) { // not required + continue + } + + if m.Peers[i] != nil { + if err := m.Peers[i].Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("peers" + "." + strconv.Itoa(i)) + } + return err + } + } + + } + + return nil +} + +func (m *ClusterStatus) validateStatus(formats strfmt.Registry) error { + + if err := validate.Required("status", "body", m.Status); err != nil { + return err + } + + return nil +} + +// MarshalBinary interface implementation +func (m *ClusterStatus) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *ClusterStatus) UnmarshalBinary(b []byte) error { + var res ClusterStatus + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/api/v2/models/gettable_silence.go b/api/v2/models/gettable_silence.go new file mode 100644 index 0000000000..a03412d2b6 --- /dev/null +++ b/api/v2/models/gettable_silence.go @@ -0,0 +1,182 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// GettableSilence gettable silence +// swagger:model gettableSilence +type GettableSilence struct { + + // id + // Required: true + ID *string `json:"id"` + + // status + // Required: true + Status *SilenceStatus `json:"status"` + + // updated at + // Required: true + // Format: date-time + UpdatedAt *strfmt.DateTime `json:"updatedAt"` + + Silence +} + +// UnmarshalJSON unmarshals this object from a JSON structure +func (m *GettableSilence) UnmarshalJSON(raw []byte) error { + // AO0 + var dataAO0 struct { + ID *string `json:"id"` + + Status *SilenceStatus `json:"status"` + + UpdatedAt *strfmt.DateTime `json:"updatedAt"` + } + if err := swag.ReadJSON(raw, &dataAO0); err != nil { + return err + } + + m.ID = dataAO0.ID + + m.Status = dataAO0.Status + + m.UpdatedAt = dataAO0.UpdatedAt + + // AO1 + var aO1 Silence + if err := swag.ReadJSON(raw, &aO1); err != nil { + return err + } + m.Silence = aO1 + + return nil +} + +// MarshalJSON marshals this object to a JSON structure +func (m GettableSilence) MarshalJSON() ([]byte, error) { + _parts := make([][]byte, 0, 2) + + var dataAO0 struct { + ID *string `json:"id"` + + Status *SilenceStatus `json:"status"` + + UpdatedAt *strfmt.DateTime `json:"updatedAt"` + } + + dataAO0.ID = m.ID + + dataAO0.Status = m.Status + + dataAO0.UpdatedAt = m.UpdatedAt + + jsonDataAO0, errAO0 := swag.WriteJSON(dataAO0) + if errAO0 != nil { + return nil, errAO0 + } + _parts = append(_parts, jsonDataAO0) + + aO1, err := swag.WriteJSON(m.Silence) + if err != nil { + return nil, err + } + _parts = append(_parts, aO1) + + return swag.ConcatJSON(_parts...), nil +} + +// Validate validates this gettable silence +func (m *GettableSilence) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateID(formats); err != nil { + res = append(res, err) + } + + if err := m.validateStatus(formats); err != nil { + res = append(res, err) + } + + if err := m.validateUpdatedAt(formats); err != nil { + res = append(res, err) + } + + // validation for a type composition with Silence + if err := m.Silence.Validate(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *GettableSilence) validateID(formats strfmt.Registry) error { + + if err := validate.Required("id", "body", m.ID); err != nil { + return err + } + + return nil +} + +func (m *GettableSilence) validateStatus(formats strfmt.Registry) error { + + if err := validate.Required("status", "body", m.Status); err != nil { + return err + } + + if m.Status != nil { + if err := m.Status.Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("status") + } + return err + } + } + + return nil +} + +func (m *GettableSilence) validateUpdatedAt(formats strfmt.Registry) error { + + if err := validate.Required("updatedAt", "body", m.UpdatedAt); err != nil { + return err + } + + if err := validate.FormatOf("updatedAt", "body", "date-time", m.UpdatedAt.String(), formats); err != nil { + return err + } + + return nil +} + +// MarshalBinary interface implementation +func (m *GettableSilence) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *GettableSilence) UnmarshalBinary(b []byte) error { + var res GettableSilence + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/api/v2/models/silences.go b/api/v2/models/gettable_silences.go similarity index 75% rename from api/v2/models/silences.go rename to api/v2/models/gettable_silences.go index 0906a700f8..3993a967da 100644 --- a/api/v2/models/silences.go +++ b/api/v2/models/gettable_silences.go @@ -14,12 +14,12 @@ import ( "github.com/go-openapi/swag" ) -// Silences silences -// swagger:model silences -type Silences []*Silence +// GettableSilences gettable silences +// swagger:model gettableSilences +type GettableSilences []*GettableSilence -// Validate validates this silences -func (m Silences) Validate(formats strfmt.Registry) error { +// Validate validates this gettable silences +func (m GettableSilences) Validate(formats strfmt.Registry) error { var res []error for i := 0; i < len(m); i++ { diff --git a/api/v2/models/matcher.go b/api/v2/models/matcher.go index f626e306a8..78bc819472 100644 --- a/api/v2/models/matcher.go +++ b/api/v2/models/matcher.go @@ -8,7 +8,9 @@ package models import ( strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/errors" "github.com/go-openapi/swag" + "github.com/go-openapi/validate" ) // Matcher matcher @@ -16,20 +18,64 @@ import ( type Matcher struct { // is regex - IsRegex bool `json:"isRegex,omitempty"` + // Required: true + IsRegex *bool `json:"isRegex"` // name - Name string `json:"name,omitempty"` - - // regex - Regex string `json:"regex,omitempty"` + // Required: true + Name *string `json:"name"` // value - Value string `json:"value,omitempty"` + // Required: true + Value *string `json:"value"` } // Validate validates this matcher func (m *Matcher) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateIsRegex(formats); err != nil { + res = append(res, err) + } + + if err := m.validateName(formats); err != nil { + res = append(res, err) + } + + if err := m.validateValue(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Matcher) validateIsRegex(formats strfmt.Registry) error { + + if err := validate.Required("isRegex", "body", m.IsRegex); err != nil { + return err + } + + return nil +} + +func (m *Matcher) validateName(formats strfmt.Registry) error { + + if err := validate.Required("name", "body", m.Name); err != nil { + return err + } + + return nil +} + +func (m *Matcher) validateValue(formats strfmt.Registry) error { + + if err := validate.Required("value", "body", m.Value); err != nil { + return err + } + return nil } diff --git a/api/v2/models/peer_status.go b/api/v2/models/peer_status.go index ddfd58b18f..9d9c34f404 100644 --- a/api/v2/models/peer_status.go +++ b/api/v2/models/peer_status.go @@ -8,7 +8,9 @@ package models import ( strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/errors" "github.com/go-openapi/swag" + "github.com/go-openapi/validate" ) // PeerStatus peer status @@ -16,14 +18,47 @@ import ( type PeerStatus struct { // address - Address string `json:"address,omitempty"` + // Required: true + Address *string `json:"address"` // name - Name string `json:"name,omitempty"` + // Required: true + Name *string `json:"name"` } // Validate validates this peer status func (m *PeerStatus) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateAddress(formats); err != nil { + res = append(res, err) + } + + if err := m.validateName(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *PeerStatus) validateAddress(formats strfmt.Registry) error { + + if err := validate.Required("address", "body", m.Address); err != nil { + return err + } + + return nil +} + +func (m *PeerStatus) validateName(formats strfmt.Registry) error { + + if err := validate.Required("name", "body", m.Name); err != nil { + return err + } + return nil } diff --git a/api/v2/models/postable_silence.go b/api/v2/models/postable_silence.go new file mode 100644 index 0000000000..1fa1fb2910 --- /dev/null +++ b/api/v2/models/postable_silence.go @@ -0,0 +1,103 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/swag" +) + +// PostableSilence postable silence +// swagger:model postableSilence +type PostableSilence struct { + + // id + ID string `json:"id,omitempty"` + + Silence +} + +// UnmarshalJSON unmarshals this object from a JSON structure +func (m *PostableSilence) UnmarshalJSON(raw []byte) error { + // AO0 + var dataAO0 struct { + ID string `json:"id,omitempty"` + } + if err := swag.ReadJSON(raw, &dataAO0); err != nil { + return err + } + + m.ID = dataAO0.ID + + // AO1 + var aO1 Silence + if err := swag.ReadJSON(raw, &aO1); err != nil { + return err + } + m.Silence = aO1 + + return nil +} + +// MarshalJSON marshals this object to a JSON structure +func (m PostableSilence) MarshalJSON() ([]byte, error) { + _parts := make([][]byte, 0, 2) + + var dataAO0 struct { + ID string `json:"id,omitempty"` + } + + dataAO0.ID = m.ID + + jsonDataAO0, errAO0 := swag.WriteJSON(dataAO0) + if errAO0 != nil { + return nil, errAO0 + } + _parts = append(_parts, jsonDataAO0) + + aO1, err := swag.WriteJSON(m.Silence) + if err != nil { + return nil, err + } + _parts = append(_parts, aO1) + + return swag.ConcatJSON(_parts...), nil +} + +// Validate validates this postable silence +func (m *PostableSilence) Validate(formats strfmt.Registry) error { + var res []error + + // validation for a type composition with Silence + if err := m.Silence.Validate(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +// MarshalBinary interface implementation +func (m *PostableSilence) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *PostableSilence) UnmarshalBinary(b []byte) error { + var res PostableSilence + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/api/v2/models/receiver.go b/api/v2/models/receiver.go index e7ceccef43..61c2748a55 100644 --- a/api/v2/models/receiver.go +++ b/api/v2/models/receiver.go @@ -8,7 +8,9 @@ package models import ( strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/errors" "github.com/go-openapi/swag" + "github.com/go-openapi/validate" ) // Receiver receiver @@ -16,11 +18,30 @@ import ( type Receiver struct { // name - Name string `json:"name,omitempty"` + // Required: true + Name *string `json:"name"` } // Validate validates this receiver func (m *Receiver) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateName(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Receiver) validateName(formats strfmt.Registry) error { + + if err := validate.Required("name", "body", m.Name); err != nil { + return err + } + return nil } diff --git a/api/v2/models/silence.go b/api/v2/models/silence.go index 747edcfa35..742ba17d78 100644 --- a/api/v2/models/silence.go +++ b/api/v2/models/silence.go @@ -6,8 +6,6 @@ package models // Editing this file might prove futile when you re-run the swagger generate command import ( - "encoding/json" - strfmt "github.com/go-openapi/strfmt" "github.com/go-openapi/errors" @@ -20,55 +18,49 @@ import ( type Silence struct { // comment - Comment string `json:"comment,omitempty"` + // Required: true + Comment *string `json:"comment"` // created by - CreatedBy string `json:"createdBy,omitempty"` + // Required: true + CreatedBy *string `json:"createdBy"` // ends at + // Required: true // Format: date-time - EndsAt strfmt.DateTime `json:"endsAt,omitempty"` - - // id - ID string `json:"id,omitempty"` + EndsAt *strfmt.DateTime `json:"endsAt"` // matchers // Required: true Matchers Matchers `json:"matchers"` // starts at + // Required: true // Format: date-time - StartsAt strfmt.DateTime `json:"startsAt,omitempty"` - - // status - Status *SilenceStatus `json:"status,omitempty"` - - // updated at - // Format: date-time - UpdatedAt strfmt.DateTime `json:"updatedAt,omitempty"` + StartsAt *strfmt.DateTime `json:"startsAt"` } // Validate validates this silence func (m *Silence) Validate(formats strfmt.Registry) error { var res []error - if err := m.validateEndsAt(formats); err != nil { + if err := m.validateComment(formats); err != nil { res = append(res, err) } - if err := m.validateMatchers(formats); err != nil { + if err := m.validateCreatedBy(formats); err != nil { res = append(res, err) } - if err := m.validateStartsAt(formats); err != nil { + if err := m.validateEndsAt(formats); err != nil { res = append(res, err) } - if err := m.validateStatus(formats); err != nil { + if err := m.validateMatchers(formats); err != nil { res = append(res, err) } - if err := m.validateUpdatedAt(formats); err != nil { + if err := m.validateStartsAt(formats); err != nil { res = append(res, err) } @@ -78,73 +70,60 @@ func (m *Silence) Validate(formats strfmt.Registry) error { return nil } -func (m *Silence) validateEndsAt(formats strfmt.Registry) error { - - if swag.IsZero(m.EndsAt) { // not required - return nil - } +func (m *Silence) validateComment(formats strfmt.Registry) error { - if err := validate.FormatOf("endsAt", "body", "date-time", m.EndsAt.String(), formats); err != nil { + if err := validate.Required("comment", "body", m.Comment); err != nil { return err } return nil } -func (m *Silence) validateMatchers(formats strfmt.Registry) error { - - if err := validate.Required("matchers", "body", m.Matchers); err != nil { - return err - } +func (m *Silence) validateCreatedBy(formats strfmt.Registry) error { - if err := m.Matchers.Validate(formats); err != nil { - if ve, ok := err.(*errors.Validation); ok { - return ve.ValidateName("matchers") - } + if err := validate.Required("createdBy", "body", m.CreatedBy); err != nil { return err } return nil } -func (m *Silence) validateStartsAt(formats strfmt.Registry) error { +func (m *Silence) validateEndsAt(formats strfmt.Registry) error { - if swag.IsZero(m.StartsAt) { // not required - return nil + if err := validate.Required("endsAt", "body", m.EndsAt); err != nil { + return err } - if err := validate.FormatOf("startsAt", "body", "date-time", m.StartsAt.String(), formats); err != nil { + if err := validate.FormatOf("endsAt", "body", "date-time", m.EndsAt.String(), formats); err != nil { return err } return nil } -func (m *Silence) validateStatus(formats strfmt.Registry) error { +func (m *Silence) validateMatchers(formats strfmt.Registry) error { - if swag.IsZero(m.Status) { // not required - return nil + if err := validate.Required("matchers", "body", m.Matchers); err != nil { + return err } - if m.Status != nil { - if err := m.Status.Validate(formats); err != nil { - if ve, ok := err.(*errors.Validation); ok { - return ve.ValidateName("status") - } - return err + if err := m.Matchers.Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("matchers") } + return err } return nil } -func (m *Silence) validateUpdatedAt(formats strfmt.Registry) error { +func (m *Silence) validateStartsAt(formats strfmt.Registry) error { - if swag.IsZero(m.UpdatedAt) { // not required - return nil + if err := validate.Required("startsAt", "body", m.StartsAt); err != nil { + return err } - if err := validate.FormatOf("updatedAt", "body", "date-time", m.UpdatedAt.String(), formats); err != nil { + if err := validate.FormatOf("startsAt", "body", "date-time", m.StartsAt.String(), formats); err != nil { return err } @@ -168,90 +147,3 @@ func (m *Silence) UnmarshalBinary(b []byte) error { *m = res return nil } - -// SilenceStatus silence status -// swagger:model SilenceStatus -type SilenceStatus struct { - - // state - // Enum: [expired active pending] - State string `json:"state,omitempty"` -} - -// Validate validates this silence status -func (m *SilenceStatus) Validate(formats strfmt.Registry) error { - var res []error - - if err := m.validateState(formats); err != nil { - res = append(res, err) - } - - if len(res) > 0 { - return errors.CompositeValidationError(res...) - } - return nil -} - -var silenceStatusTypeStatePropEnum []interface{} - -func init() { - var res []string - if err := json.Unmarshal([]byte(`["expired","active","pending"]`), &res); err != nil { - panic(err) - } - for _, v := range res { - silenceStatusTypeStatePropEnum = append(silenceStatusTypeStatePropEnum, v) - } -} - -const ( - - // SilenceStatusStateExpired captures enum value "expired" - SilenceStatusStateExpired string = "expired" - - // SilenceStatusStateActive captures enum value "active" - SilenceStatusStateActive string = "active" - - // SilenceStatusStatePending captures enum value "pending" - SilenceStatusStatePending string = "pending" -) - -// prop value enum -func (m *SilenceStatus) validateStateEnum(path, location string, value string) error { - if err := validate.Enum(path, location, value, silenceStatusTypeStatePropEnum); err != nil { - return err - } - return nil -} - -func (m *SilenceStatus) validateState(formats strfmt.Registry) error { - - if swag.IsZero(m.State) { // not required - return nil - } - - // value enum - if err := m.validateStateEnum("status"+"."+"state", "body", m.State); err != nil { - return err - } - - return nil -} - -// MarshalBinary interface implementation -func (m *SilenceStatus) MarshalBinary() ([]byte, error) { - if m == nil { - return nil, nil - } - return swag.WriteJSON(m) -} - -// UnmarshalBinary interface implementation -func (m *SilenceStatus) UnmarshalBinary(b []byte) error { - var res SilenceStatus - if err := swag.ReadJSON(b, &res); err != nil { - return err - } - *m = res - return nil -} diff --git a/api/v2/models/silence_status.go b/api/v2/models/silence_status.go new file mode 100644 index 0000000000..82c9b435de --- /dev/null +++ b/api/v2/models/silence_status.go @@ -0,0 +1,104 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// SilenceStatus silence status +// swagger:model silenceStatus +type SilenceStatus struct { + + // state + // Required: true + // Enum: [expired active pending] + State *string `json:"state"` +} + +// Validate validates this silence status +func (m *SilenceStatus) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateState(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +var silenceStatusTypeStatePropEnum []interface{} + +func init() { + var res []string + if err := json.Unmarshal([]byte(`["expired","active","pending"]`), &res); err != nil { + panic(err) + } + for _, v := range res { + silenceStatusTypeStatePropEnum = append(silenceStatusTypeStatePropEnum, v) + } +} + +const ( + + // SilenceStatusStateExpired captures enum value "expired" + SilenceStatusStateExpired string = "expired" + + // SilenceStatusStateActive captures enum value "active" + SilenceStatusStateActive string = "active" + + // SilenceStatusStatePending captures enum value "pending" + SilenceStatusStatePending string = "pending" +) + +// prop value enum +func (m *SilenceStatus) validateStateEnum(path, location string, value string) error { + if err := validate.Enum(path, location, value, silenceStatusTypeStatePropEnum); err != nil { + return err + } + return nil +} + +func (m *SilenceStatus) validateState(formats strfmt.Registry) error { + + if err := validate.Required("state", "body", m.State); err != nil { + return err + } + + // value enum + if err := m.validateStateEnum("state", "body", *m.State); err != nil { + return err + } + + return nil +} + +// MarshalBinary interface implementation +func (m *SilenceStatus) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *SilenceStatus) UnmarshalBinary(b []byte) error { + var res SilenceStatus + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/api/v2/models/version_info.go b/api/v2/models/version_info.go new file mode 100644 index 0000000000..5cdbc2bdd5 --- /dev/null +++ b/api/v2/models/version_info.go @@ -0,0 +1,149 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// VersionInfo version info +// swagger:model versionInfo +type VersionInfo struct { + + // branch + // Required: true + Branch *string `json:"branch"` + + // build date + // Required: true + BuildDate *string `json:"buildDate"` + + // build user + // Required: true + BuildUser *string `json:"buildUser"` + + // go version + // Required: true + GoVersion *string `json:"goVersion"` + + // revision + // Required: true + Revision *string `json:"revision"` + + // version + // Required: true + Version *string `json:"version"` +} + +// Validate validates this version info +func (m *VersionInfo) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateBranch(formats); err != nil { + res = append(res, err) + } + + if err := m.validateBuildDate(formats); err != nil { + res = append(res, err) + } + + if err := m.validateBuildUser(formats); err != nil { + res = append(res, err) + } + + if err := m.validateGoVersion(formats); err != nil { + res = append(res, err) + } + + if err := m.validateRevision(formats); err != nil { + res = append(res, err) + } + + if err := m.validateVersion(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *VersionInfo) validateBranch(formats strfmt.Registry) error { + + if err := validate.Required("branch", "body", m.Branch); err != nil { + return err + } + + return nil +} + +func (m *VersionInfo) validateBuildDate(formats strfmt.Registry) error { + + if err := validate.Required("buildDate", "body", m.BuildDate); err != nil { + return err + } + + return nil +} + +func (m *VersionInfo) validateBuildUser(formats strfmt.Registry) error { + + if err := validate.Required("buildUser", "body", m.BuildUser); err != nil { + return err + } + + return nil +} + +func (m *VersionInfo) validateGoVersion(formats strfmt.Registry) error { + + if err := validate.Required("goVersion", "body", m.GoVersion); err != nil { + return err + } + + return nil +} + +func (m *VersionInfo) validateRevision(formats strfmt.Registry) error { + + if err := validate.Required("revision", "body", m.Revision); err != nil { + return err + } + + return nil +} + +func (m *VersionInfo) validateVersion(formats strfmt.Registry) error { + + if err := validate.Required("version", "body", m.Version); err != nil { + return err + } + + return nil +} + +// MarshalBinary interface implementation +func (m *VersionInfo) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *VersionInfo) UnmarshalBinary(b []byte) error { + var res VersionInfo + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/api/v2/openapi.yaml b/api/v2/openapi.yaml index 41b87eb940..a0062e0340 100644 --- a/api/v2/openapi.yaml +++ b/api/v2/openapi.yaml @@ -50,7 +50,7 @@ paths: '200': description: Get silences response schema: - $ref: '#/definitions/silences' + $ref: '#/definitions/gettableSilences' '500': $ref: '#/responses/InternalServerError' parameters: @@ -72,7 +72,7 @@ paths: description: The silence to create required: true schema: - $ref: '#/definitions/silence' + $ref: '#/definitions/postableSilence' responses: '200': description: Create / update silence response @@ -100,7 +100,7 @@ paths: '200': description: Get silence response schema: - $ref: '#/definitions/silence' + $ref: '#/definitions/gettableSilence' '404': description: A silence with the specified ID was not found '500': @@ -205,11 +205,28 @@ responses: definitions: alertmanagerStatus: + type: object + properties: + cluster: + $ref: '#/definitions/clusterStatus' + versionInfo: + $ref: '#/definitions/versionInfo' + config: + $ref: '#/definitions/alertmanagerConfig' + uptime: + type: string + format: date-time + required: + - cluster + - versionInfo + - config + - uptime + clusterStatus: type: object properties: name: type: string - statusInCluster: + status: type: string peers: type: array @@ -218,8 +235,37 @@ definitions: $ref: '#/definitions/peerStatus' required: - name - - statusInCluster + - status - peers + alertmanagerConfig: + type: object + properties: + original: + type: string + required: + - original + versionInfo: + type: object + properties: + version: + type: string + revision: + type: string + branch: + type: string + buildUser: + type: string + buildDate: + type: string + goVersion: + type: string + required: + - version + - revision + - branch + - buildUser + - buildDate + - goVersion peerStatus: type: object properties: @@ -227,11 +273,12 @@ definitions: type: string address: type: string + required: + - name + - address silence: type: object properties: - id: - type: string matchers: $ref: '#/definitions/matchers' startsAt: @@ -240,25 +287,51 @@ definitions: endsAt: type: string format: date-time - updatedAt: - type: string - format: date-time createdBy: type: string comment: type: string - status: - type: object + required: + - matchers + - startsAt + - endsAt + - createdBy + - comment + gettableSilence: + allOf: + - type: object properties: - state: + id: + type: string + status: + $ref: '#/definitions/silenceStatus' + updatedAt: type: string - enum: ["expired", "active", "pending"] + format: date-time + required: + - id + - status + - updatedAt + - $ref: '#/definitions/silence' + postableSilence: + allOf: + - type: object + properties: + id: + type: string + - $ref: '#/definitions/silence' + silenceStatus: + type: object + properties: + state: + type: string + enum: ["expired", "active", "pending"] required: - - matchers - silences: + - state + gettableSilences: type: array items: - $ref: '#/definitions/silence' + $ref: '#/definitions/gettableSilence' matchers: type: array items: @@ -273,8 +346,10 @@ definitions: type: string isRegex: type: boolean - regex: - type: string + required: + - name + - value + - isRegex # Define required properties for 'alert' alerts: type: array @@ -306,24 +381,34 @@ definitions: fingerprint: type: string status: - type: object - properties: - state: - type: string - enum: ['unprocessed', 'active', 'suppressed'] - silencedBy: - type: array - items: - type: string - inhibitedBy: - type: array - items: - type: string + $ref: '#/definitions/alertStatus' + required: + - labels + alertStatus: + type: object + properties: + state: + type: string + enum: ['unprocessed', 'active', 'suppressed'] + silencedBy: + type: array + items: + type: string + inhibitedBy: + type: array + items: + type: string + required: + - state + - silencedBy + - inhibitedBy receiver: type: object properties: name: type: string + required: + - name labelSet: type: object additionalProperties: diff --git a/api/v2/restapi/embedded_spec.go b/api/v2/restapi/embedded_spec.go index 4720c7512d..53041cb8db 100644 --- a/api/v2/restapi/embedded_spec.go +++ b/api/v2/restapi/embedded_spec.go @@ -166,7 +166,7 @@ func init() { "200": { "description": "Get silence response", "schema": { - "$ref": "#/definitions/silence" + "$ref": "#/definitions/gettableSilence" } }, "404": { @@ -235,7 +235,7 @@ func init() { "200": { "description": "Get silences response", "schema": { - "$ref": "#/definitions/silences" + "$ref": "#/definitions/gettableSilences" } }, "500": { @@ -256,7 +256,7 @@ func init() { "in": "body", "required": true, "schema": { - "$ref": "#/definitions/silence" + "$ref": "#/definitions/postableSilence" } } ], @@ -299,6 +299,9 @@ func init() { "definitions": { "alert": { "type": "object", + "required": [ + "labels" + ], "properties": { "annotations": { "$ref": "#/definitions/labelSet" @@ -328,29 +331,7 @@ func init() { "format": "date-time" }, "status": { - "type": "object", - "properties": { - "inhibitedBy": { - "type": "array", - "items": { - "type": "string" - } - }, - "silencedBy": { - "type": "array", - "items": { - "type": "string" - } - }, - "state": { - "type": "string", - "enum": [ - "unprocessed", - "active", - "suppressed" - ] - } - } + "$ref": "#/definitions/alertStatus" }, "updatedAt": { "type": "string", @@ -358,11 +339,82 @@ func init() { } } }, + "alertStatus": { + "type": "object", + "required": [ + "state", + "silencedBy", + "inhibitedBy" + ], + "properties": { + "inhibitedBy": { + "type": "array", + "items": { + "type": "string" + } + }, + "silencedBy": { + "type": "array", + "items": { + "type": "string" + } + }, + "state": { + "type": "string", + "enum": [ + "unprocessed", + "active", + "suppressed" + ] + } + } + }, + "alertmanagerConfig": { + "type": "object", + "required": [ + "original" + ], + "properties": { + "original": { + "type": "string" + } + } + }, "alertmanagerStatus": { + "type": "object", + "required": [ + "cluster", + "versionInfo", + "config", + "uptime" + ], + "properties": { + "cluster": { + "$ref": "#/definitions/clusterStatus" + }, + "config": { + "$ref": "#/definitions/alertmanagerConfig" + }, + "uptime": { + "type": "string", + "format": "date-time" + }, + "versionInfo": { + "$ref": "#/definitions/versionInfo" + } + } + }, + "alerts": { + "type": "array", + "items": { + "$ref": "#/definitions/alert" + } + }, + "clusterStatus": { "type": "object", "required": [ "name", - "statusInCluster", + "status", "peers" ], "properties": { @@ -376,15 +428,42 @@ func init() { "$ref": "#/definitions/peerStatus" } }, - "statusInCluster": { + "status": { "type": "string" } } }, - "alerts": { + "gettableSilence": { + "allOf": [ + { + "type": "object", + "required": [ + "id", + "status", + "updatedAt" + ], + "properties": { + "id": { + "type": "string" + }, + "status": { + "$ref": "#/definitions/silenceStatus" + }, + "updatedAt": { + "type": "string", + "format": "date-time" + } + } + }, + { + "$ref": "#/definitions/silence" + } + ] + }, + "gettableSilences": { "type": "array", "items": { - "$ref": "#/definitions/alert" + "$ref": "#/definitions/gettableSilence" } }, "labelSet": { @@ -395,6 +474,11 @@ func init() { }, "matcher": { "type": "object", + "required": [ + "name", + "value", + "isRegex" + ], "properties": { "isRegex": { "type": "boolean" @@ -402,9 +486,6 @@ func init() { "name": { "type": "string" }, - "regex": { - "type": "string" - }, "value": { "type": "string" } @@ -419,6 +500,10 @@ func init() { }, "peerStatus": { "type": "object", + "required": [ + "name", + "address" + ], "properties": { "address": { "type": "string" @@ -428,8 +513,26 @@ func init() { } } }, + "postableSilence": { + "allOf": [ + { + "type": "object", + "properties": { + "id": { + "type": "string" + } + } + }, + { + "$ref": "#/definitions/silence" + } + ] + }, "receiver": { "type": "object", + "required": [ + "name" + ], "properties": { "name": { "type": "string" @@ -439,7 +542,11 @@ func init() { "silence": { "type": "object", "required": [ - "matchers" + "matchers", + "startsAt", + "endsAt", + "createdBy", + "comment" ], "properties": { "comment": { @@ -452,39 +559,60 @@ func init() { "type": "string", "format": "date-time" }, - "id": { - "type": "string" - }, "matchers": { "$ref": "#/definitions/matchers" }, "startsAt": { "type": "string", "format": "date-time" - }, - "status": { - "type": "object", - "properties": { - "state": { - "type": "string", - "enum": [ - "expired", - "active", - "pending" - ] - } - } - }, - "updatedAt": { + } + } + }, + "silenceStatus": { + "type": "object", + "required": [ + "state" + ], + "properties": { + "state": { "type": "string", - "format": "date-time" + "enum": [ + "expired", + "active", + "pending" + ] } } }, - "silences": { - "type": "array", - "items": { - "$ref": "#/definitions/silence" + "versionInfo": { + "type": "object", + "required": [ + "version", + "revision", + "branch", + "buildUser", + "buildDate", + "goVersion" + ], + "properties": { + "branch": { + "type": "string" + }, + "buildDate": { + "type": "string" + }, + "buildUser": { + "type": "string" + }, + "goVersion": { + "type": "string" + }, + "revision": { + "type": "string" + }, + "version": { + "type": "string" + } } } }, @@ -682,7 +810,7 @@ func init() { "200": { "description": "Get silence response", "schema": { - "$ref": "#/definitions/silence" + "$ref": "#/definitions/gettableSilence" } }, "404": { @@ -757,7 +885,7 @@ func init() { "200": { "description": "Get silences response", "schema": { - "$ref": "#/definitions/silences" + "$ref": "#/definitions/gettableSilences" } }, "500": { @@ -781,7 +909,7 @@ func init() { "in": "body", "required": true, "schema": { - "$ref": "#/definitions/silence" + "$ref": "#/definitions/postableSilence" } } ], @@ -827,6 +955,9 @@ func init() { "definitions": { "alert": { "type": "object", + "required": [ + "labels" + ], "properties": { "annotations": { "$ref": "#/definitions/labelSet" @@ -856,29 +987,7 @@ func init() { "format": "date-time" }, "status": { - "type": "object", - "properties": { - "inhibitedBy": { - "type": "array", - "items": { - "type": "string" - } - }, - "silencedBy": { - "type": "array", - "items": { - "type": "string" - } - }, - "state": { - "type": "string", - "enum": [ - "unprocessed", - "active", - "suppressed" - ] - } - } + "$ref": "#/definitions/alertStatus" }, "updatedAt": { "type": "string", @@ -886,11 +995,82 @@ func init() { } } }, + "alertStatus": { + "type": "object", + "required": [ + "state", + "silencedBy", + "inhibitedBy" + ], + "properties": { + "inhibitedBy": { + "type": "array", + "items": { + "type": "string" + } + }, + "silencedBy": { + "type": "array", + "items": { + "type": "string" + } + }, + "state": { + "type": "string", + "enum": [ + "unprocessed", + "active", + "suppressed" + ] + } + } + }, + "alertmanagerConfig": { + "type": "object", + "required": [ + "original" + ], + "properties": { + "original": { + "type": "string" + } + } + }, "alertmanagerStatus": { + "type": "object", + "required": [ + "cluster", + "versionInfo", + "config", + "uptime" + ], + "properties": { + "cluster": { + "$ref": "#/definitions/clusterStatus" + }, + "config": { + "$ref": "#/definitions/alertmanagerConfig" + }, + "uptime": { + "type": "string", + "format": "date-time" + }, + "versionInfo": { + "$ref": "#/definitions/versionInfo" + } + } + }, + "alerts": { + "type": "array", + "items": { + "$ref": "#/definitions/alert" + } + }, + "clusterStatus": { "type": "object", "required": [ "name", - "statusInCluster", + "status", "peers" ], "properties": { @@ -904,15 +1084,42 @@ func init() { "$ref": "#/definitions/peerStatus" } }, - "statusInCluster": { + "status": { "type": "string" } } }, - "alerts": { + "gettableSilence": { + "allOf": [ + { + "type": "object", + "required": [ + "id", + "status", + "updatedAt" + ], + "properties": { + "id": { + "type": "string" + }, + "status": { + "$ref": "#/definitions/silenceStatus" + }, + "updatedAt": { + "type": "string", + "format": "date-time" + } + } + }, + { + "$ref": "#/definitions/silence" + } + ] + }, + "gettableSilences": { "type": "array", "items": { - "$ref": "#/definitions/alert" + "$ref": "#/definitions/gettableSilence" } }, "labelSet": { @@ -923,6 +1130,11 @@ func init() { }, "matcher": { "type": "object", + "required": [ + "name", + "value", + "isRegex" + ], "properties": { "isRegex": { "type": "boolean" @@ -930,9 +1142,6 @@ func init() { "name": { "type": "string" }, - "regex": { - "type": "string" - }, "value": { "type": "string" } @@ -947,6 +1156,10 @@ func init() { }, "peerStatus": { "type": "object", + "required": [ + "name", + "address" + ], "properties": { "address": { "type": "string" @@ -956,8 +1169,26 @@ func init() { } } }, + "postableSilence": { + "allOf": [ + { + "type": "object", + "properties": { + "id": { + "type": "string" + } + } + }, + { + "$ref": "#/definitions/silence" + } + ] + }, "receiver": { "type": "object", + "required": [ + "name" + ], "properties": { "name": { "type": "string" @@ -967,7 +1198,11 @@ func init() { "silence": { "type": "object", "required": [ - "matchers" + "matchers", + "startsAt", + "endsAt", + "createdBy", + "comment" ], "properties": { "comment": { @@ -980,39 +1215,60 @@ func init() { "type": "string", "format": "date-time" }, - "id": { - "type": "string" - }, "matchers": { "$ref": "#/definitions/matchers" }, "startsAt": { "type": "string", "format": "date-time" - }, - "status": { - "type": "object", - "properties": { - "state": { - "type": "string", - "enum": [ - "expired", - "active", - "pending" - ] - } - } - }, - "updatedAt": { + } + } + }, + "silenceStatus": { + "type": "object", + "required": [ + "state" + ], + "properties": { + "state": { "type": "string", - "format": "date-time" + "enum": [ + "expired", + "active", + "pending" + ] } } }, - "silences": { - "type": "array", - "items": { - "$ref": "#/definitions/silence" + "versionInfo": { + "type": "object", + "required": [ + "version", + "revision", + "branch", + "buildUser", + "buildDate", + "goVersion" + ], + "properties": { + "branch": { + "type": "string" + }, + "buildDate": { + "type": "string" + }, + "buildUser": { + "type": "string" + }, + "goVersion": { + "type": "string" + }, + "revision": { + "type": "string" + }, + "version": { + "type": "string" + } } } }, diff --git a/api/v2/restapi/operations/silence/get_silence_responses.go b/api/v2/restapi/operations/silence/get_silence_responses.go index 82e9f6f52e..55fc4377eb 100644 --- a/api/v2/restapi/operations/silence/get_silence_responses.go +++ b/api/v2/restapi/operations/silence/get_silence_responses.go @@ -25,7 +25,7 @@ type GetSilenceOK struct { /* In: Body */ - Payload *models.Silence `json:"body,omitempty"` + Payload *models.GettableSilence `json:"body,omitempty"` } // NewGetSilenceOK creates GetSilenceOK with default headers values @@ -35,13 +35,13 @@ func NewGetSilenceOK() *GetSilenceOK { } // WithPayload adds the payload to the get silence o k response -func (o *GetSilenceOK) WithPayload(payload *models.Silence) *GetSilenceOK { +func (o *GetSilenceOK) WithPayload(payload *models.GettableSilence) *GetSilenceOK { o.Payload = payload return o } // SetPayload sets the payload to the get silence o k response -func (o *GetSilenceOK) SetPayload(payload *models.Silence) { +func (o *GetSilenceOK) SetPayload(payload *models.GettableSilence) { o.Payload = payload } diff --git a/api/v2/restapi/operations/silence/get_silences_responses.go b/api/v2/restapi/operations/silence/get_silences_responses.go index 175b72ffa3..4de24c6c22 100644 --- a/api/v2/restapi/operations/silence/get_silences_responses.go +++ b/api/v2/restapi/operations/silence/get_silences_responses.go @@ -25,7 +25,7 @@ type GetSilencesOK struct { /* In: Body */ - Payload models.Silences `json:"body,omitempty"` + Payload models.GettableSilences `json:"body,omitempty"` } // NewGetSilencesOK creates GetSilencesOK with default headers values @@ -35,13 +35,13 @@ func NewGetSilencesOK() *GetSilencesOK { } // WithPayload adds the payload to the get silences o k response -func (o *GetSilencesOK) WithPayload(payload models.Silences) *GetSilencesOK { +func (o *GetSilencesOK) WithPayload(payload models.GettableSilences) *GetSilencesOK { o.Payload = payload return o } // SetPayload sets the payload to the get silences o k response -func (o *GetSilencesOK) SetPayload(payload models.Silences) { +func (o *GetSilencesOK) SetPayload(payload models.GettableSilences) { o.Payload = payload } @@ -51,7 +51,7 @@ func (o *GetSilencesOK) WriteResponse(rw http.ResponseWriter, producer runtime.P rw.WriteHeader(200) payload := o.Payload if payload == nil { - payload = make(models.Silences, 0, 50) + payload = make(models.GettableSilences, 0, 50) } if err := producer.Produce(rw, payload); err != nil { diff --git a/api/v2/restapi/operations/silence/post_silences_parameters.go b/api/v2/restapi/operations/silence/post_silences_parameters.go index 3fba5a4215..843973690e 100644 --- a/api/v2/restapi/operations/silence/post_silences_parameters.go +++ b/api/v2/restapi/operations/silence/post_silences_parameters.go @@ -36,7 +36,7 @@ type PostSilencesParams struct { Required: true In: body */ - Silence *models.Silence + Silence *models.PostableSilence } // BindRequest both binds and validates a request, it assumes that complex things implement a Validatable(strfmt.Registry) error interface @@ -50,7 +50,7 @@ func (o *PostSilencesParams) BindRequest(r *http.Request, route *middleware.Matc if runtime.HasBody(r) { defer r.Body.Close() - var body models.Silence + var body models.PostableSilence if err := route.Consumer.Consume(r.Body, &body); err != nil { if err == io.EOF { res = append(res, errors.Required("silence", "body")) diff --git a/asset/assets_vfsdata.go b/asset/assets_vfsdata.go index b1b49d463f..c3adb6373a 100644 --- a/asset/assets_vfsdata.go +++ b/asset/assets_vfsdata.go @@ -136,9 +136,9 @@ var Assets = func() http.FileSystem { "/static/script.js": &vfsgenÛ°CompressedFileInfo{ name: "script.js", modTime: time.Date(1970, 1, 1, 0, 0, 1, 0, time.UTC), - uncompressedSize: 93828, + uncompressedSize: 93840, - compressedContent: []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\xfd\x0b\x5f\xdb\x38\xb7\x28\x8c\x7f\x15\xf0\xc9\xce\x48\x93\x85\x9b\x70\x6b\xeb\xa0\x27\xff\x96\xd2\x96\x19\x4a\x3b\x94\xde\x86\x61\x73\x64\x47\x06\xb7\x41\xa6\x8a\x4c\xa0\xc4\xfb\xb3\xff\x7f\x5a\xf2\x35\xb1\xd3\x3e\x67\xef\xf3\xbe\xef\xde\xf3\x50\xc7\x92\x96\x96\x6e\xeb\xae\xe5\xf5\x30\x91\x81\x8e\x62\x49\x24\x7d\x70\x92\xa9\x58\x9b\x6a\x15\x05\xda\x19\xe6\x05\x6b\x8a\x48\x50\xa0\xe9\x83\x12\x3a\x51\x72\x4d\xbb\x9c\x49\xd0\x6e\xc8\x14\xe8\xb4\xa8\x36\x25\x65\x15\x45\x36\x41\x43\x01\x5a\x15\x05\xd5\xde\x72\x70\x44\x81\xa4\x69\x4a\x4b\x50\x82\x88\x0a\xa8\x2d\x10\x25\x28\xbd\x0c\x6a\x25\x74\x41\x34\x58\xf8\xd5\x0e\x34\x49\x2a\x1d\x6c\x43\x52\x76\x20\x96\xa1\xfd\xbb\x7d\x26\x44\x40\xd1\x6b\xb5\xdb\x88\xf0\x4a\xb7\x3b\xc0\xcb\x6e\x93\x65\x80\xff\x03\x98\x70\x92\x40\x15\x97\x2a\x32\x09\x09\x2a\xc8\xec\x42\x50\x22\xc3\x97\x61\xfe\xdf\xc1\x2f\x20\x1c\x16\x30\xac\xa2\xc8\x49\x54\x41\xf1\x31\x44\x25\x8a\xc1\x32\xd8\xff\xc7\xb0\x8e\x48\x00\xcb\x78\x57\x11\x0f\x48\x5c\x41\xfc\x09\xc4\x25\xe2\xd1\x32\xe4\xff\x37\xc7\x12\x93\x08\x1a\x47\x53\x1d\x4e\x4c\xc2\xca\x70\x9e\x42\x58\x0e\x27\x5e\x06\xfe\xff\xb1\x11\x86\x24\x86\xb6\x31\x56\x07\x39\x5b\x20\x73\x9b\x8c\x31\xe9\xf2\x91\x74\x43\x62\xde\x7b\xa6\x1f\xa2\x2b\x2d\xee\x6d\x0b\x28\x91\xdc\xaa\xb7\x01\x51\xb4\x22\xa2\xd2\xf0\x20\x6f\x08\xe5\x90\xb7\x17\x9b\x42\x52\x6d\x4c\x92\x4a\xfb\xbb\xb2\x3d\x94\xf3\xb8\xb3\x0c\x01\xf8\x02\x0c\xc2\x2b\x60\x6e\xab\x60\xa0\x5c\xa3\xdd\x26\x40\x10\x2c\x83\x22\x41\x05\x9a\x5f\x87\x06\xe5\x36\x78\xdc\x0c\x0f\xa2\x46\x88\x24\xa2\xe9\x2d\x57\x6b\x21\x13\xa4\x5c\x4e\xbb\x34\x61\xac\x88\x29\x13\xec\x99\x52\xfc\x9e\x48\x0a\x09\xeb\x0f\x93\x3d\x39\x4c\x7a\x3d\x2a\xce\x92\x73\xa6\x89\xea\x25\x74\x98\xd3\xff\x94\xc2\x84\x4d\x6b\x90\x4a\x38\xba\x84\x23\x58\x7f\x28\xf6\x64\xb7\xab\x5c\x7f\x28\x7a\x3d\xaa\xcf\xc4\x39\x53\x2e\x07\xc5\xcc\xab\x82\xf9\x4d\x84\xbc\xd4\x57\x4c\xc0\xa1\x61\x2d\x34\xa5\x30\x66\x64\xb1\x83\xfc\xb0\x9c\xc9\xf3\x94\xc2\xaa\x81\xe4\x00\x21\xc9\x70\x11\x14\x38\xeb\x0f\xf9\x9e\x18\xf2\x5e\x8f\x26\x67\xfc\x9c\xe9\x33\x7e\x9e\x63\x90\x9c\xc9\x73\xa6\x20\x49\x29\xb4\x0f\x4b\xe5\x50\xf3\x99\xd2\xbd\x41\x3e\x57\xba\x9c\x2b\x75\x96\x14\x70\xc5\x99\x3e\x67\x12\xc4\xaf\xe3\x6b\x80\x09\x04\xa6\x98\x39\x3d\xfa\x2c\x39\x07\x55\x4c\xbd\xfa\x45\x48\x1b\x83\x61\x7f\x8f\x89\xa1\xd8\xd8\x28\x00\x89\x05\x40\x14\x3a\xcb\x93\xbc\x6a\xb8\x0d\x83\x95\xc4\x0c\xb7\xb6\x33\xfe\xdb\x0b\x83\x44\xa3\xc7\xc1\x2c\x50\x01\x39\x69\x84\x5c\x6c\xa0\xe9\x24\x0a\x04\x8e\xa0\xb1\x9e\xed\x5d\x95\xbd\xcb\x0d\x31\xcc\x91\xd9\x4b\xba\x5d\x92\x14\xb8\xd1\x61\x8e\x2f\xcf\x91\xec\x25\x14\x02\xd6\x1f\x06\x7b\x62\x18\xf4\x7a\x94\x9f\x05\x66\x9d\x83\x73\xac\x6a\x4b\x92\xbc\xa4\x27\xcc\xde\x0a\x8a\x3d\xc0\x53\x0a\x0f\x1d\xaf\x9f\xd2\x52\xfc\xbb\xaa\xee\xe8\x87\x8e\x37\x00\xee\x49\xf0\x3d\x95\xe2\x31\xbd\x66\x53\x72\x55\xa9\x7e\x63\x48\x6f\x8e\x95\x62\x1d\xd0\x4c\x66\xd8\x0e\xf5\xc6\xc6\x90\x2a\x76\x45\xe4\x99\xae\x2f\x70\xd1\xfc\xb2\xde\xfc\xec\x7c\x28\x5d\x7f\x28\x99\x74\x7d\xaa\xdc\x9b\x64\x7a\x45\xa4\xcb\x2b\x2d\x4d\xbd\x6f\x2b\x49\xc5\xd9\xf9\x50\xb9\x7e\xb7\xab\xcd\x29\x36\x67\x19\x34\xd3\xae\x4f\x85\x05\x87\x4b\xe8\x72\xd0\x2e\xa7\x05\xdc\x1b\x43\xaf\x29\x3c\x63\x44\x2f\x40\x36\xd4\x3e\x87\x9d\x54\x61\x77\xbb\xa2\xde\x01\x08\x26\x5c\x9f\x26\xb6\x9b\xfb\xb2\x1b\x10\xf5\xae\x12\xd3\x55\xb4\xd4\x8f\x61\x0e\xe5\xf2\x2e\xf6\xd4\xed\x26\x4d\xdd\x41\xc2\x12\xd7\xa7\xdc\x76\x7a\x50\xef\x14\x92\x7a\xc7\xdc\x74\x9c\x34\x74\x6c\xb8\x4a\xde\x75\xd0\xdc\x75\xb7\xcb\xdb\xfb\x07\xce\xb8\xeb\xd3\xc0\x62\x71\xb7\x8c\x05\xf0\x3a\x26\x01\xad\x93\x33\x0d\x25\x03\xbf\x21\x66\x53\xb8\xd3\x58\xe9\x66\x2a\x7b\x41\xb4\xa1\xe0\x9a\x28\x4a\x53\xfc\x6f\x58\x01\x25\x7e\x09\x94\xa5\x23\x33\x53\xbb\xb2\x31\x35\x63\xec\x5e\x8f\xfa\x9e\x79\x38\xd0\xa3\x8d\x81\x37\xc0\x1e\x96\x48\x6f\x85\xe6\xb5\x14\x05\xb1\x9c\xc6\x13\xe1\x4e\xe2\x4b\x22\x7b\x8e\xb7\xb6\x17\x49\x2d\x94\xe4\x93\xe9\xbf\x1c\x0a\xaa\x7a\xe6\x4e\xcd\x29\xd0\x57\x2a\x9e\xad\x1d\x28\x15\x2b\xe2\x5c\x69\x7d\x33\xf5\x1e\x3d\xba\x8c\xf4\x55\xe2\xbb\x41\x7c\xfd\x48\x4c\xae\x1f\x05\xb1\x12\x8f\xfc\x49\xec\x3f\x1a\xb8\x7d\xb7\xff\xe8\x2a\x92\x7a\xfa\xc8\xe9\xc9\x9e\xe3\x5e\x8f\x9d\x0a\x7b\xde\x5f\xa0\x99\x60\x0e\x06\x24\xec\x3d\xae\x7a\x1f\x04\x1d\x1a\xda\xa2\x99\x70\x6f\xe2\x1b\x42\xe9\xd0\x94\x69\x5c\x36\x1f\xcb\x2b\xf4\xad\x80\xfa\xbe\x3c\x14\x51\x48\x06\xfd\xfe\x9e\xa6\x39\x7d\xb5\x8b\x7f\x88\xfd\x52\x58\xef\x0f\xa3\x90\x48\xc6\x98\xca\x6a\xd8\x37\x4e\xec\x7f\x15\x81\x76\xd6\x99\xbe\xbf\x11\x71\xb8\x26\xe7\x73\x99\x4c\x26\x46\x66\x28\x9e\xf2\x26\x4e\xde\xb1\xc3\x8a\xea\xdd\xee\x29\xd9\xa1\xb0\x3e\x28\x68\x61\xb2\x16\xc9\x35\xe9\x76\xf6\xfa\xdd\x2e\x91\xec\x14\x77\x87\x32\xff\x1a\x44\x24\x8d\x42\xb2\xfe\x9e\x48\xe4\x56\xe6\x8f\xee\x0d\xcc\xf0\x32\xac\x06\xc3\x1c\x3d\xa4\x2d\x2f\xd9\x94\xec\x53\x38\x5a\x92\x21\xb2\x5a\xfb\x19\x25\x2f\x17\xef\x22\x27\x41\x8d\xa3\xcb\xa7\x07\x67\x62\xd4\xf7\xe4\x9e\xc2\x6d\x65\xe6\x62\x5d\xba\x9d\xac\x9c\x68\x76\x61\x28\x9d\x39\x38\x94\x8e\xb4\x97\xbd\xf0\x41\xb9\x3e\xbe\x30\xbf\x02\x50\x6e\x60\x99\x80\xa1\x93\x28\xbc\x74\xbb\xeb\xf5\xc6\x96\x7a\x5a\x31\xa6\xdc\xd9\xf3\xb9\x81\x36\x1a\x78\xca\xf5\x0d\x02\x7d\x2b\x75\x7d\x6d\x19\xa7\x1d\x15\xdd\xeb\xa7\x14\x7e\xb4\xca\x3b\x59\xa5\x41\xfb\x29\xe8\xef\x5d\xe4\xac\xaf\xb5\x06\x6b\xad\x62\x4f\xa9\x2d\x2e\x46\xb2\xd7\x1f\x1d\x68\x4f\x8f\xbe\x69\xef\x5e\x1b\x51\xe1\x39\xeb\x97\xab\x71\x58\x63\x5f\x05\xeb\x2a\xca\x8f\xeb\xfc\x39\xaf\x01\x81\xa7\x2b\xb5\xbe\x54\x14\x0a\x59\xbe\x7e\x5b\x45\xeb\x21\x2d\x76\xa0\xc0\x1d\x68\x45\x48\x79\x26\xce\xeb\x05\x2a\x93\x2d\x4d\x41\x3e\x08\x9c\xfc\x37\x6c\x4a\x4e\x2a\x3b\xe9\xc4\x82\x37\xfb\x68\xaa\x55\x24\x2f\x2b\xdb\xbe\xd8\x47\x3d\x95\x6d\x1d\x3f\x7f\xa5\x86\x16\xa1\x2b\xbb\x07\xb2\x0d\x30\xac\x88\x36\x15\xa6\x8a\x54\xbb\xac\x5a\xc3\xe7\x45\xdb\x66\x90\x3d\x43\xae\xfe\xad\xc2\x5f\x13\xd6\xec\x5c\x72\xa6\xdc\xe0\x8a\xab\xfd\x78\x2c\x9e\x69\x92\xd0\x21\xdf\xdb\xd9\xd9\x7c\xba\x3b\x9f\xef\xec\x6e\x0d\x9e\xee\xf1\x11\xc9\x44\xba\x2f\x56\xa8\xa3\x60\xc4\x3c\xaf\xfe\xb6\xa7\xce\x92\xde\xc0\x16\xb2\x4d\x9a\x16\x84\xe9\x6b\x1c\x49\xe2\x38\x4d\x3b\xac\x44\xf3\xec\x1c\x6a\x62\x98\x95\x76\x0b\x04\x0d\xe1\x08\x96\xf0\x4c\x7a\x3d\x08\xea\xb8\x06\xf3\x39\xe1\x3d\xdb\xc0\x20\x09\x06\x3d\x4e\xa9\xe1\xa7\x48\x21\x79\x81\x99\xae\x60\x36\xfc\xb7\x84\xf0\x1c\x2d\x6d\xd1\xd2\xbf\x8c\x96\x2e\xd0\xb2\xa2\xb7\x41\xcd\x9c\xbd\x92\x9f\xe1\x66\xfa\xbe\x52\xc2\xca\xd1\x31\x22\x7c\x86\x4a\xc2\x50\x88\xe7\x75\x54\x04\xae\xe4\xee\xd6\x66\x7f\x3e\xdf\x79\xbc\xb5\xbd\xb5\xc7\xe7\x73\x23\xcf\x9e\x6d\x6c\x88\x73\x23\xba\xe6\x58\x24\x0b\x58\xc0\xab\xb6\xbd\xa8\xdc\xe9\xcd\x24\x32\x34\x3e\xa5\xf0\xba\xbd\x16\x4e\x2d\x56\xfa\xd0\x30\x98\x46\xe9\xfc\x17\x36\xb1\x95\x69\x73\xa1\xdd\x88\xb5\x49\x7d\x53\x68\x6a\x8e\x67\x52\x1f\x75\x32\x9f\x13\x53\x7d\x63\x43\x9f\xf7\x84\xdd\x12\x82\x16\x2c\xa8\x9f\xe6\xbc\x28\x9b\xfe\x77\x2b\x34\xd8\xff\x59\x4c\xd6\x17\x50\x19\xa4\x05\x4e\x14\x3e\xb7\xcc\xee\xc6\x60\x4f\xb9\x91\x1c\x8b\xbb\xb7\xa1\x9d\xe2\x8f\x6d\xeb\xd0\x67\x6c\xa1\xea\x1f\xad\x44\x26\xd7\x79\x8a\x21\x1a\xfe\x36\xe1\x53\x7d\x58\xb4\x67\x45\xd9\x46\x5e\x3d\xa5\xf0\x69\x09\xa4\x9d\xaa\x42\x11\x89\x42\xa2\xf7\x06\x39\xbd\xec\x54\x48\x63\x1f\x50\xa8\xdf\x18\xec\x99\x69\x29\x31\x45\xf9\x27\x97\xe5\x05\x05\xd1\x63\xba\x2e\xc1\xe3\x42\xfd\xb9\x92\x62\xc2\xdf\xad\x9c\x53\x6e\xac\x10\x1d\xe5\xef\xa8\x02\xff\xd5\xde\xfa\xd1\xaa\xd6\x8f\xd4\xbc\x8f\xc5\x6f\xb8\xbe\x72\x6f\xe2\x59\xbb\xf8\xfa\x1f\xb2\x95\xeb\xaa\xff\x90\xc3\x72\x11\x99\x1c\x9d\x92\xc1\x80\x7a\xfd\x3d\xdd\xed\xca\xbd\xfe\x7c\xae\x8d\xbc\xd5\xdf\x93\x23\xdd\x93\x9e\xb6\x52\x38\xf6\xc8\x35\x97\x9b\x76\x7e\xa4\x64\xf8\x2a\x10\xd1\x04\x54\xf6\x23\x9c\xc4\xb1\x02\x9d\xfd\x52\x71\x22\xc7\x20\xb2\x5f\x93\xf8\xb2\x95\xcf\x74\xbb\xab\x46\x3d\x9f\xaf\x2a\x5d\x67\x2c\xa7\x6d\x89\x64\x3f\x53\xbe\xf2\x8d\x63\x28\x7e\x8f\xef\xb1\x24\xff\x1d\x19\x7d\xba\xdb\x8d\xf6\x78\x76\xf4\x62\x96\x54\xcf\x9c\xa2\xc3\x80\xc9\xb3\xa8\xd7\x3b\x67\x8c\x25\x67\xaa\xd7\x3b\xef\x76\xc9\xc0\xcc\x60\x3c\x22\xba\xd7\x03\xc1\x06\x86\x71\xf5\x7a\x80\xf4\x99\x31\xb2\xbb\xb5\xfd\xe4\x49\x37\xa6\xa3\x85\x86\xde\x80\x16\x24\xf1\x98\x04\x23\xe5\x6d\x0c\x50\xf6\x4e\x29\x70\xd9\x4e\xd4\xd4\x5e\x4e\xa0\x47\xf5\x2e\x74\x1d\x55\x3a\x32\x87\x5f\xbb\xd3\xc4\x9f\x6a\x45\x14\x6c\x52\x4a\x47\xaa\xb7\xe9\x6d\x0c\x3c\x2c\x3a\x53\xe7\x94\x8e\x9c\x7f\x8c\xfc\xcd\xcc\xaf\xd1\xc6\xa6\xa7\x7a\x03\x53\x61\xc3\x48\x7d\xc1\x0a\x34\x16\x7a\x33\x7b\x28\xa5\x10\xcb\x46\xda\x36\x94\x7b\x05\x61\x93\xbd\x5e\xb1\x09\xab\x30\x24\xb5\x07\x79\xfb\x89\xa1\x66\xa5\xe6\x21\xd3\xe2\x81\x42\xd8\x84\x51\xe5\xbc\x0f\xcb\xd9\x19\xaa\xbc\xa3\x84\x2d\x20\xbb\xb1\xfd\xc4\x12\xcf\xfe\x7c\x2e\xf7\x58\x42\x7d\x25\xf8\xb7\xa1\x60\xf2\x77\xd1\x4b\xf2\xfe\x0e\x89\xb2\xab\xe1\x37\x0f\xca\x8e\xa1\xdf\x38\x36\xd1\x34\xb6\xed\x27\xff\x12\xf3\xb9\xf8\xd7\xce\x63\xa3\xb4\xec\xee\xd8\x5f\x8f\xfb\x28\x13\x8a\xbd\xa7\x8f\xe7\xf3\x41\x7f\x73\x4f\x64\xe8\x68\x36\xd8\xfd\x5d\xf7\xc4\xc6\x93\xc7\xa9\x98\x4c\xc5\x5a\xf1\x62\x67\x67\x58\x7f\xb1\xfd\xa4\x44\x5a\x82\x46\x51\x48\x32\xf2\xb3\x83\x90\x54\x28\xa2\xa2\x10\x30\xbe\xd7\x1f\xe5\xa7\xc1\xe3\xbd\x82\xc2\xaa\xbd\x20\x3b\x11\xd1\xc2\x89\xe8\xf5\xe8\x10\xf7\x7f\x34\x22\x82\x0d\x40\x5b\xc1\x6d\x69\xff\x47\xb4\xdb\x35\x95\xcb\x1d\xcf\xf3\xcd\xde\x4c\xa0\x9c\x4b\x67\x28\x5d\xfe\x87\xd1\x62\x7b\xcc\xb9\x76\x28\x48\x97\xcb\xec\x67\xe4\xd0\xa1\x56\xf7\xf9\x66\x3c\xd2\xe4\x44\x5c\x1e\xdc\xdd\xa0\x6d\x9f\xa6\x01\xd7\xc1\x55\x45\xc8\xbf\xd0\xa9\x21\xb9\xb7\xb2\x9d\xe6\x26\x93\x89\xa1\x22\xee\x75\xd6\x74\xb5\x3d\x11\xf9\x0a\x70\xd6\x37\xe2\x19\x44\xac\xc2\xc9\x20\x66\x1b\x83\x21\xef\xf5\xf6\x0c\xb2\x66\x23\x88\x3b\x11\x90\xc0\xc8\x88\xf1\x7a\xb5\xe6\xb0\x04\x18\x32\x51\xd8\x4f\xc1\xcf\x24\xe9\x90\x0e\xfb\x7b\x61\x36\xf1\x53\x26\xce\xc2\xf3\xa1\x7f\xb6\xb1\x11\x9e\xb3\xe9\xe8\x48\x93\x29\xf5\x2e\x74\x9a\xe4\xc6\xa1\x8f\x09\x88\xb3\xfe\x39\x08\xbb\xaa\xc0\xe1\x86\xf8\x94\x52\x88\xab\x9d\x16\x52\x58\xf9\x8a\x45\x90\x99\xad\x2a\x76\x94\x04\x24\xf0\x7c\x39\x02\x73\xb2\xf2\x76\x4a\xdc\x4c\x38\x4a\x55\x55\xff\x4c\x14\x92\xa0\xd7\xfb\x17\x4b\x8a\x73\x3b\x2c\x0d\x7f\x5c\x5d\x26\xd7\x42\xea\x69\x3e\xc8\x2d\xc8\x8d\xf5\xca\x0c\x52\x15\xa2\x4e\x51\xf3\x4c\x9d\x0f\x8d\x20\xa9\xce\x99\x30\x83\x15\x38\xd8\xdc\xb2\x69\x87\x2b\xa1\xac\xbe\xd4\xc5\xe6\x39\x04\x70\x43\x34\xa5\x34\xa5\x66\xf5\x27\xab\x69\x87\xce\xd7\xb4\xba\x96\x41\x6d\xbd\x64\x21\x93\x45\xf9\xb2\x0a\x3c\xd9\xeb\x51\x76\x66\x73\x91\x22\x13\x3c\x39\x44\x76\x31\x28\xad\x03\xce\x07\xb2\x58\x9f\x52\xa8\x2e\x4c\x00\x15\x69\x64\xbc\x4c\x86\x4a\x33\x6e\x1f\xc6\xb9\x32\xdc\xa6\xca\x99\x6a\x03\x10\x65\xb5\x42\x33\xed\x2c\xd5\xdb\x82\xd0\x93\x70\x99\x9b\x85\xaf\x56\x75\xbd\x8d\x1a\xf6\x95\x27\xd3\x0c\xd1\xeb\xb6\xda\xb6\x23\xc3\x76\x52\x0a\x37\x2b\x98\x4b\x56\x0f\x34\xd6\xbc\x94\xac\xc9\x6e\xbb\x58\x17\x04\xd6\x9e\xb5\x09\x00\xcb\xf5\x21\xc1\x16\xf7\x92\x91\x36\xbb\x69\x53\x23\xe0\xd8\x8c\x37\x36\xa9\x78\xde\x16\x1a\x41\x70\x8e\xfb\xf0\x40\x32\x12\xb4\xb4\xad\xf8\xd9\x96\x5a\x43\x84\xdd\xc6\xad\x4d\x21\x5e\xd5\x18\xe2\xf3\x26\x6a\x5b\xa1\xa2\xdf\xcc\xab\x3f\xde\xbf\x3d\x76\x6f\xb8\x9a\x0a\x34\xc0\x2e\x52\xd2\xaf\x09\x99\x91\xeb\x00\x9c\xd3\xab\x68\xba\x16\x4d\xd7\x64\xac\xd7\x6e\xf9\x24\x1a\xaf\x99\x96\xeb\x6b\x4e\x4f\xba\xd7\x62\x3a\xe5\x97\x02\x2e\xa4\x81\x41\x91\xf6\xde\xb5\x6e\x0a\xec\xf6\xab\xb4\xf6\xde\x72\x53\x7e\xcb\x6a\x4d\x67\x11\xa2\xe0\x76\xe8\x43\xc0\xa7\x62\x6d\xcb\xcb\xcc\x87\x7e\x1c\x4f\x04\xaf\x58\x0f\xd5\xe8\x47\x42\x14\xf5\xf6\x25\x71\xf8\xda\xf3\xb7\x6f\x8f\x1c\x30\x32\x9b\x69\xb5\x99\xb7\x92\xc9\xb5\x2f\x54\x69\xc3\x53\x23\xac\x2e\xd7\x0e\x8f\x4f\x4d\x75\x6f\x63\x73\xb0\xfd\x78\xfb\xc9\xd6\xee\xf6\xe3\x3d\xd5\xed\xaa\xbd\xf2\x77\xb7\x4b\xfa\x73\x14\x76\xf2\xae\xd6\xa3\xe9\xcb\x48\x46\xda\xcc\xd6\x7c\xae\xfe\x63\xb0\x08\x0d\xab\x59\x14\xb6\x17\x50\x68\xc1\xfb\xe5\xd1\xdb\x67\xa7\x25\xe2\xbb\x79\xab\x45\xa3\x51\xde\x4a\xad\x45\x72\xaa\xb9\x0c\xcc\xcb\xf7\x58\x09\x4b\x7a\x8e\x93\x83\x7c\x7f\x7a\x72\x78\xfc\xaa\x84\xf9\xd4\xab\xb0\xbd\x7c\x34\xd2\x0d\x6c\x7d\xf3\xb2\xac\xbb\x93\xd7\xfd\x91\x10\xbb\xa0\xf6\xfd\xe3\xfc\x3d\xd2\x71\x37\x9a\xe6\xf4\x7c\xf4\x4c\x5a\xd3\x26\xdc\xe4\xfd\x1f\x1d\xbe\xaf\x8c\xe8\xc9\xcf\x5b\x9e\xca\xac\xa9\x5c\x7b\x76\x72\xf2\xec\x4b\xd9\x78\xd0\xf7\x72\xf5\x6f\xdc\x68\x71\x56\xa5\x9d\x79\x3e\x5f\x27\xda\xda\xe8\x72\xae\x94\x01\x7d\xfb\xfc\x8f\x83\xfd\xd3\xb5\x59\xa4\xaf\xd6\xf8\x5a\x18\x89\xc9\x78\x4d\xf2\x6b\x31\x5e\xfb\xdf\x4e\x4f\xf7\x9c\xff\x8d\x1d\x5a\xc6\xf0\x2d\x43\xea\x4c\x97\x4e\xc1\x2b\x43\xf9\x47\xc2\xc3\xe3\x70\x13\x98\x73\x86\xc6\x59\x8b\xe2\xc0\xb3\x62\xa7\x74\x05\x72\x87\xc5\x71\x2e\x20\x53\x8e\x30\x0a\x89\x2a\xf4\xe4\xa4\x56\x6d\xed\xe8\xed\xf1\xab\x83\x93\x35\x8e\xb0\xd6\x8e\x85\x18\xaf\x21\x6b\x59\x73\x7a\x49\xcf\x59\xf3\x13\xbd\x16\xcb\xc9\xfd\xda\x54\x88\x35\xa7\x97\x83\xe9\x39\x6b\x42\x6a\x15\x89\x29\x76\x50\x19\x4d\xd2\x32\x9a\xcb\x00\x92\xda\x68\x36\xbd\x9f\x4e\xf3\x4f\x06\x68\x67\xbb\x98\x52\xce\x4a\x1d\x3d\xb0\xcb\x83\x03\xbf\xe2\xd3\xb7\x33\xf9\x4e\xc5\x37\x42\xe9\x7b\x23\x31\x3d\x54\xf0\x0d\xce\x2d\xab\x45\x64\x69\x95\x1c\xdd\x04\x10\x64\x18\x73\x76\x45\x0e\x89\xfd\x05\xa5\x29\xee\x47\x42\x3e\x68\x52\x0e\x69\xcb\xcb\xfb\x8f\x98\x74\x43\x88\x99\x74\x2f\x21\x64\xfd\x61\xb8\x17\xe7\x42\x6f\x68\x84\x79\x44\x20\x3e\x0b\xcf\xb3\xe5\xa9\x77\x2f\x86\x11\x8b\x88\xe9\xac\xd2\x53\x94\xf7\xb2\xed\x95\xe8\x2f\xcc\x35\xbe\xbe\xc2\x96\x86\x48\x88\xac\xc5\x4e\x81\x97\xcf\x3a\x30\x35\x58\x0d\xa7\xae\x3f\x9c\xb2\xa9\xeb\x67\xc8\x4c\xad\x69\x37\x0a\xc9\x02\x2a\x3e\x43\x80\xe0\x17\xc8\x98\xd9\x09\xcc\xc8\x8d\x18\x98\x75\xe1\x2d\x10\x72\xe9\xf2\x9c\x4e\xdb\x1a\xfd\xca\x79\x97\x66\x64\xa5\x81\xfc\x59\x83\xd8\xa4\x7e\xe2\x58\xcf\xe4\x47\x4b\xcd\xd1\xaf\x9e\xcd\x62\x50\x5f\xc4\xcb\xc0\xb0\x29\x5c\x44\xf4\xc5\x07\x2e\xaf\xcc\xa9\x26\x09\xad\xb8\xbf\x4e\xab\x51\x42\x33\xd2\x09\xa0\x40\xa3\x21\x66\xc8\xc6\x6d\x54\x9c\x67\x75\xfe\x53\xb0\xb4\x83\xbb\x1b\x11\xe8\x48\x5e\x1a\x26\x56\x30\xaf\xd2\x3b\x26\x0b\x03\xfe\xb2\xe3\x4b\xba\x1d\x54\x1f\x3a\xa5\xe3\x69\x89\x71\xf5\xbd\xfa\x12\x48\x97\x1b\x38\x2e\x1f\x66\x7c\x2d\x63\x54\x19\xb3\xc8\xa8\x7f\x8d\x08\xaf\xf7\x17\x09\xb8\x1b\x20\x8c\x20\x27\xca\x19\x85\xcd\x8f\x6e\x56\xed\xbd\x2c\xbc\x4d\x05\x19\x2d\x20\x8c\x11\xc2\xb8\xdb\x5d\xae\x55\xc1\x55\x60\x2d\xd1\x54\x6b\xab\xac\x15\x62\xad\xb0\xdb\x7d\x69\x6a\x5d\x82\x72\x2f\xcb\xe3\x50\xd4\xba\xc2\x5a\x57\x4d\xb0\x0a\x76\x53\x01\x50\xd9\x82\x2f\xdb\x4d\x80\xeb\xa5\xf9\xb0\x5c\x84\xaa\x6d\x40\xec\x69\x8c\x05\x42\x8f\xa1\x24\x12\xe3\x52\xce\xc4\x79\x9b\xb3\xf0\xa8\x55\x64\x41\x21\xc9\xf2\xe3\x28\xbc\x27\x28\xbc\x80\x21\x87\x20\x69\xcf\x71\x6a\xfe\x43\xd9\xec\x6c\xfa\x5a\x7f\x6f\xfa\xfb\xb1\xca\xdc\x72\x26\xcf\x99\xed\x47\xa7\x74\x68\xa0\x26\x93\x49\xa5\x9f\xe7\x15\x78\x0f\x1d\xaf\x0f\xdc\x08\xe4\xa5\xe3\xac\x5e\x3c\x58\x28\x3e\xae\x17\x6f\x82\xef\x49\x08\x3c\xd3\x87\xd5\x00\xbe\xac\xd0\x00\xb6\xb0\xf6\x18\x95\x0a\x78\xbb\xa2\xe2\x76\xa5\x22\x72\x82\x37\xb2\xea\xdc\x3b\x41\x24\xac\xc6\x88\x43\x10\xde\x1b\xd9\xeb\x65\xaa\x08\x4e\xef\x95\x77\x76\x9e\xe6\xa4\xf4\x1d\x4e\x47\x25\xdc\xe4\x45\x95\x2c\x1c\x4b\x52\xa5\x05\x92\x3c\x97\xe4\x24\x3b\xd3\x95\x53\xfd\x3d\x43\x52\xba\x57\x56\x17\x53\x14\xde\xa1\x6b\xc1\x20\xf2\xaa\x36\x9a\xea\x82\x2c\x80\xff\x6e\x4b\x01\xbb\x79\x6e\x55\x4e\x1c\xe2\x6b\xc9\xd6\x07\xf0\x41\xb2\xb3\xf3\x72\xa4\xef\x72\x95\xf9\x83\xcc\xa2\x60\x28\xac\xbf\xce\x62\x65\x4c\x8b\xfe\x50\xb2\x0f\xd2\x9d\x5e\x45\xa1\x26\x74\x48\x3f\x9b\x06\x43\x84\x55\x59\xb5\xcf\x38\x5e\x34\xb0\x29\x37\x37\x14\x48\x73\xfe\xdc\x8e\x39\x12\x7d\xeb\x76\x1f\x98\x7f\x8a\x7a\x97\xdd\xae\x72\x2f\x91\x5c\xc9\x21\x55\xee\x25\x33\x3f\x23\x24\xcb\xe6\xb0\xd9\xf1\x19\x80\x58\xe0\x13\x03\xce\xb0\xa9\xbc\x26\x1a\xa3\x0c\xf2\x18\x53\x99\x13\xf1\xdb\x38\x1a\x63\xd5\x00\xfb\xf7\x6b\xb3\x63\x80\x49\xc0\xf5\x4a\x29\x72\x80\x1d\x8b\x53\x86\xa4\x72\xaf\xea\x27\x37\xeb\x3e\xc4\xee\xaf\xf2\x79\xa0\xd6\x0e\x66\x30\x31\xdb\x0e\xed\xd6\x7d\x6f\x60\xf4\x4f\x53\x15\x22\x4f\xb9\x97\x29\xe4\x6d\xc7\xa9\xdd\xbb\x1f\x6b\x8b\x58\xd5\x05\xab\x8b\xa8\xf2\xe9\x93\x62\xb6\xf6\xf9\xcd\xd1\x6b\xad\x6f\x4e\xc4\xf7\x44\x4c\xf5\x70\xbd\xbe\xa1\xcd\x54\x7d\x0c\x4a\x39\x67\x28\x5d\x3e\x1e\x1f\xdc\x0a\xa9\x8f\xa2\xa9\x16\x52\x28\xe2\xdc\xa8\xf8\x52\x89\xe9\xd4\xa9\xb1\xa4\x9c\x62\xed\xc7\xd7\x37\x89\xe6\xfe\x44\x74\xbb\x66\x57\xba\x9c\x3c\xf8\xdf\x3d\xe9\x4e\x62\x3e\x16\x63\xf0\x95\x27\x5d\x1d\x6b\x3e\xc1\x08\x95\x94\x48\x48\xd0\x02\xb6\xd4\x8f\x50\x2a\x56\x95\x4e\xe8\x83\x22\x87\x92\xfc\x15\x60\x64\x4b\x53\x0b\x1d\x5d\x8b\x38\xd1\xcb\x6d\x64\xd4\xda\xc6\xa0\xb5\xd0\xa0\xc9\x6a\x47\x04\x93\xf0\x10\xbc\xf0\x84\xab\xc4\xf4\x26\x96\x53\xf1\xe1\xe4\x08\xf8\x8e\xf7\xe0\x27\x9e\x70\xa7\x9a\xeb\x64\x0a\xfe\x6e\xf1\x7c\x2a\xee\x74\x0a\xfe\x89\x57\x9d\x25\x4b\x03\xc2\xc4\xfa\xc2\x4b\x4f\x78\x69\x76\x95\x99\x9f\xd0\xf9\x47\xfd\x23\x1d\x0a\xab\xdd\x96\xa5\xa1\xd3\xf1\xd6\x1c\xdc\x80\xfd\x3d\x9e\xcb\x26\x49\x66\x23\x8f\xe4\x25\xe9\x03\xa7\x10\xd5\x5e\xf1\xde\x26\x1d\x2a\x76\x4f\x6e\x79\x35\xac\xbe\xa4\xde\x47\x9a\x7c\x0c\x88\xa4\xa3\xa8\xe7\x00\x2a\xc0\xdc\x8b\x68\x0a\x8a\xa6\xa5\xcf\x93\x08\xf7\x52\xe8\x67\x93\xc9\x49\x36\x2f\xaf\x05\x1f\x0b\x35\x25\x94\x82\x3f\xa9\xcc\x57\x46\x37\x84\x95\x2a\xec\x24\xed\x6d\xf6\xfb\xf3\xf9\x56\xbf\xbf\xc7\xf2\x57\xb4\xb0\xc3\xfb\xf1\xf8\x9e\xc9\xa2\xbd\x99\x50\x38\x94\xe4\xcf\x80\x68\x9a\xf9\x44\x98\x22\xba\x2a\x81\x26\x74\xf4\x5c\x92\xc4\xe5\xd4\x23\xad\x00\x66\xe4\x53\x80\xd1\x5d\x68\x42\x23\x12\x84\xeb\xbf\x36\x02\x5a\x6a\x6d\xaf\xd2\x8d\x6f\x84\x24\xc2\xf5\x1f\x83\x70\x83\x17\xb0\xde\x5f\xb6\x17\xe0\xbe\xfa\x3b\x20\xa6\x82\x01\xb3\xde\xee\xf8\xf4\x4f\x86\xda\xf5\x87\x36\x9c\x4f\xba\x53\xa1\xb3\xe3\x67\x67\x8a\x68\x97\xdb\xb0\x33\x23\x2c\x54\xd0\xbd\xbf\x31\x52\xa8\xff\xda\xf5\x41\xba\x46\xa3\xdb\x57\x62\x2c\xa4\x8e\xf8\x64\x6a\x24\xa3\x43\x30\x67\xd5\x0d\xee\x68\xb7\x4b\xa4\x9b\xed\x7e\x53\x72\x67\xc4\x5b\xf4\x06\x66\x31\x16\xc2\xf5\x27\xc3\x42\x4a\x99\x0a\x39\x26\x2a\x22\x9a\x8e\x48\x03\x3e\xce\x7e\x2c\xb5\x90\x7a\xc3\x60\xe0\x60\xc4\x21\x18\xd4\x3d\x7c\xaa\x1c\x15\xe9\x72\x3f\x56\x9a\xe0\xb5\x98\x9a\x75\xae\x62\xc7\x42\x86\xe7\x7b\xc2\xf5\x81\x37\x9c\x05\xe1\x72\xc3\x01\x0a\x91\xf7\x0f\xa3\x73\x2a\xbc\x08\x33\x5c\x61\x1c\xfb\xc3\xb0\x25\x01\xd2\xf5\x3f\x81\x74\x83\xe7\xe6\x4f\x52\x3b\xc6\xb6\x5e\xe5\x8d\x45\xb2\xe0\x31\x7f\x2c\x18\xc4\xec\x91\x99\x91\x3b\x09\x56\x46\x1e\x29\x37\x9c\xf0\xcb\xa9\x67\x38\xc0\x5a\x9f\xd2\x21\x0a\xf7\xf3\xf9\x29\xc9\xdc\x84\x11\x7b\x48\x21\x66\x24\x60\x9a\xa0\x84\xef\x72\x08\x19\x27\x53\x88\x29\xf8\xac\x81\x8e\xd4\x23\x6c\x3e\xc9\xfc\x38\x7f\xc2\xf0\x9b\xc4\xe5\xdd\x2e\x21\x9a\xe9\xf9\xfc\x21\xa5\x67\xe2\x9c\x25\x2e\x27\x02\x23\xd3\x4c\x0d\xf6\xa7\x24\x49\x25\xe2\x40\xa7\x24\x82\x69\x65\x50\x53\xdb\x57\x90\x85\x08\xc6\x14\x42\x12\x1b\x95\x03\x8c\x7c\xa5\x48\x04\x81\xeb\x43\x42\xe2\xd2\x45\x57\x7f\x0b\xfe\xe8\xe1\x26\x56\x7a\xea\xf9\xa9\xf7\x60\xd9\xcc\x27\x89\x41\x43\x79\x1f\x7f\x56\x06\x24\xd8\xc3\x25\xda\x48\xed\x1c\xa5\x90\x30\xe9\x06\xc0\x99\x74\xc7\x10\x30\xe9\x0a\x40\x45\xb4\x88\x66\x76\xaf\xd8\x89\x39\x81\x5f\x4a\x23\xfb\x5a\xf5\xb2\x04\x96\x48\x78\xe8\x78\x3b\xe0\x37\x6c\x17\xe9\xf2\x9a\x7b\xd7\xed\x8c\xee\x09\x07\x81\x32\xa5\x17\x74\xbb\xd1\xe8\x00\x6f\x13\x29\x37\x02\xe5\x7e\x35\x6f\xef\xf1\x45\x30\x52\xae\xe1\xa3\xe6\x95\xd9\x0a\x66\xef\x50\x2b\x0c\xfd\xfd\xab\xc2\x90\x72\x2f\xc9\xa2\x2c\xd4\x22\x49\xcf\xc8\x2b\x09\xd2\xbd\x82\x4c\x66\x55\xf5\xdd\xf7\xd7\xea\xeb\x20\x28\xc9\x7e\xf3\x14\x4c\x8c\x34\x5b\x0a\x46\x52\x2d\x88\xb3\xd7\xa6\x1c\xa7\x46\xad\x92\x63\xa5\x27\x21\x5e\x30\x8e\x6b\x55\x8f\xe5\xae\x04\x86\x61\x68\xa2\x50\x64\xbd\x0f\x78\xca\x8c\x44\x0e\xe6\x37\x3a\x72\xb3\xdf\x92\x1a\x11\xf3\x2c\x39\x37\x43\x74\xc2\x3b\x07\xb8\x27\xce\x92\xf3\xf9\xfc\x21\xf2\x3a\xf0\xd5\xeb\xd4\x6f\xcb\xa9\xf2\x10\x67\x1a\xa4\x2a\x34\xc8\xdc\xb0\xa4\xdc\x6f\xc0\x19\x09\x59\x02\x3e\x13\x30\x23\x72\xf4\x49\x9e\x85\xe7\xae\xf0\xec\xbf\x61\x8d\x4f\x95\x8e\x18\x7f\xa8\x30\xca\xf7\x3b\x35\x62\xe2\x4d\x85\xa4\x48\x23\x37\x4d\xca\xb0\x50\x94\xe7\xf4\x59\x72\xce\x48\xc4\xb8\x39\xbe\x31\x86\x17\xd1\x0a\xde\x20\x47\xb1\x1b\xb1\x2b\x12\x41\xec\x46\xd4\x8b\xdd\xaf\xd9\x8f\xaf\x14\x62\x5a\x58\x5e\xcb\xe0\x63\xe5\x5e\x0f\x03\xd7\x1f\x06\x2c\x70\x7d\x8a\x63\x35\xa7\xce\x8c\x36\xeb\x78\x58\xb3\xf1\x22\x1a\xd9\x9c\xb8\x31\x68\x78\xb8\xf1\x94\x2b\xe1\xbb\x27\x52\xbb\x29\x23\x88\x21\x04\xbf\x72\x13\x0e\xd7\xfe\x93\x3c\x93\xe7\xdd\xee\x29\xd9\xb2\xd5\x78\xdb\xba\xaf\xd5\x42\x75\x03\x95\x9f\x21\x0d\x9c\x9d\x9d\x43\xc0\x10\x92\xab\x20\x62\x44\xb3\x3e\x2c\x6c\x75\x3b\xad\x53\xa1\x4f\x2d\x5b\x21\x55\xba\x9f\xef\x7f\x28\x99\x6f\xa5\x38\x98\x08\xae\xf2\x66\x0a\xad\xe4\x79\x2d\xdb\xa7\xcf\x22\xb0\x4f\xc1\x82\x62\x58\x08\xf3\x59\xcc\x36\x2d\xf9\x28\x07\x61\xf4\x44\xc3\xf1\x38\x2d\x42\xf1\x72\xd9\x28\xc1\xab\x30\xc9\x39\x29\xe6\x7b\x2d\x4a\x29\x3c\x18\x69\x27\x50\x91\x2f\x6a\xb4\x84\xe7\xca\x49\x0a\x89\x6c\xae\x62\xc7\x4f\x38\xe3\x99\x0b\x8b\xd2\x4a\x40\xd0\x50\xed\xf5\xe7\x73\x8e\xb2\x5a\x20\x88\x82\x01\xcd\x64\xf2\x48\x0d\x5b\x68\x49\x93\x01\x07\x43\xc2\x69\xae\x35\xc6\x8a\x39\x89\x1c\x8b\x30\x92\x62\x5c\x5a\x24\xc7\x71\x80\x1e\xc0\x51\xfe\xe0\x55\xc9\x71\xa8\x72\x3d\x8f\xdf\xdc\x08\x39\xde\xbf\x8a\x26\x63\x33\xed\x4d\xdc\xd3\x9e\x32\xe1\xca\x78\x2c\x86\xa5\xab\x8e\x2b\x21\xf5\x71\x3c\x16\xb9\x0f\xd4\x02\xd9\x57\x55\x5f\x28\x7d\x48\xa9\x91\xd5\x1f\x6a\x54\xc4\x57\x4d\xea\x39\x3a\x76\x6b\x3b\xb3\xea\x3f\xfa\x49\x34\x63\xbf\xb2\xfe\x0f\x39\x5d\xe0\x43\xd1\x63\x89\xeb\xcf\xe7\x7d\xc8\x22\x12\x93\x32\x56\xb2\x57\xc6\x1a\x22\xe9\x0c\xbc\x00\xc6\xde\x33\x85\x57\xa6\x3c\x0d\xa1\xc7\x8d\x0c\x82\x22\x00\xc9\xf8\x39\xdc\xfe\x5f\x41\xf0\xd7\x50\xdc\xfc\x25\x14\x71\x57\x4c\x56\x50\xf6\x6d\xf8\xea\x49\x64\x14\xbe\x37\xe8\x11\x85\x9d\xd3\xda\x02\x8d\xd5\x42\x9b\x1d\xc3\x54\xe0\xda\x53\xf0\x2d\x67\xdb\x69\x0b\x09\x19\x2b\x72\x26\x41\x9d\x37\x08\x56\x56\xe5\xcd\x36\x6e\x47\xb5\x1b\x78\x32\x18\xa0\x9b\xa0\xe4\xb7\x19\x0d\x24\xb8\x52\xab\xdc\xa1\x05\x1c\x10\x4d\x90\xca\x5b\x8e\x08\xeb\x5a\xb5\x45\x89\x2c\x83\x83\xa4\x09\x60\xf5\xf6\x63\xba\xea\x06\x4a\x13\x40\xe0\x4d\x20\xeb\x17\x22\xd3\x5f\xf2\xb5\x2e\x80\x85\xa0\x09\xf0\xe2\x15\x49\x04\xfd\x0b\xae\xd8\x25\xe0\x10\x35\x81\x5f\xbe\x33\x99\x2e\x38\x6c\x43\xf0\x61\x0a\xb7\x30\x81\x31\x74\xe0\x0a\xae\x6b\x5d\x2c\x95\x36\x75\xa2\x98\x0f\x9a\x4d\x41\xb0\x5b\x48\xd8\x04\x38\x33\x12\x64\x07\x22\x76\x05\x31\xbb\x86\x27\x8c\x31\x22\x59\x48\x9b\xae\x68\x42\xdc\x76\x49\x93\xc4\x59\x48\xdf\xa2\x4b\x39\x6d\x0f\xee\x37\xf2\x0c\xef\x3b\x15\xa9\x89\xc2\xcd\x8a\x53\xe8\xf0\x41\xb5\x32\x5c\xae\xac\xbb\x59\xab\x3b\x5b\x59\x77\xab\x5a\xb7\x21\xd6\xba\x52\x75\xdb\x54\x55\x10\x7b\x0f\x21\xb6\xd0\x69\x8d\x0c\xdc\x57\xe8\xb4\x63\xf8\xdd\x8d\x76\x18\x93\x23\xe7\xc6\xf1\x64\xcb\xf9\x37\x93\x80\x46\xac\xce\x68\x46\xae\x15\x18\x01\x85\x68\x26\x8d\x94\x1f\x63\x04\x50\x8c\x17\xf1\x84\xdb\x01\xee\x25\xa3\x7b\xf2\x57\x04\xc9\xde\xd6\xe8\x4e\x79\xdf\x14\x1c\x1b\x45\x1d\x3d\x56\xde\x8c\xbc\xc8\x7d\x89\x29\xa5\x5e\x16\xfa\x6f\x96\x23\xa3\x20\x07\x0a\xee\x5a\x25\x99\x43\x82\x86\x24\x8a\xe6\xf4\x94\xc2\xb7\xd6\x39\xf3\x77\xcd\x36\x70\xfd\x5d\x0a\xfc\xd2\x53\x2e\xbf\x04\xee\x9b\x7f\xfd\xda\x64\x20\xd5\xad\x48\x8f\x0f\x69\xe5\xaa\x41\x61\x82\xe7\x68\x7c\xe9\x40\xc2\xb4\x2b\x31\x46\x3c\x46\xc7\x2c\xdf\x74\xd6\x19\x13\xb9\xca\xa8\xce\xc4\xf9\x7c\x4e\xcc\x3f\xec\x21\xa5\x43\xb3\x6a\x8c\x31\xd1\xed\x3a\xc1\x84\x4f\xa7\xe6\x47\x32\x3a\x55\x24\xb0\x37\x9d\x03\x23\x7b\x72\xb4\xf8\xd9\x0a\xc7\xfc\x5a\x14\x95\x14\x24\xf0\x55\x12\x6e\x66\xc9\x54\xc4\xe7\xd2\xda\x52\x7a\x8a\x16\xa4\x77\x79\xa6\xce\x87\xe6\x0f\x13\x23\xd1\x73\xd6\x9c\x9e\xf6\x2a\x69\x2f\xf6\x55\xdd\xbd\xd0\xc9\x6d\x95\x45\x38\xa2\xa9\xe1\x7e\xc3\xfb\x36\xdf\x98\x74\xaf\x09\xa5\x99\x3b\xae\x5f\xad\x16\x2b\x37\x50\x82\x6b\xb4\xa6\x18\x91\xc1\x5e\x74\x8c\x42\xb2\x8d\xd5\x2a\x1e\x34\xe9\x7e\x43\x7d\xf0\xeb\xd0\x14\x09\xb7\x33\xa4\x4b\xde\xd6\x64\x94\xb0\xb3\x04\x84\xfb\xf5\xdc\x2b\x62\x86\xbe\x52\xbc\xa5\xf7\x2d\x73\xaa\x3e\x7c\xf5\x12\xb8\xf1\x54\x6e\x1f\x27\x01\xdb\x57\x44\x80\x51\xb8\xc5\xe4\xfa\x42\xdc\x0a\xa9\x2f\x8c\x48\x73\xa1\x44\xc8\x38\x04\x69\x14\x92\xad\x2a\xd6\xef\x15\x31\xda\xe8\x15\x91\xee\x25\x05\x05\xd2\x1d\x53\x08\x86\x76\x01\xa5\x1b\x8e\x8a\x61\x1d\x4c\x84\x11\xb1\x8e\xdf\x13\xe9\x86\x80\xa1\x03\x8b\x65\x18\x50\x30\x8c\x54\xb7\xeb\x70\x73\x86\xdc\xa0\xdb\x0d\x1a\x4c\x8b\xc1\x24\x0a\xbe\x39\x10\x29\x12\x50\x0a\x06\x85\xac\xe7\x61\xd5\x49\x2b\x20\x66\xfd\x61\xbc\x17\xe5\xa2\x6c\xdc\xeb\xd1\xd0\x54\xde\x57\x64\x60\x06\x31\x8a\xce\xe2\x73\xcf\xfc\x41\x87\x6b\x21\xe0\x06\x15\x17\x9e\x5a\x72\x60\x1a\x15\x4e\x57\xcd\x85\x43\x43\xa6\xcc\x42\x8c\x5e\x2a\xb4\xba\x7a\xd9\xf9\x16\xa3\xaf\xb6\x39\xbe\xb2\x9b\x77\x74\x54\xd4\xd9\xb6\x2f\x2e\xb2\x17\xc4\xb9\xe5\x93\x44\xe0\x11\x98\xcf\x9d\xe0\x4a\x04\xdf\x50\x5a\x35\x3f\xe5\x99\x38\x5f\x67\x2c\x41\x8b\x14\xda\x2f\x6a\x3e\xae\x85\x4d\x38\xd5\xf7\x13\xd1\x7a\xe9\xa8\x6c\x77\xa4\x16\xc4\x30\x5b\xb3\x72\x89\x60\x28\x46\x68\xc8\x7a\xa6\xb5\x8a\xfc\x44\x0b\x62\xb3\x1a\xb8\x4a\x5c\xc7\xb7\xa2\xf2\xba\x8a\xcf\xc5\x4f\xe1\x82\x11\x96\x43\xe0\x4c\xb8\xf1\x90\x2f\xf4\x71\xfc\x9e\x24\xa0\x31\x79\xc1\x62\x3f\xb6\xa8\xda\xd7\xd7\xc5\xf3\x6a\xb6\xee\xcb\x29\x9e\x37\x7c\x42\xda\x51\x53\xc0\xf5\xc2\x75\x19\xa3\x5c\x9b\x83\xc6\x6d\x50\xa2\xfd\xeb\x7e\x77\x3b\x8c\x31\x8e\xaa\xb4\xfb\x9d\xf1\x61\x10\x4b\x1d\xc9\x44\xa4\x39\x56\xf5\x6d\x99\x18\xf9\x20\x60\x3f\x0c\xa9\xe1\x8d\x36\xf1\x04\x02\x38\x50\xdd\xee\xc3\x0d\x9f\x4e\xa3\x5b\xe1\xc9\x98\x70\xba\xb7\x99\x52\xc0\x8b\x4b\x81\xf5\x56\xb4\x83\xb7\xd5\x72\xd9\x52\xab\xfb\x87\x59\x24\xc7\xf1\xac\xc9\x64\xef\x58\xf7\xe2\x5b\xa4\x0b\xae\xd5\x7d\x8a\x48\x89\x87\x14\x9c\x0c\x09\x07\x1e\x2e\x85\xf6\x2a\x72\xc3\x81\x62\xeb\x7d\xc3\x9b\x4b\xdb\x6c\x39\xdd\x3f\x14\xf1\xc1\xd0\xf8\x8a\x65\xac\x50\x6a\xdd\xef\xa0\xd9\x37\xe4\x29\x20\xf3\x88\x03\x4d\xeb\x61\xb0\x32\x26\x8a\x22\xd5\xe7\x10\xb0\x64\x64\xf8\x1a\x77\xb9\xc7\x5d\x7f\xd7\xe3\x10\xb1\x81\xa1\xd8\xdc\xf5\xbd\x2d\xc6\x92\x6e\x97\x1b\x66\x13\x33\x12\x75\xbb\x66\x67\xc7\x37\x66\x14\xfc\x92\x5b\x6c\x81\x6c\x2e\x55\xf7\xa9\xa9\x7a\xa3\x90\x7e\xbd\x10\x21\x4f\x26\x9a\x50\xf0\xe9\x50\xb0\xd8\xfd\x3a\xb4\x57\xea\xf2\x11\x94\xf1\x51\x82\x1a\xb5\x39\xa0\x36\x56\x7a\x39\xd2\x76\x18\x6e\x6c\x0c\x4d\x9d\xb3\xf0\xdc\x54\x8b\x59\xec\xde\xa4\x31\x41\xc1\x2d\x67\x25\x53\xf7\x3b\x93\x30\x2d\x67\xec\x79\xed\x70\x9e\x15\x77\xfe\x8e\x73\xbb\x4d\x9f\x56\xf3\x28\x1d\xaa\x45\xad\xf2\xa1\xe3\x29\x50\x9e\x86\xa9\x27\x40\x67\xaa\x05\x24\xb9\x8e\x51\x9a\x9f\x33\xcd\x08\x2a\x17\x74\x8f\x2b\xd0\xa2\x90\xe0\xbd\x87\x1c\xae\x34\xd2\x85\x11\x42\x30\xb4\x7d\x9d\x31\xbb\xff\x07\x86\xce\xcc\xe7\x9b\xf8\xa2\x6a\x54\x39\x54\x44\x43\x1f\x04\xc6\xa6\xb0\x66\x73\x91\x21\xbb\xbf\x98\x8f\xc1\x70\xe1\x22\xb1\x46\xa6\x5c\x4a\xd7\xe8\x6e\xd2\x1d\x83\xf0\x04\x84\x9e\x61\x15\xbe\x27\x5d\x3f\x4d\xed\xa6\x19\xa4\x99\x89\x8b\x67\x06\xae\x9d\x8a\xad\x48\xba\x13\x1b\x59\x0d\x31\x0b\x8a\xf0\x0e\x16\x33\xc6\x0a\x26\x10\x76\xbb\xb1\x59\xc5\x90\x05\x67\xf1\xb9\x29\x39\x8b\xf1\xf0\x87\x0b\x7e\x49\xc3\xab\xbf\xd1\xa1\x79\x50\x86\x69\x0f\x6d\x90\x4d\x7d\xfd\xdc\x6f\xa0\xdc\x6f\xe0\x9b\x35\xc4\x76\xfd\x3d\xbf\xb8\xac\x84\xf3\x35\x00\x01\x3e\x2d\xe2\xf9\x72\x64\xa7\x86\x7d\xc3\x2d\x53\xee\x57\x98\xb0\xf5\x01\x8c\x4d\x77\xc8\xcf\xc7\x86\x9f\x4f\xd8\x7a\x1f\x96\x98\xfa\x74\x34\x65\x67\x53\x18\x1b\xa6\x3e\xb5\xcb\x3d\x36\x4c\x7d\xcc\xc6\xee\xb7\x82\xc6\x75\x98\xca\x40\x75\xda\x41\xdd\x8e\x6e\xd9\xd9\x2d\x74\x0c\xa8\x5b\x0b\xaa\x63\x40\x75\x58\xc7\xfd\x96\x0f\x71\xd2\xed\xe6\xd1\xd1\xeb\x8c\xdd\xe6\xb7\x48\x16\x77\x83\x47\xc8\x64\xd4\xa6\xd8\xf7\x87\x7a\xaf\xcc\x00\x61\x83\x29\xe4\x99\x36\xdc\x0c\x03\xe4\x96\x23\x29\xc8\x14\x6e\xa9\x37\x65\x8c\xdd\xd2\xf9\x1c\xfb\xd9\x04\x01\xb7\x76\x8a\xcd\xbc\x1b\x6d\x47\x83\xe8\x0d\x96\x42\x90\x70\x11\xa4\xcb\x31\xb4\x83\x67\x6b\xb0\x85\x66\x6b\xbe\x14\xd1\x84\xe0\xbe\x14\x27\x04\xde\x2c\x86\x7e\x2e\xd5\x38\xc9\x6b\x6c\x79\xe8\x6c\xbb\xc2\x7e\xae\x5a\x8f\x09\x86\x42\xb3\xb7\x66\xa7\x8c\x41\x19\x09\x25\xdf\x17\xdb\x20\xe0\x2a\x8b\x7e\x66\xca\x8d\xca\xd8\x97\xea\x48\xae\xb3\xda\x3b\x20\xe0\x9a\xd2\xaa\xc5\xba\x82\x55\x62\xcf\x76\x1e\xd8\x63\x88\x5f\x16\x55\x93\x33\xba\x2a\x06\xbc\x82\x01\x37\xda\x77\xa1\xdf\x23\xd9\xab\xa0\x5f\xb9\xe8\x5c\x67\xb2\x46\xde\xae\x07\xe4\xe1\xad\x7a\x23\x07\xad\x33\x16\x18\xf9\xad\x5f\x3c\x6d\x15\x4f\xdb\xf8\x64\x6a\x06\x15\x81\x20\x62\xf2\x2c\x38\x87\xd8\x66\x29\x89\x18\x63\x71\xb7\x5b\xca\x42\xa6\x65\x45\x16\x0a\xe6\xf3\x4c\xba\xd2\xdd\x2e\x21\x09\x8b\xa8\xe1\xd3\x84\xb3\x98\xba\x1d\x8c\x0f\x2a\xf2\x4b\xcc\xe7\x84\x08\x23\x3d\x3d\xa4\xf4\x2c\x38\x67\xb1\x1d\x62\xed\x9d\x1e\x65\xd2\x9b\x1e\x39\x4e\x2e\xb8\x69\xd3\xc9\x96\x7d\x6b\xa9\x2c\x2a\x7f\x67\xc1\xb9\x1b\x42\x9c\x13\x5e\x6f\xf9\x56\xf6\x59\x70\x6e\xc0\x18\xce\x8b\x4c\xe4\xc1\x32\x10\x33\x7d\x66\x8c\x66\x84\xa6\x67\x08\xa8\x21\x44\x75\xec\x42\x9a\x16\xb1\x7c\x76\x7a\xf0\x1f\x59\x1b\x85\x6f\xe8\xa6\x5f\xcd\x62\x53\xac\xd1\x9b\x25\xc6\x61\x88\xb1\x21\xf0\xc2\xf0\xd9\xf2\xca\x1a\x2f\x62\xa0\xf6\x82\x11\x2e\xf7\x2e\x08\x78\xb8\xf5\x22\x88\xbc\x60\x23\x4a\xa9\x17\xec\x45\xd9\x2e\x79\x6c\x8b\x02\x10\x1e\xaf\xc8\x51\x31\x0b\xf6\xa2\x51\xe0\x45\x79\x0c\xa4\x0d\x7e\xb4\x34\x32\x39\x0b\xcf\x87\xc7\x46\x50\xe0\x67\xe1\x39\x68\xe8\xf5\xec\x95\x49\x6b\xc3\xab\x6c\xe2\x93\x0a\xce\xd5\xac\x2a\xc0\x99\x99\x25\xf3\x94\x8b\xf2\x66\x18\x61\x41\xc7\xc1\x67\x79\xd8\x25\x4c\x59\x1f\x6e\x59\x1f\x26\x4c\x0c\xa7\x7b\x61\xb7\x7b\xbb\xe7\x67\xfe\xfc\x31\x23\xa7\x2c\x3a\x9b\x9e\x53\x97\x43\x87\x91\x7d\x16\x9f\xdd\xe2\x8f\x2b\x76\xea\xfa\x70\xcd\xf6\x5d\xdf\x50\xff\xf1\x3a\x63\x1d\xdb\xe6\xc6\x34\xe8\x0d\xce\xe1\xd2\x54\xee\x0d\x90\x3b\xdc\x50\x53\x34\x63\x37\x2e\x87\x7b\x76\xe3\xfa\x70\xc0\x8c\x78\x38\x33\x85\x97\x58\x78\xc7\x2e\x5d\x0e\xdf\xd8\xa5\xeb\xc3\x33\x36\x66\x8c\xdd\x99\xc2\x67\xdd\xee\x01\x3d\x56\xe4\x0a\xbe\x41\x02\xbd\xde\x84\xc2\x77\x85\x79\xef\xc6\x70\x0d\xb7\x46\xaa\x9b\xf4\xd8\x95\xb5\x6e\xbe\xca\x4b\xee\x6d\xcd\x49\x8f\xdd\xdb\x92\x69\x8f\x6d\xc2\x6d\x8f\x6d\x5a\xe1\xc4\x00\xa6\x93\x5e\x2f\x87\xd5\xc9\x61\x15\x3d\x4d\xaa\x70\xa7\x3d\x36\xa8\xb7\x3e\xa0\x45\x5f\x57\x45\x5f\x59\xed\x63\x45\xee\xe1\x3a\xc7\x76\x19\x87\xc1\x30\x0f\xe8\x59\xbf\x99\xcf\x67\xeb\x8c\xdd\x65\xb7\x59\x16\x61\x2e\x62\xb7\xd0\xc7\xb7\xf6\x3e\x36\x53\x4b\x8e\x70\x3c\x55\x5c\x8a\x11\xf5\xe0\xb6\xd7\xc3\x23\x63\x56\x3d\x5b\xf0\xd3\x1c\x85\xca\xba\xdb\xa5\x5e\x6e\x6f\xdb\x96\x9b\x65\x1f\xde\xb3\xf7\xf3\xf9\xd9\xf9\x30\x43\xbb\xb2\x5d\xf6\x5d\x1f\x32\xc1\xeb\x3d\xc5\x8e\x49\x7f\x2f\x3f\x53\xf3\x79\x7f\x2f\x28\x9e\xdf\xd3\xec\xe8\x3c\x31\x47\x67\xe6\x25\x70\xe7\x05\x70\xef\xbd\xcf\xfc\x4f\x2f\x14\x73\x2e\xc4\xe4\xfa\xd3\xee\xf3\xa3\x4a\x9a\xcd\xef\xaa\xc9\x6d\x6e\x38\x25\xc6\xb4\x04\x39\x8f\xc9\x5c\x2c\x0f\xca\x4b\xe0\x99\x17\xb0\x87\xc0\xeb\xc3\x0f\x4f\x80\x79\x31\x2d\x0c\xcf\x99\x3c\x62\xda\xb3\x00\x45\x71\xa3\xf2\x06\x6e\x50\x38\x69\x72\x08\x29\x85\xc0\x0d\xd8\x66\xe6\x79\xaf\x09\x38\x81\xfb\x03\x04\x44\x10\xb8\xca\xd4\x52\x2c\xb1\x60\x03\x77\xea\x4e\xd9\xc3\xcc\x8b\x2c\x84\x34\xc7\xbe\xf7\x42\xe5\x56\xd8\x62\x64\xaf\x6a\x9c\xca\x32\xa4\x7c\x5c\xbc\x88\xe8\xe2\x16\xb5\x1c\x91\xa0\x8e\x88\x00\xee\xfe\x80\x00\x92\x4c\x08\x38\x34\x5a\xd6\x53\x48\xcc\x04\x07\xf0\xcc\xd0\xa6\xf4\x55\x1d\x07\x4b\xec\x33\x16\x53\xd4\xcf\x1d\x00\x38\x31\x0f\x81\x37\xa8\xcc\x5d\x54\xe5\xaf\xaf\x2b\xa4\x69\xbd\xe2\x52\x5f\x30\xf8\x5a\x62\x88\x1a\xa4\xa5\xf5\xb1\x6b\xa3\x8e\x86\x86\x05\xe7\xd7\x82\x0d\xb5\xea\xe4\x8b\xe0\xd3\xd7\x06\x1b\xed\x7e\x83\xd8\x9d\x42\x44\x8b\x43\xf9\x04\x4b\x1f\x62\x57\x33\x05\xb1\x9b\xb0\x68\x68\x85\xc5\xd8\x9d\xba\xb3\x61\x7f\x6f\x5a\x08\x97\x16\x91\x29\xf4\x73\xc3\x71\x0e\xe3\x69\x33\x8c\x5b\x03\xc3\x60\x70\x4b\x1f\x6e\xdd\x67\xee\x94\xa9\x0c\xf6\xed\xcf\x20\x5b\xd0\x55\x80\x66\x43\x12\x33\xea\x5e\x0f\xfd\xbb\x04\x87\x4d\xff\x55\x6c\xd2\x04\x77\xfa\x84\x69\x3b\x6a\x23\x8b\x4e\x4a\x0a\x3f\x66\xba\x2a\xeb\x5a\xe9\xb5\x74\x7f\xc0\xd8\x4e\x70\x6f\x00\x01\xa8\x06\x4b\x94\x3d\x47\x1d\xa6\x5d\x91\x49\x58\xca\x0d\xae\xa2\xc9\xf8\x38\x1e\x8b\x69\xc1\xa3\xae\x59\x7f\x78\xbd\xd7\xc9\xb9\xdd\x75\xce\xa0\x6e\x8c\x86\xc9\x26\xa3\xce\xd9\xf5\xb9\x67\xfe\xb8\x3e\x5c\xb2\x5e\x8f\xf7\xc8\x8d\xf5\xf3\xe0\xce\xdc\x63\x61\xb7\x1b\xee\xb1\x4b\x4c\xb9\x26\xc9\xd5\xd9\xf5\x39\xdc\x64\x6b\x7f\x09\x11\x05\x3b\x07\x0b\x33\x50\x4c\xc1\x90\xb3\xcb\xe2\xd6\x5e\x9a\xeb\x7a\xd0\x07\xe5\xfa\x50\x4d\x07\xf9\x41\x2d\xf9\x64\xd0\x32\x98\x8b\xdb\xd2\x23\x95\xcd\x08\xef\x14\xde\xd8\xad\x00\x78\xb7\x68\x6e\x41\xa1\x5b\x55\x85\xee\x45\xd3\x8b\x06\xce\x3e\x2b\x92\x60\xde\x27\xc6\x98\xc4\x54\x49\xa5\x41\xb4\x12\x77\xfc\x59\xd5\xae\x55\xa9\x4a\x74\xfa\x92\x03\xb6\x6e\x88\x29\xdd\x9f\x90\xb0\x7d\xdc\xf3\x74\x98\x34\x2c\xe8\x7c\x4e\x9a\x5e\x5b\x5b\xce\xe2\xe2\x0f\x45\xb7\x6b\xb4\x55\xd9\xed\x2e\xb8\x55\x13\x90\x95\x24\x55\x18\x01\x30\x05\xe5\x26\x0b\xb7\xa9\x32\xa3\x9e\x9b\x98\x72\x0a\x8b\x01\x04\x32\x07\xfa\x82\x6b\x4e\xfa\x50\x5c\xfe\xaf\xd6\x2e\x74\x08\x3b\xf7\xee\x74\x51\x73\x68\x42\x7d\xd4\xf4\xd2\xfd\xca\x94\x3b\xf5\x9a\x8a\xd8\xc3\x57\xcf\x0c\xe1\xc6\x53\x6e\x92\xe6\x5d\xef\x7a\xd5\x18\xb8\x69\x96\xb9\x52\xbb\x11\x86\xaa\xe7\xc6\x23\x3b\x23\xb2\x72\x2e\xce\xb4\x7b\x5b\x0a\x8e\x32\x0f\xff\x2f\xc5\x2e\x82\xf0\x28\x0a\x8d\xb5\x86\x82\x99\xa6\x43\x51\x30\xbc\xac\xa7\x48\x4e\x85\xd2\xcf\x45\x18\x2b\x41\xf6\x15\x49\x30\x3e\xde\x4d\x28\xf0\xc5\x7e\x9e\x7a\x48\x33\x6c\x0f\xb4\xb4\x58\x54\x1d\xe4\x15\xb4\xcd\x3c\x5b\x2e\xa0\xdd\x67\x55\x8d\x68\xad\x6f\x74\x00\x57\xa1\x81\xa7\xb5\x71\xe0\x4e\x99\x3d\x26\xee\xac\x58\xb2\x27\x4d\xdb\xb5\x4c\x2c\x60\x26\x72\x39\x68\x37\x0f\x25\xad\x04\x92\x16\x56\xeb\x17\x59\xd4\xc0\x4b\xc5\x2f\xd1\x7c\x5d\x64\x11\xad\x4e\x53\x2e\x8b\xe7\x71\xa5\xcf\x86\x21\x6a\xb4\x96\xe5\x8d\xb8\x3b\xf5\xf6\x15\x31\xdc\xcd\xcc\x5c\x35\x02\x4d\xbb\xf7\x36\x7b\x53\x31\x94\xd2\x8c\xc9\xb4\x7b\x97\xdd\x9a\x29\x16\xa5\x72\x79\x26\x39\xe3\x46\x72\x0e\xdc\x67\x10\xb3\x4d\xb4\x7f\x04\xa3\xc8\x76\x15\x65\x5d\x0d\x17\x16\x30\x86\xda\xa2\x07\xae\x3a\xa7\xa9\xe8\x76\x31\x0e\x42\x54\xc2\x7e\x70\x76\x16\xae\xfa\x29\x77\x4a\x24\x1d\x8e\xad\xb1\xcd\x3b\x25\x83\x7e\xd5\x48\xfb\x51\x65\xe1\xeb\x36\x43\xae\xd9\xe0\xa7\xf7\x37\x22\xdf\x08\xbe\x51\x4f\xb5\xb8\xd3\x59\x80\xa4\x95\x57\xd6\x5b\xaa\x3a\x0e\x1d\x2e\x66\x98\xe4\xb9\x81\x78\xba\x2a\xb0\x77\xa8\xd8\x15\x99\x91\x99\x82\xc4\x95\xfc\x5a\x40\xe2\xa2\x9e\x89\xc9\x86\x32\xc1\xc4\xd5\xfc\xf2\x98\x5f\x0b\x57\xc7\x47\xf1\x4c\xa8\x7d\x3e\x15\x84\x66\x1e\x53\xb9\xc8\x67\x44\x69\x59\x12\xd6\x38\x78\x45\x3e\x2a\x12\x9d\x89\x73\x6a\xb4\xbc\xc2\x89\x3e\x55\xc0\x41\x41\x50\x0b\x1f\x51\x20\x41\x57\xdc\xc6\x18\x3a\x19\x19\x06\xf1\x09\x94\x1b\x3c\x37\x7f\xaa\xb9\xc9\x41\x96\x61\x11\xc1\x6b\xe0\x2c\xc2\xf9\x81\x80\x7d\x54\xa4\x3c\x73\x7f\xaa\x85\xab\xf6\x76\xa6\x12\xcc\x92\xc8\x9e\xa3\xbf\x84\x0e\x39\xfb\x60\xc4\xdc\xc0\x72\x95\x80\x61\x20\x5d\xe6\x35\xfc\xa3\x16\x31\x60\xd1\x14\x75\x34\x45\x2b\x9a\x49\x8e\xa6\xd1\x3d\xdf\x74\xbb\xca\x7d\x43\x30\x2b\x29\x22\x1d\x99\x03\xa4\x23\x3d\x31\x4a\x5d\xac\x30\x96\x18\x42\x33\x80\xb8\x7d\x00\x91\x62\x7c\x68\x47\x11\xd8\x51\x4c\x15\x71\x4c\x53\x87\x92\x0e\x25\xca\xf5\x27\xe6\xf4\x3d\x57\x24\x34\x4c\x26\x36\x63\x8b\x21\x44\x39\x10\x42\xa6\x21\x52\xac\x0f\x11\x9a\x6b\x82\xfb\x6e\x97\xe4\x48\xb0\x08\xdf\x50\x3b\x78\xf8\xd4\x1c\x29\xa4\x6c\x1c\xef\x33\x19\x5d\xa3\xdd\xf9\xa5\xe2\xd7\x62\xd4\xf8\xb6\x16\xec\x54\x09\xf3\x92\x30\x10\x5b\x8f\x76\xfb\xb4\x1a\xf1\xa9\x6c\x40\xaf\x20\x3a\x8f\xbb\xae\xdc\x6e\xe1\x84\x3e\x24\x28\xab\x24\xa3\xbe\x47\x3e\x99\x25\x06\x53\x15\x06\x05\x99\xa8\x53\x2c\xcd\x24\xa8\x11\xc1\x3a\xe6\xd4\xdb\x6c\xb1\x03\x4a\x3d\x14\xb1\x93\x6e\xd7\x02\x49\xd8\x66\xf5\x74\xfe\xad\x2a\x21\x09\xb1\x99\x9a\x49\x1c\xe0\x88\xdc\x2b\xc3\x71\x5d\x3e\x9f\x9f\x92\x01\x6d\x8b\x66\x99\x91\xbf\x23\xf8\x33\xaa\x45\xba\xd1\x07\xd5\xed\x5e\x45\x53\x1d\xab\x7b\xf7\x12\x4d\xfe\x92\xd8\xf4\x9c\x38\xd2\xbf\x5a\x9d\xd2\xcd\xd0\x72\x50\x46\x75\x79\xaf\xb9\x16\xe8\xc3\x70\xa0\x02\x17\xa4\x6e\xcd\xd6\xb1\x1a\x68\xc6\xf0\xdb\xe0\x3e\x2c\xba\x57\xaa\xde\x92\x14\x1a\xbc\x35\x5e\x3d\x3c\x1a\x94\x66\x64\x55\x04\x5a\xb7\x9b\x3f\x41\x53\x35\xeb\xe5\x19\xd9\x7f\x3c\x43\x1f\x45\x2d\x14\xae\x72\x36\x5f\x48\x52\x1f\x63\x45\x75\x91\xf4\xe1\x44\x12\x81\x91\x71\x05\xdd\x5e\x72\x1d\x69\x90\x75\x2f\x15\xe6\xfe\xaa\x2e\x6c\xa3\x7f\x4a\xdb\xaf\x38\xb4\xe7\x67\xc9\xae\xe7\x57\x2e\x15\x68\x3a\x3a\xd2\x44\xbb\x1c\x33\x75\x54\x23\x68\x75\x35\xd0\x7d\xf1\xd2\xcd\x27\x55\x1d\x1f\xc6\xa0\xb0\x7c\xfa\xdc\x4b\xa1\x33\x6f\xf2\xf3\xfb\xc3\x31\x5e\x62\x20\x72\xf4\x3c\x1b\xb6\x77\x28\xc9\xa7\xa8\x48\xf1\x81\x34\x5f\xe8\x7a\x90\x72\xe5\xd3\x14\x7a\x81\x0c\xe5\x2c\xf0\x4c\x9d\x13\x0a\xcf\x57\x85\x29\x6b\xd6\x10\x89\xa3\xdd\x69\xa0\xe2\xc9\xc4\x66\xcf\x79\x9e\x2e\xc6\x86\xd6\x47\x86\xd1\xa0\x9a\xd0\xca\xdd\x30\xbd\x22\x58\xa5\x1d\xdd\xac\xd7\x23\x11\x1a\x15\x2e\xff\x79\x1a\xdf\x30\xbd\x7a\x10\x72\x75\x86\xad\x55\x85\xff\xb9\x22\x43\xa4\xda\xdb\x6b\xca\x33\x96\x97\xfe\xeb\x5f\xab\x4b\x4d\x71\x5b\x2c\x68\x7d\xef\xdb\xbd\x31\x15\xfa\x50\x6a\xa1\x6e\xf9\xa4\x5a\x78\x22\x89\xc6\x3b\x37\x6d\x91\xb6\x45\x23\x99\xdd\xc3\x40\x0a\xad\x81\x6b\x08\x34\x44\x1a\x62\x0d\xa1\x06\x5f\xc3\x54\xc3\xad\x66\xcb\x53\x5f\xc6\x6d\xc2\xa4\xa5\x7c\x33\x2b\x1f\xb7\x94\x6f\x65\xe5\x9d\x96\xf2\xed\xac\xfc\xaa\xa5\x7c\x27\x2b\xbf\xd6\xec\xa1\xe3\xed\xa6\x70\xa3\x57\x66\x3b\x79\xf8\xe2\x29\xe0\x81\xa7\x81\x8f\xbd\x04\xb8\xf0\x04\x04\x33\x4c\xd5\x02\x97\x7a\x45\x92\x31\x62\xa6\x13\xd3\xa9\x68\x36\x86\x7b\xcd\x88\xa8\x5e\x5b\xa9\xdc\x6c\x50\x6e\x80\xb9\x09\xc7\xc0\xdb\x78\xc0\x3d\x99\x69\x90\x6e\x67\xa4\x3d\x8e\xb1\x1d\xdc\xcc\x7f\xb5\x90\x03\xfe\x63\x00\x27\xd4\xa6\x85\x1a\x50\x38\xd0\xac\x0f\x77\x9a\x5d\xc3\x37\xcd\x36\xe1\x59\x13\xc2\x68\x9c\xb1\x3e\xe0\x8d\x4d\xd4\xb3\x3b\xf5\xcc\xa9\x46\x80\x1c\x43\xc2\x24\x70\x76\x8f\x92\xb7\x0f\xda\x0d\xe0\x9e\x3c\xc3\x71\x80\x76\x05\xa6\xd5\x4d\x40\x31\x0e\x9a\x09\x33\x39\xa7\x4d\x0b\xb0\x86\x6d\x5a\x27\x6d\x46\xee\x34\xd8\x0c\xb5\x36\x07\x57\xc7\x10\x51\xd8\xff\x3f\x05\x25\xab\x50\xde\x37\x42\xd9\xc7\x4c\x99\xf0\x52\xb3\x23\x38\xfa\xc9\x9e\xbd\xc0\x3d\x33\x48\xe1\x6b\xbd\x22\x3a\x9b\xfc\xea\x6d\x36\x59\x49\x68\x70\xa1\x53\xf8\xa1\xdb\x13\x71\x76\x46\x17\xda\x33\x6d\x6c\xc0\x79\x4a\xe1\x79\x23\xa6\xb2\x2e\x81\xa7\x70\xd8\x0a\xd4\xc6\xcc\xc2\x71\x33\x9c\x14\xbe\x68\xf6\x03\xde\x2e\x37\x97\xde\xe2\x66\x28\xef\xe3\xaf\x5d\xe8\x61\xae\x1b\x06\x98\x0a\x76\x8c\xbb\x56\xe4\xd7\xf4\x67\xe4\x0b\x6e\x07\xd7\xa7\x85\x41\x44\x1a\x01\x8c\x89\x22\x54\x64\x6d\xd1\x5c\x70\x84\x79\x38\x73\x35\xc9\x56\x4f\x2a\xd5\x53\xb3\x95\xde\xac\x9c\x3d\xe9\x29\x97\xa7\x14\x4e\x74\xdb\xe5\x9a\x86\x49\xd0\x64\x46\xde\x68\xe8\xc0\x8c\xbc\xb5\xdf\x40\xc1\xe8\x78\x78\xd1\x38\x65\x33\x72\x62\x86\x36\x23\x97\x1a\xbe\x6a\xf8\x61\x5a\x5f\x6a\x78\xae\xe1\xa5\x26\x4e\xc8\x27\x53\xe1\x50\xf3\x7f\x29\x7c\x6f\xc7\xd5\xe6\x44\x7b\xa5\xd9\x9f\xf0\xfa\x27\x07\x71\x5d\x2f\xa6\x2f\x16\x98\x53\xde\x1e\x42\xfc\x26\x44\x9e\xca\xb8\x76\xe8\x3e\xb4\x9c\x94\xd7\x1a\xee\x74\x76\x0e\xde\xe9\xc6\xe8\xe7\x28\x24\xa2\x0c\x33\x17\x2e\xc7\x60\x24\x74\x06\xf1\xfc\x7d\xc0\xb8\xcb\xd1\x63\x86\xef\xa3\xfc\x7d\xcc\x22\xbc\x91\x16\xd9\xf7\x61\xfe\xde\x67\x61\xf9\xa9\x10\x83\x75\x02\xe6\x6f\x80\x7f\x63\xfc\x1b\xba\x1c\x76\xfa\xfd\x3d\x3d\x42\x2c\x0d\x3a\x36\xdd\x86\x77\x40\xde\x65\xe4\xa5\x37\x00\xdf\x4e\x6f\x2b\x28\xd5\x52\xaa\x16\x5f\xd7\xb3\xe8\x7e\x5e\x41\xc1\x8b\xfe\xfb\x96\x8a\x7c\xac\xad\x6c\x35\x23\xff\x3d\xf9\xac\xdb\xf8\x33\xd2\x21\x9b\x71\xbd\x20\x45\x14\xfe\xf8\x09\xd3\x49\x3c\x01\x33\x4f\x83\xf6\x14\x04\x07\xe8\x32\x41\x8e\xf3\xa9\x75\x77\xdd\x91\x3f\x34\x28\xf7\x0e\x94\x6b\xfe\x9d\xa1\x3d\xcf\x90\x94\xe0\x00\x69\xca\x9f\xba\x7e\x07\x41\x16\x1e\x95\x25\x76\x5f\xb9\x03\x77\x87\xc6\x04\x0d\x82\x49\x77\x86\x31\x96\x49\xb9\x9c\x1f\x35\x7c\xc2\x18\xc5\x03\x0a\x01\xb1\x08\x14\xfe\x1a\x7b\x9c\xfe\x5e\x71\x72\xfd\x11\xce\xdb\x9d\x3d\x7e\x9e\x91\x71\xfe\x6a\xad\xae\x19\xf6\x87\x9c\x01\x9b\xfd\x6d\xb6\xb3\x2e\xa4\x40\x90\xa2\x2d\xc9\xad\xa1\x55\x4d\x63\x2c\xc6\xf1\x97\xc1\x39\xbf\x1f\x03\x6a\x19\x50\xb9\x81\x04\x60\x60\xb2\x6a\xb0\x26\x48\x77\x56\x26\xc0\x3d\xc3\xd9\x30\xf3\x67\x66\xcf\x30\xec\x04\xd0\x74\x1a\x1c\x50\x82\xb9\x45\x29\xa6\x32\x2b\xd0\xd7\x82\xbd\x04\x51\xb1\xb8\x35\x7c\x48\x6a\xf5\xba\x58\x23\xe5\x01\x26\xf2\x28\xcf\xab\xc6\xf3\xaa\xcb\x53\xb8\x4f\x02\x88\xe9\x28\x47\x11\xb7\xa7\x39\x26\x10\x65\x0b\x77\x4e\xbd\x4e\x7e\x44\x3a\x69\x0a\x89\x58\x41\x11\x1b\xd9\x94\xdf\xed\xae\x4b\xd7\x77\xfd\x51\xc6\x09\x51\x9b\x49\x81\x0b\x36\x23\x7f\x6a\xb8\x31\xdd\x2a\xd1\xf8\x47\x08\xe2\xf0\x89\x50\x7a\xea\x50\x48\x04\x71\xc2\x68\xa2\x85\x72\xa8\xfd\x75\xa9\xe2\xe4\x26\xff\xa1\x44\x20\xa2\x5b\x5b\xf8\x42\x13\x67\x1a\x4d\x84\x0c\xc4\x38\xff\x1d\xc9\xab\xc8\x8f\x34\xbe\xa0\x10\x98\xde\x6b\x2b\xeb\xff\x0f\x4f\x31\xc4\xcc\x27\xd6\xb7\x18\x97\x6c\xb3\x53\xf8\xc1\xf8\xe2\xfe\x58\x9a\x7c\x12\xe2\xbe\x28\x67\x9f\x82\x93\x67\x1e\x3b\xd2\x14\x22\x33\x06\x69\x67\x29\x1b\xad\x99\x27\x7c\x17\xd8\xd7\x62\x1c\x69\x1c\x6f\x2c\x5a\x49\xdb\x83\xdf\xf7\x24\xf0\x37\x96\xb8\x68\xd3\x4d\x58\x5f\xe5\x7c\x12\x2a\x89\x4a\xfb\xe5\x47\x66\xea\x99\xd3\xd5\x48\x79\x83\xfe\xe6\xf6\xef\x44\x6d\x60\x01\xed\xd5\x1a\x0e\xe8\x06\xa6\xd8\xee\xed\xee\xec\x6c\xed\xa6\xe0\x37\x75\x15\x8a\xca\x4d\x4a\xb5\xc7\x76\x1e\x77\xbb\xdb\x4f\xf6\x98\x4a\x61\xfa\xd3\xfa\x4f\x1f\xef\x31\xcc\x33\xc7\x06\x9b\x9b\x29\xdc\xfe\x4a\x07\x4f\xfb\xdd\xee\xee\x0e\x76\x30\x69\xdc\xe1\x53\xd3\x60\x3e\xbf\xb5\xff\x38\x17\x8e\x4d\x05\xe2\x0b\x94\x17\xc7\x82\xdd\x90\xb3\x43\xe2\xb0\xff\x72\x60\x93\xc2\x21\x71\xd6\xff\xcb\x81\x2d\x7c\x62\x0e\xf4\xed\x2b\xe6\xc0\x80\x9e\x53\xe8\x08\xf6\x02\xae\x5a\x4e\x52\xc7\x50\x15\xc7\xa1\x29\x5c\x37\xd5\x28\x93\xcd\xc0\x4d\x4b\x79\x2e\xa0\x5e\x0a\x14\x50\x07\x29\xcc\xda\xa8\x58\xfd\x8b\x45\x14\xee\x57\x6c\x93\x0c\x70\xf9\xfd\x07\x0a\x07\xbf\x0a\xf7\x4e\xac\xb8\x63\xf5\xc0\x6f\x3c\x05\xfe\x9d\x27\x80\xbf\x33\xaa\xd5\x17\xcb\xde\xbe\x21\xfe\xfd\x14\x9e\xad\x20\xc2\x07\x02\xbe\x09\x38\x20\x77\xc2\xe8\x41\x5f\xcc\x9f\x1b\x24\xb1\x36\x5f\xc7\xa9\x60\x5c\xc2\xbe\x60\xcd\x59\x02\x1a\xce\xfa\x3d\x39\x15\x46\x71\xc2\xf4\x07\xa5\xd5\x78\x9f\x28\xd8\x18\xd0\xd1\x8c\xcc\x04\xac\x0f\x60\x46\x9e\x99\x85\x12\x94\x7a\x58\xb4\x49\x47\xf7\xe4\x5e\xc0\x7a\x1f\xfa\x60\x46\x54\x0f\xd8\xc4\x30\xcd\xde\x00\xc7\xe6\xf2\x2f\x3d\x9c\x1d\x23\xa8\x7a\xf5\x56\x06\xfd\xde\x62\x53\x95\x37\xcb\x1b\x99\xd9\x79\xdf\xb2\x7f\xf6\x0d\x5a\x97\xc2\x68\x31\xf5\x69\xab\x88\xfc\x14\x8e\x6a\x0b\x1d\x95\x0a\x68\xcc\x24\x84\xcd\x2c\xd2\xce\x4f\x9c\x65\x5f\x1e\xd4\xf5\x01\x9c\x17\xfc\x20\x9c\xeb\xd3\x42\x35\xe0\xa8\x1a\x18\x49\x35\x24\xf8\x31\x96\xac\x61\xe2\x76\x72\x23\x78\x52\x52\x42\x84\xa1\xe7\x73\x0e\x89\xeb\xd3\xd4\x96\x65\x2e\x1b\x37\x28\x15\xdc\xfb\xac\xd6\x8c\x20\xa5\x74\x7d\x0a\x01\xce\xc9\x45\xeb\x46\xb9\x27\x47\x02\x5e\xda\xef\x17\xa5\x14\xbe\x0a\x76\x21\xe0\xc7\x8a\xed\xbb\x59\xdd\xbe\xcf\x9b\x8e\x45\x4d\x3d\x2a\x38\x40\x2e\x99\x93\x3e\x66\xb0\xc8\x26\xab\x1c\xaf\xf9\x45\x38\x4b\xa8\x5b\x84\x0f\xf3\xa1\xd5\x74\x66\xe4\x87\x00\x05\x46\xbe\x36\x12\x7c\x55\xef\xc9\x6b\xb2\x24\xad\xce\xd5\xfa\x00\x73\x56\x50\x38\xac\x6c\x86\x95\xdf\x7b\xbc\x27\xcf\xcd\x24\x7c\xc3\x00\xc6\x14\x8e\x05\x3b\x14\xf0\xe5\xd7\x5b\xdf\xdb\x4e\xd1\x9a\x09\x6f\x05\xfb\x22\xe0\xcd\x8a\x59\xec\x57\x67\xf1\xa4\x65\xc7\xbe\x11\x36\xf5\x82\xa5\x5b\x34\x85\x17\x4d\x15\xd7\x65\x0a\xdf\x9b\x0a\x1c\xa4\xc5\x29\xbc\x12\x2c\x91\xf0\x7a\x99\xdc\x73\xbc\x54\x15\xe0\x77\x7e\x22\xb6\xfe\x5d\x54\x9c\x41\xcb\xfb\xfb\x8e\xbc\x12\xc0\xf3\xf3\x9f\x11\x14\x89\xc9\x48\x6a\x1b\x5a\x95\x3b\x72\x9f\xe8\x26\xda\x10\xd0\xec\x74\x47\xd9\xe1\x4e\x16\xce\x35\x92\x3a\x51\x1e\x6a\xf8\xd0\x38\x43\xaf\x05\x39\xb1\x66\x69\x78\xd7\xb8\x52\xc7\x82\xdc\x90\xb3\x19\xf9\x2a\xe0\xad\x20\xd7\x82\xf4\x29\x85\x0f\x82\x5c\x61\xce\x59\x23\x11\x7c\x15\x90\x17\xdf\xe0\x4b\x78\x2f\x1a\x48\x83\xf3\xcf\x3f\x76\x32\x17\x2a\x14\x6b\xd0\x4f\x73\x70\xbf\x00\xc9\x46\x21\x14\xdf\x80\xa2\xe7\x66\x04\x9f\x05\xfb\x0a\x1f\x1b\xc7\x59\x7c\xa3\x02\xfe\x10\xec\x03\x7c\x6a\x3d\xcc\x72\x6f\x30\x52\xde\x3d\xf9\xc3\xcc\xf2\x47\x81\x59\xcb\x50\xab\xf9\x95\x16\x7d\xd8\xc8\x88\xc0\xdf\xb5\xea\x15\xbf\xdc\x0a\x25\x88\xff\x3b\xd4\xcf\xc7\xcd\x52\x27\x5c\xa6\xd2\x8c\x24\x60\xb1\x37\x55\x32\x46\x03\x1a\x0d\x75\x46\xef\x69\x39\x27\x7f\x5b\x0a\x46\x53\x90\x09\x5b\xfc\x86\x5b\xe6\x47\x6f\xc7\x3c\xc9\x30\xff\x29\xd6\xcb\xf8\x0a\xa2\x90\x26\x59\x8d\x28\x61\x32\x01\x9d\xac\x96\x4d\x44\x4b\x79\x2e\x9b\x24\x4d\xe5\x6b\x68\xd3\xb4\x69\x32\x3d\x91\xa5\xcb\x04\x9e\x34\xca\x0e\x39\xf1\xcd\xfc\xd7\x44\xd1\x2c\x79\x38\xd2\xda\x65\xbe\x22\x0b\xbe\x52\xf0\x1d\x0c\xfc\xf5\x31\x3d\x55\x30\xc4\x5b\x4d\xc5\xd4\xe0\xd8\xb1\x49\x60\x04\x7a\xfc\x4a\x94\xf9\xa5\x30\xab\x8d\x66\x46\x13\x88\xcc\x74\x04\xc9\xbf\x61\x67\x3a\x20\x3c\xb1\xf4\x33\xf3\x07\x41\x94\xb4\x8b\x36\x41\xd2\xac\x53\xcd\x88\x4a\x20\x49\x40\x21\x4d\xc0\x2b\xd1\x78\x0d\x66\x63\x33\x85\x30\x61\x71\x02\xbe\x99\x5d\x98\xb6\xc2\x46\x6e\x78\xa8\x73\x6e\x78\xdb\xb8\x18\x75\x91\x37\x93\x74\x27\x8d\x55\x0d\xef\xca\xa9\xf8\x53\x4b\xc5\xd1\xa1\x5d\xd0\x5b\xa6\x6a\x39\x9c\xfe\x07\x88\xed\x7c\xde\xdf\xb3\xb2\x5a\x03\x3e\xb7\x49\x55\x4c\x4f\x51\x9c\xe3\xff\x6d\xfa\x6c\x5d\xec\x36\xee\x2f\x85\x31\xce\xf9\xe3\x14\x3a\x6d\xd3\xbc\x8e\xd6\x44\xf3\xc2\xed\xa4\x14\xae\x56\x2c\x75\x27\xc9\xd7\xe2\x3a\x61\xed\x97\xf3\xab\x7b\x3e\xb2\xa3\xb7\x17\x28\xcd\xee\xdd\x27\x91\x99\x18\x5a\x0a\xd5\x22\xcb\xf6\xc0\x73\x19\x52\x03\xf7\x92\xb4\xa8\xbc\x49\xa9\x95\x3c\x54\x6f\x60\xf6\x74\x6f\x00\x82\x0d\x20\x61\x46\xb7\x35\xa7\x23\xb0\xb1\x97\xb6\x52\x94\x6d\x7b\xd1\xab\x55\x31\xbb\xf8\x26\x31\xda\x74\x02\xe5\x9f\xb7\x82\xc4\x82\x02\x09\x34\x7b\xe0\x53\x6f\x9c\x80\xff\xd9\x23\x5c\xb3\x07\xff\xb3\x37\x11\x10\x5c\x79\x7e\x02\x7c\xcb\x9b\x88\x94\xba\xfe\x67\xf3\x82\x6b\x37\xb8\x32\xef\xb8\x76\xf9\x56\xda\xb0\x5d\x70\xc4\x81\x29\x2d\xe5\x73\x1c\x8c\xaa\x8c\x7c\x6d\x71\x99\xb5\xcb\xa7\xb9\x71\x85\xe5\xc2\xba\x4f\xae\x13\x53\xe4\x7f\x06\x2b\x99\x67\x62\x39\x3e\x80\x59\x7f\xbc\x84\x5b\xa9\xa6\xca\x2d\xda\xab\xd7\x02\xc1\x0a\x72\xae\x17\xf4\x86\x19\xb9\xc2\x34\x50\x66\x6c\xcb\x3b\xd0\xa2\x56\xe8\x00\x02\x6d\x8b\x14\x8e\x05\x41\x03\x57\x93\x12\x5e\xa1\x6a\x96\x0d\x4b\x43\x9b\x27\x09\xe6\x7b\x87\xb1\x30\x0c\x9f\x24\x9a\xfd\xe6\xfc\x06\x48\x29\xd0\x38\xfd\x49\x90\x81\x61\x90\x64\x40\x0d\x83\x21\x35\x91\xa0\x9f\x4b\x0b\x89\xb6\xe2\x42\x94\x40\xa2\xe1\x9d\x40\x33\x2b\x85\xcb\x84\x91\xc8\x7a\x3b\xfa\x69\xd3\x79\xdb\x27\x1f\xed\x85\x6c\xcc\x6e\x35\xca\xc5\xc4\x3e\x48\xea\x2d\x0c\x39\xca\xdc\x60\xb5\xc3\x10\xe4\x1c\x2c\x5a\xc5\xc1\xa2\x7f\x5f\xf3\x08\x20\x61\x01\x72\xaf\x8c\x39\xfc\x9b\xca\xc7\x92\xca\x61\xf8\x45\xe2\x5a\x6d\xe3\xbe\xf5\x40\x2b\xa3\x1b\xaf\xa6\xbe\xf7\xc5\x89\xbf\x4b\x56\x7f\x60\x61\x46\x0e\x12\x50\x70\x98\x09\x79\x07\x66\x3b\x65\xef\x66\x44\x26\x4d\xeb\x21\x12\x92\x79\xbc\x12\x9b\x2e\x09\x57\x55\x36\x65\xaa\xd3\x98\xca\x1b\xab\x49\x23\xa1\x61\xa2\x83\x66\x8e\x9b\xb5\xc8\x11\xf9\x59\xd7\xc2\xc0\x9c\x91\x0b\x81\x88\x5e\x08\x74\x99\x5c\xa0\x6e\x4d\x7f\x8a\x10\x36\xfe\x82\x92\xec\x39\xe2\xf4\xac\x6d\x96\xec\x42\xfe\xca\xe8\x86\x3f\x9f\xd0\x5f\x1d\x5b\x36\xad\xc0\xcf\x71\x28\x3c\x9b\xb8\xd3\x1a\x92\xcb\xc9\x5a\x72\xf0\xb3\x3a\xf8\x85\x4b\x9b\x45\xe4\x30\x8a\x00\x37\xe4\x4c\x9e\x53\x38\x20\x77\x49\x31\xe8\xc5\xab\x7a\xf5\x8a\xcf\xaa\x15\x73\x67\x5a\x51\xf3\x22\x1b\xac\xb6\xff\x24\xe5\xaf\x12\xc6\x3d\xf9\x96\xe4\x10\x28\x26\x64\x30\x22\x5d\xeb\x92\x75\x52\x50\xd9\x32\xed\xb7\x2d\x53\x95\x75\xf1\x0a\xeb\x2a\x48\x38\xaf\x92\x70\x3c\x70\x17\x24\xc1\xcc\x03\x7b\xb9\x71\xc4\xf0\xb3\x04\xf9\x73\x52\xda\x45\x90\xa7\x19\xfe\x5c\x80\x69\x67\x6b\x55\x76\xc6\xeb\xec\x0c\x4d\x2a\xc9\x2f\xea\xc1\x77\x64\x3f\x41\x7e\x50\x13\x5b\xcc\x24\xbd\x4c\xd8\xfb\xa4\x49\x1f\x5a\xcb\x2c\x86\xd9\xe7\xc1\xf0\x49\x65\xca\x16\x1c\x65\xfc\xf3\xad\x20\xc7\x3a\x53\xb0\x48\x68\x98\xe5\x81\x77\x22\x08\x89\xed\xa3\x93\x3a\xe0\x77\xbc\x9b\x04\x82\x6b\xcf\x01\x07\x02\xe5\xbd\x44\x2e\xea\x3c\x38\x10\xfc\xf0\xfa\x86\x97\x1e\x50\x53\x29\xd6\xae\xdf\x31\xf5\x4e\x04\x89\xb5\x1b\x5c\x53\x53\xdb\x3c\x29\xd3\xc0\xbe\xe5\x5b\xd4\x34\x6b\xd8\x8b\x72\x71\x2f\xf6\x17\xb6\xdc\x60\x71\x67\x6d\xa6\x29\x76\xf4\x03\x4f\xfd\x41\x02\xaf\x05\x09\x6d\x17\xf8\x33\xc4\xae\xef\xc8\x69\x5e\x62\x10\xb5\x2f\x43\xc4\xd5\xbe\x35\x88\x86\x08\xc6\x72\x1e\x4a\xe1\xa2\x55\x57\xc8\x5c\xe5\xa8\x26\x7c\xfd\x89\x46\xf2\xe3\x27\x1a\xc9\xf3\xa4\xdd\xf4\x89\x06\xca\x9a\x6d\xf2\xb0\x11\xa7\x7b\xf2\x3c\xa9\x0b\xb2\xef\x68\x0a\xc7\xcb\x9c\xa0\xb0\x1d\x35\x24\xb5\xcf\x79\xc8\xb0\x92\xa2\x50\xb3\x3c\x51\x0c\x47\x43\xd1\x9d\xc6\x74\xa5\x55\x4f\x7a\xbe\x1c\xf9\xf5\x82\x6a\xf5\xe3\xc4\x5e\xb8\xad\x7a\xd2\x29\x7c\x59\xc6\x2b\xeb\x8b\xe4\x06\xcc\x0e\x8c\x31\x1f\x74\xdf\x0c\x7c\x60\xf3\x49\x16\x5f\xc1\x75\x3b\x23\xcc\xf5\x7f\x9c\xa0\xd4\xd3\xa1\xf8\x75\x16\x6d\x93\xe5\xbc\x6d\x03\x3e\x23\x5f\x92\xfa\x67\xc4\x73\x38\x1f\x35\x1c\x26\xf6\x4b\xf3\x16\x10\x7e\x81\xfd\x8d\x39\x1b\x97\x1a\xde\x26\xe4\x28\x31\x9b\x81\xc2\x49\x3b\xe3\xb5\x9b\xc2\x06\x4f\xa4\x14\x5e\x24\xd6\xc9\x84\x10\x4e\x12\xf2\x26\xa1\xf0\x46\x93\x0e\xcd\xdc\x24\x4b\xae\x93\xcc\xe9\x24\xc5\x6c\xd1\xe3\x44\x29\x7c\xcf\xa0\x35\x52\x84\x1b\xc3\x17\x2e\x74\xf1\x1f\x1e\x03\xb5\xd4\x45\x1d\x26\xbc\x4a\x1a\x7d\x38\x81\xa0\xf0\x3a\x61\xf8\x16\xd3\x13\x3b\x14\x3e\x24\x8c\xf8\x9a\x21\x03\xf9\x53\x43\x47\xc3\xf7\xc4\xa0\xfc\xa7\x86\x6b\x0d\xaf\xf3\xe7\xb1\x86\x17\xf9\xf3\x95\x86\x57\xf9\xf3\x44\x43\x24\xb2\xe7\x5b\x0d\x3c\x7f\xb6\x4a\x4c\xc3\x90\x2c\x2f\x48\xe9\x79\x45\x71\x53\x75\x47\x69\xd3\xb1\x24\x8a\xa6\xe0\xa3\x8f\xfc\x5d\x92\x45\xc8\x7c\x5e\xa1\xfa\xbc\x06\x09\x97\xf6\x63\x45\xf0\x71\x95\xe0\xf1\xe0\x7f\xf4\x14\xf8\xdb\x9e\x84\x80\x7b\x1a\x02\x8d\x69\xeb\xe0\x8f\x84\x4d\x25\x7c\x6a\x3c\x90\x33\xf2\x47\x02\x0f\x5c\x7a\xeb\x03\xe0\x7f\x78\xeb\x83\x14\xed\x27\x7f\x26\xec\x91\xfb\x9f\x8f\xe0\xef\x84\x4d\x24\xfc\xd5\x8a\xdd\x0d\x99\x91\x57\xb8\x59\x31\x80\x96\x37\xd3\x21\xbf\xdb\x25\x0e\x5a\xbb\x5c\x3e\x9f\xa3\xaf\xd3\x48\xfa\x77\xda\x2a\x09\x1c\x25\x74\xea\x19\x2e\xc9\x57\x3b\xfa\x3b\xde\xc6\xa0\xea\x63\x81\xb1\x27\x40\x78\xc8\x9c\x74\x5b\xdb\x28\x24\x1b\x98\x95\xc2\xed\xcc\xe7\x86\x9f\x16\x6f\x84\x79\x23\x0c\x52\xd9\xcf\xb1\x7d\x31\x2e\x6d\xcf\x77\x44\x71\x28\x81\x65\xa9\x8f\x84\x3b\x1e\xfa\x4c\xb8\x45\xb2\x46\xac\xd6\x47\x5b\x95\x70\x03\xc0\x9f\x03\xe0\xae\x0f\xdc\x0d\x80\xbb\x63\xe0\xae\xa0\xf9\x7b\x03\xcd\x47\x19\x29\x37\xde\x67\x46\x16\x88\x99\xe1\xdc\x21\x4b\xec\x97\x7c\x6a\x58\x2e\xa0\x14\x40\x04\x59\xb7\x16\xbb\x98\x42\x98\xe5\x99\x58\x40\xcb\x94\x67\x5d\xe7\x18\x0a\x23\x20\x98\x11\x14\x48\x61\xf6\x35\x08\x71\x25\x05\x6f\xa0\xf5\x0d\x11\x6f\x19\x7c\x53\x21\x4e\x20\x4e\x68\x11\x7c\xc3\x31\x3d\x97\x6f\x3f\xe1\x8c\xdf\x94\x1e\xa3\xdb\x77\x31\xfe\x29\xa1\x8b\x74\xfd\x8e\x68\x9e\x69\xf4\xf7\x44\xd8\xc9\x0f\x28\x44\x8b\x32\x1d\xf6\x6d\xea\x29\xbc\x67\xb8\xc8\x6e\x2b\x60\x82\x12\x50\x64\xa3\x16\x92\xa6\xf1\x59\xd4\x8b\xaa\xf6\x1a\x49\xe3\x0a\xd4\x97\xbd\x3e\xa9\x66\x4a\x53\x0a\x9c\x2f\xc6\xbc\x6d\x0c\x6c\x62\xe4\x6e\x37\x7b\x1a\x57\x9e\x85\xe1\x6f\x79\x77\xe6\x27\xee\x44\xfb\xc0\x4b\xdd\x76\x8c\x5e\x76\x31\x0c\x70\x6e\x23\x9c\x5b\x1b\x6f\xe8\xe3\xdc\xd6\xd1\xb2\xe2\x57\x50\xec\x12\xfc\xf0\x49\x00\x0a\x53\x39\xe4\x0b\xdf\xc7\x85\xc7\x2c\x23\xe9\x6d\x9e\x63\x07\x83\x2b\x25\xde\xfc\xe7\xd8\x11\xc7\xbd\x49\x04\xe3\x38\xc4\x31\x85\xd0\x6c\x1e\xf0\x19\xff\xd9\x21\x58\xc0\x22\x53\x10\xc1\xec\xf3\xc4\x60\x11\xd7\x76\x60\x88\x88\x14\x8e\x38\x08\xfe\x5b\xf3\x38\xce\xe7\x71\xbc\x3c\x8f\x66\x1a\x30\xdf\x13\x9e\x64\x1f\xa6\xcc\x20\x7d\x6b\xce\x36\x4c\x96\xce\xf6\x00\xa7\xc5\xb7\x31\x0d\x8b\x33\xaa\x6d\x82\x81\x62\x46\xb3\xb4\x8a\xd9\x8c\x56\x1b\x06\xd8\x79\xc4\x02\x77\x8c\x59\x66\x04\xe0\x35\x45\xc0\xd0\x2f\x98\xb2\x10\x51\x08\x11\x85\x70\x69\x66\x03\xd7\x87\xa0\x9c\xd9\xc8\x2c\x8d\x1b\x40\x64\x40\x56\x4e\xb2\xd9\xf3\xf1\x12\x2e\xd5\x59\x8d\xf8\x0a\x23\x5a\x3e\x7d\xdc\x4c\x1d\x37\xd3\x56\x0f\x74\xb4\x37\xc1\x3b\xdd\xae\x7d\xe0\xd5\xb7\xe3\x6c\xfe\xf3\x5f\xa5\x6a\x17\x70\xc3\xf8\xf0\x9e\x7f\xe9\xaf\x6b\x7c\xa9\xd2\xea\xa8\x75\x8d\x8a\xe6\x5b\xcc\xe0\x6a\xb6\x27\x52\xab\xf8\x97\xf6\x48\xc5\x42\x84\xa7\xc8\xc7\xd5\x0f\x8a\xed\x9e\xe4\xa9\xd1\x4b\x33\x08\x6f\x9a\x0c\x6b\x86\xe1\xb9\xa3\x03\x3b\x88\x72\xf0\x31\x8b\xaa\xab\xa6\x39\x44\x2e\x2f\x16\x2a\xe6\x24\x32\x67\x27\x2e\xd6\x22\x4e\x6a\x83\xcd\x08\x39\xc7\x0b\x4f\xf4\x17\x8a\xe2\x24\x85\x70\x39\x0e\xba\x21\x1e\x35\x4e\x1a\x9c\xce\x0a\x93\xc2\x2b\x1c\xb9\xb2\x23\xbf\xc0\xeb\x7a\x7b\xfd\x72\x1e\x79\xbe\xd6\xd5\xe1\xdb\x8f\xe1\xe1\xd4\x44\x66\x6a\xa2\xbc\x2c\x36\x53\xa3\xca\xa9\x89\xf3\xa9\x09\x59\xbc\x30\x35\xb1\x6b\xfe\xe7\x43\xec\x06\x30\x23\xa1\x21\xbb\x31\x92\x96\xb6\xe9\xb1\x9b\x34\xab\xca\x97\xa6\xa8\xbd\x78\x46\x7c\xf3\xce\x27\x51\x85\x99\xe3\x6e\xc7\xef\x2d\x37\x4f\x60\x6e\x46\x7b\xf8\xa5\x79\xdb\xb7\x5f\x79\xcf\xe6\xa7\xba\x1f\x6b\x67\x07\xc9\x52\x27\x13\x38\xec\xbe\xcc\x8f\x25\xea\x23\xe3\x34\x25\xc5\xc5\xbf\x7c\x6f\x8d\x70\xba\x74\xb1\x8f\xb8\xd9\x07\x01\xa5\x5e\x75\x7e\x34\x2f\x86\x95\x4d\x41\x40\xab\x13\x49\x61\xba\x3c\xce\x5c\xe5\xc0\xfa\xaa\xe4\x78\xda\xe0\xa8\x4b\x8e\xa7\x17\x88\x61\x1e\xd4\x6e\x58\x8f\xb6\x1c\xef\xb6\x9d\xa7\x2a\x92\x59\xfa\x75\x99\x25\x51\x60\xf6\xd2\x29\xc7\xb7\xde\x3d\x49\xcc\x93\xc0\xaf\x7f\xa4\x14\x26\xf5\x23\x5d\xff\xf4\xf2\x58\x04\xf1\x58\x7c\x38\x39\xdc\x8f\xaf\x6f\x62\x89\xa9\x1f\x5b\x3e\xc2\x0c\xe3\xd6\x4b\x02\x47\x3a\x37\x94\x8e\xac\x24\xef\x65\xb6\xab\x3c\xae\xbc\xd3\x3e\x5d\x7f\x25\xe0\x30\x27\x4b\x52\xa7\x8d\x80\xab\x8d\x54\xdb\xed\xae\xe3\xbf\xb5\x58\x07\x14\x85\x26\x1c\xd5\xb5\xaa\x85\xb5\x50\x63\xab\xee\xb6\x09\xaf\x64\x4a\xcf\x08\x2d\x3a\x66\x6f\x39\x70\x18\x73\xfc\x9e\xc5\x42\x54\xee\x55\x0b\x9e\x20\x9a\x4c\xc5\x35\x5a\x5e\xe4\x55\xcd\xc9\xa2\x72\x75\x11\xaf\x17\x85\x56\x6a\xd7\x46\x40\xd6\x76\x54\x98\x8a\xb5\x21\xf0\xe2\x48\xdb\xd8\xd9\xb6\xdf\x66\x2d\x88\xb4\x51\xaf\x1d\x20\x22\x9b\xc3\x47\x8e\x99\x6d\x6e\x54\x07\x22\xcc\xfc\x61\xac\x82\x70\xf9\x48\xb8\xbe\x27\x28\x05\x33\x07\x78\xef\x3b\x08\xa9\xdb\x19\x85\x89\x87\xf1\xac\x1d\x0e\xa1\x39\xea\x06\x48\xd7\x7e\x0b\x85\x1a\x50\x3f\xe0\xd8\xde\xce\x82\x6b\xde\x10\xd6\x56\x44\xb1\xff\x30\x2a\xef\xdf\x09\x0c\x00\x5f\xfd\x99\xc0\xa7\x84\x38\xff\xfc\x33\x42\xa5\x53\xba\xfc\x07\xb5\x2e\x36\x7f\x74\x48\x32\xdb\xb9\x8d\xd0\x9c\x91\xcf\x09\xde\xf0\x43\x9d\xe5\x42\x53\xef\x90\x98\x71\x5c\x68\x0a\x66\x58\x57\x1c\x3e\x24\xf0\x96\x48\x78\xe0\x3f\xbc\x0b\x0d\x9c\x7b\x98\xab\x30\xf4\xb4\xeb\xa7\xf5\x03\xf0\x2e\xf1\x84\xcb\x53\xb8\xe1\xd9\xf5\x9a\x4b\x5e\x84\xa4\xd9\xa7\x9d\x14\xee\x9b\x46\x72\x8d\xfc\x67\x29\xa9\x42\x9e\xa4\xc0\x7e\xa2\x99\x63\xac\x7f\xfd\xae\xb5\x51\x67\x6b\x05\x9b\x65\xc1\x93\x5a\xc1\x56\x59\xf0\xb4\x56\xd0\x2f\x0b\x76\x6a\x05\xf9\xa7\x63\xd7\x2e\xf9\xc2\x37\x5b\x67\x7c\x51\x3e\xbf\xe1\x69\x0a\x07\x4d\x1a\x63\xe5\x5a\xd3\x5d\x4b\x79\x7e\xad\xe9\x5b\x4b\x79\x6e\xd3\x7a\xd6\x52\x9e\x5f\x7b\x3a\xe5\x99\x02\xbe\xbf\x4a\x20\xca\xd5\xeb\x4b\xa3\x78\xbe\xf3\x38\xf8\xa7\x5e\x00\xfe\xdf\x9e\x00\x7f\x60\x14\xd1\xd8\x68\xdb\x53\xab\x86\xbe\x6f\x25\x38\xca\xda\x71\xb2\x8b\x2b\xf8\xa1\x5e\x6b\x84\x79\xc9\xd9\x2c\x81\x23\xce\x5e\x0b\xb8\x68\xd4\xa1\x8f\x38\x29\x1d\xc8\x4f\xac\x03\x99\xa6\xf0\x95\xb3\x37\xf0\x83\xb3\xbf\xe1\x39\x67\x5a\xc2\x61\xb3\x02\xde\x73\x9c\x14\x8e\x97\x84\x24\xfb\xa1\x96\x3c\xef\xd0\xa3\xb3\x7f\xa6\x77\x7e\x7c\xfe\xc8\xd5\x62\x8a\x04\xb5\x38\xba\xd9\xd5\xe9\x5e\xe1\x7a\x52\x8c\x29\x73\x16\x14\xc6\x2a\xc3\x17\xce\xde\x27\xf0\xb6\xb1\x73\xfc\xb2\xde\xc0\xae\x67\xb3\xaf\xbe\xe6\xfd\x52\x34\x77\x23\xa7\xf0\x86\xb3\x19\x79\xc9\x17\xbf\xfa\xfe\x74\xef\xa3\xa8\xa0\xf7\x96\x93\xec\x43\x9a\x62\xbc\xc6\xf5\xda\x75\x3c\xd5\x6b\x4f\xd7\xc6\xd1\x65\xa4\xa7\x80\x9f\xa9\xbd\x8c\xf5\x9a\xd3\x3b\xe4\xc4\x36\xa4\xd9\x78\x8e\x39\x71\xfa\xae\xd3\xab\x04\xba\xba\x9d\xd1\x5b\x4e\x7e\x3b\x94\xf6\x0b\xd3\xe1\x24\xe6\xda\x5b\x73\x7e\xeb\xc9\xde\x6f\xce\x6f\xd4\x7b\x2b\xc8\x73\x4e\x06\x62\xeb\x77\xcb\x24\xe0\x2f\x41\xbe\x70\xe2\xa3\x53\xf1\x84\xb3\x63\x0d\x2f\x38\xfb\x49\x46\xfa\x13\x4e\x64\x6f\xb7\xff\xbb\xfa\x7d\xb7\xff\xfb\x40\x6c\x99\x67\xa2\x37\x38\xc5\x1f\x06\xb8\xe8\xe1\xd7\xf1\xbf\xf3\x96\x34\x99\x7d\x14\x60\x6b\xd1\xc6\x20\xd8\xf6\x16\xa6\x9e\xdb\xde\x61\x4c\x8f\x06\x5e\x1f\x12\x26\x86\x49\x99\x4e\xa2\xd7\x2b\xf3\x27\x55\x1b\x27\x59\xc2\x9a\xed\x27\xf3\xf9\xce\xe3\x3d\x5e\x59\x78\xc5\x06\xfd\xdf\x55\x8f\x6f\x6c\x3f\x29\x72\xd1\x60\xd2\x61\xb4\x2b\xdb\x9e\x36\x94\xa7\x68\x0a\xaf\x2a\xc8\x56\xef\x95\x2d\x2f\xa0\x75\x86\x52\x23\x0c\x64\xc4\xec\x7b\xf5\x5b\x53\x8b\x8b\x10\x49\x2d\x2e\x85\x5a\x58\x06\x55\xb9\x32\x56\xdb\x02\xb8\xd0\x9a\xf6\x9c\x95\x5b\xa0\xb6\x72\x29\xbc\x6e\xdc\xbb\x06\x6e\x8e\xc5\x98\xdf\x7b\x16\x02\xc6\x99\x7d\xe0\xec\x2f\x78\xd7\xd4\x6a\x7d\x46\x3e\x70\xd8\x06\x49\xbb\x5d\x82\xcf\x83\x7e\x1f\x24\x9d\xcf\xb3\x12\xfc\x45\x53\xf8\xdc\x44\xd6\xe5\x46\x9e\xc9\x92\xa8\x47\xdb\xf3\x3e\xdd\x20\xea\xd1\xa0\xdf\x9f\xf7\x69\xcf\xbc\xc1\xa7\x14\x3e\x36\x1c\x8d\xdc\xae\xcd\xab\x9a\xaa\x5d\xd9\x7e\xbe\xa4\xaf\x39\xe1\xf9\xf6\x5f\xee\x7c\x6b\xb0\xb3\xb5\x2b\x76\x7f\x27\x62\x63\xf0\xf4\x71\xdf\x30\xc0\x27\xbb\xdb\x62\xe7\x77\x42\x92\xbd\xad\xf9\x7c\xfd\x9d\x91\x4e\x46\x7c\x63\xe0\x71\xda\x23\x9f\xcd\xaf\x8d\xcf\x9c\x60\xe5\x92\xb1\xbd\x15\x44\xf6\x54\x4f\xd3\x34\xe7\x4f\x49\xf1\x39\xa1\xac\xca\xd6\x60\x8f\x8f\x10\x19\x4f\x91\xfe\x62\xf2\x9b\xcd\xa7\x7b\x7c\x3e\xdf\x7c\x6a\x54\x8e\x6e\x37\xeb\x35\xaf\xbd\xb9\xfb\xf8\xc9\xb6\xd8\xa1\x0b\x69\x77\x6a\x10\x77\xfa\x4f\x1f\xef\x16\x75\x8a\xc4\x3d\x5b\xfd\x4a\x9d\xc7\x8f\x1f\xef\x8a\xdd\xc5\x44\x24\x35\x30\x83\xfe\xd6\xee\x93\xa2\xce\x6e\x23\x98\xc1\x56\x7f\x7b\xb7\xc4\xe7\x71\x33\xa0\x9d\xdd\xad\x0a\xd2\x4f\x9a\x2b\x3d\xd9\x1a\xec\x3e\x29\x2a\x3d\x6d\xec\x6e\xb3\xff\xf4\xe9\xce\x66\x51\xa9\xfc\xaa\x6e\x0d\xd4\xe6\xd6\xce\x93\xc7\x95\x5a\x83\x66\x58\xbb\x9b\xbb\x3b\xe5\x34\x95\x1f\xef\xad\xc3\x7a\xf2\x64\xc7\x4e\xe6\x02\x03\xaf\x9e\xd1\xeb\x58\xea\x2b\x3c\xa1\x87\x46\x41\xc5\x53\x9a\xa6\xb0\x1c\xf3\xd2\x7a\x7d\xec\x98\xe4\x5f\x1c\xc9\xdc\x7b\xaf\x38\xd9\xa6\x70\xc1\x89\xb3\xe1\xd0\xca\xcb\xcd\xea\x4b\xfc\x4d\x29\xfc\xd1\xa4\x7b\xe4\xec\xef\x77\x62\x88\x6d\x0f\xf5\x8a\x4f\x0d\x07\x27\xc7\x20\xf3\x3d\xd7\x50\xae\xfe\xb1\xb1\x20\x2f\x90\x02\x20\x0e\xa7\xce\x32\x5e\x5e\x13\xb2\x5e\x05\x59\xa8\xf5\x63\x61\x1e\x6b\x5b\xcf\x35\x00\xdf\x70\x6a\x63\x4e\xce\x69\xa5\xb6\x6a\xf2\x2b\xf7\x53\x6c\xf6\xb7\xc5\x63\x71\xae\xff\xe0\x3f\x69\x3e\xb0\xcd\x7b\xb6\x79\x53\x95\x8d\xac\x8a\x99\xed\xf3\x9f\x0c\xac\x2c\x7f\x2b\xc8\x2d\x79\x61\xf4\xb9\x7e\xfe\xff\xd6\x55\x89\x01\xae\x1f\x39\x85\x3f\x9b\x28\xa7\x8d\x53\x36\x22\x92\xf3\xfe\x2a\x4e\x26\xe3\x35\x19\xeb\x35\x5f\xac\x89\xeb\x1b\x7d\xef\x18\xfd\xec\x3d\x87\x97\x82\x38\x9f\x54\x2c\x2f\xd7\x0e\xdf\xbf\x7d\xb2\xdb\x1f\xac\x85\xb1\xba\xe6\x1a\xbd\x53\x6f\x13\xf8\xc4\x2d\x79\xfd\x9b\xaf\x72\x95\x2c\xdc\xd5\x80\xb1\x75\x95\xfc\xc5\x99\x94\x20\x83\x36\x11\x4e\x48\xa2\xe8\x23\x21\xed\xdd\x54\x15\xb4\x5c\x18\xd6\x01\xfb\xcb\x48\x6c\x32\x80\x4d\xd8\x32\x8b\x2e\x30\x19\x69\x12\xb0\x03\xf2\x37\x87\x3e\xe8\x00\x84\xf9\x8f\x02\x0f\xd8\x04\x82\xe5\x1e\xab\xf1\x00\x46\xe5\xe4\x01\x6c\x6d\x82\xb4\x5f\x1e\xf5\x21\xb1\x4e\xce\x6c\x20\xda\x28\x11\xd9\x07\xe3\x45\x79\x17\x16\x43\x3b\x86\x92\x09\x50\xd6\x81\x1f\x35\x63\x6c\x5a\xc7\x3f\x43\xe1\x2f\x4e\xd4\xa3\xad\xcd\x42\x87\xd5\x65\x7c\x51\x8e\x9b\xcb\x87\x92\xcd\x48\x10\x80\x84\x0e\x05\xc5\xec\x65\xa9\x80\x29\x09\x7e\xeb\xa4\xf6\xf7\x2e\xf0\xf7\x48\x7a\x98\x12\xa2\x05\xc7\x3c\xf6\xf9\x76\x19\x10\x46\xed\x8a\x1c\xd1\xad\xcd\xdf\x95\x2b\x40\xb0\x30\xb0\x6b\xb0\xb5\x09\x7a\x63\x80\x1f\x27\x93\xa3\x0f\x46\x33\xbd\xa4\x9e\x72\x2f\xf1\x6e\x70\x1c\x40\x82\xe6\xf0\x9c\x7d\xe1\x0a\x4d\x03\xa2\xdc\x90\xf6\x8c\x9a\xe8\x07\xb0\x03\xe2\x77\x6d\x16\x0b\xcc\xdb\xb4\xa1\x66\xb6\xa2\x58\x4c\x61\x12\xb0\x10\xc6\xc1\x4f\x42\x3d\x0c\xda\x25\x6f\x9e\x91\xdb\xc0\x48\xc2\x0f\x97\xe8\xd3\xd2\x8f\xb6\x36\xe7\x7d\x08\xbd\xfc\x53\x2c\x56\x55\x01\xee\xdd\x93\x09\x8e\x09\x2f\x19\x64\x57\x23\xd4\x86\x19\x24\xc6\x6b\xe0\xbe\xe0\x20\x68\x1e\xb5\xd1\x69\x9c\xb0\xfe\x9e\x2c\xdc\xd9\xff\xb1\xb5\x89\x21\x7a\x93\x00\x34\xc8\x0d\x5d\x71\x3e\xdf\x91\x31\x7e\x1e\x63\x43\x9b\x1e\x24\x74\x40\x14\xe3\x4f\x82\x94\xc2\x55\xd3\x72\xad\x4b\xb7\x93\xc2\x75\xdb\x92\xe7\x1a\x5c\x7e\xf1\xe1\x66\x45\xc5\xda\x0d\x89\xcb\x15\x15\x6b\xf7\xa9\x66\x4d\x58\x55\x14\xcb\xfb\xc6\x4d\x86\x77\xaa\xdb\xb4\xb7\xde\x20\xa5\x18\xb1\x97\xc2\x41\xc0\xbe\xc1\xdd\xe2\x47\xf2\x16\x2e\xa5\x0f\xf6\x98\xdd\xd7\xa5\x0d\x2d\x13\xd1\x20\x61\x6a\x63\x80\xbb\x0f\xaf\xf3\xea\xe2\x8c\x82\x66\x1c\x6f\x76\xb5\x1e\x96\x7b\x72\x17\xa0\x09\xb3\x83\x41\x5f\x2b\xea\x1d\x04\x18\x50\xf6\x2d\x80\x3e\xdc\x07\x44\xd1\x8d\x41\x76\x0d\xe0\x34\x60\xef\x60\x3f\xf8\x37\xae\x30\xa2\xb2\xb7\x78\x8f\xf1\x90\x7c\x21\xf2\xac\x7f\x4e\x41\x66\xdf\xe2\x1b\x50\xea\xe5\x6f\x7b\xf2\x6c\x50\x29\x32\x6c\x1a\x95\xc5\xf7\x8d\x33\x6f\xad\x2a\xff\xc8\xb5\xb5\xb5\x35\x27\xb3\xeb\xfc\x23\x1d\x4b\xca\x5f\x06\xec\x48\xc2\x51\xdb\x58\x9d\x7f\xe4\x3f\x92\x58\xd9\xbc\x37\xa0\x3d\x87\xae\x39\xbd\xf7\x01\xb9\x08\x32\xaf\xf9\x45\x4b\x97\x5f\x2d\x9d\x4a\xe1\xeb\x32\xe8\x55\x01\x28\xb9\x53\xa7\xf4\x23\x54\x18\xa7\x4d\x1a\xb3\x1f\x64\x6a\x55\xe6\x88\x28\xf3\xd4\xdb\x18\xe9\xf2\x3b\x46\xb9\xaf\x96\x4c\x05\x51\x4c\xbb\xdc\x86\x94\x2b\x4a\xbb\xdd\x19\x39\x0d\xe0\x36\x31\x47\x8e\xe0\x37\x2f\x20\xb0\x7b\x46\x8c\x1c\xd7\xe9\x25\x9e\x73\xf6\x9b\xd3\x4b\x7a\xce\x6f\xe7\x8e\x4d\x6f\x80\x01\xf8\x0d\xf9\x23\x6c\x7c\x8c\xb5\x4d\x3b\x67\x76\xae\x5c\x4e\x7b\xce\xb9\x33\xac\xc0\x8d\x56\x41\xd9\xf4\xb2\xfb\x6f\x2e\xb7\x97\x76\xad\x8d\x30\x2e\xed\x9d\x21\x23\xca\xf5\x47\xce\xe9\x95\x58\xfb\x63\x1a\x4b\xf7\x05\x5a\x6a\xdd\x58\x8a\xb7\xa1\x51\xce\xbf\x4e\x63\xe9\xf4\x72\x13\xda\x07\xbc\xda\xed\x39\x4b\x55\x1d\xa3\xbe\x85\x3c\x9a\x88\x31\x7e\x70\xe5\x4a\xac\x85\xf1\x64\x12\xcf\x22\x79\x69\x95\xb0\xfb\x80\xc4\xd4\xd4\x9a\xf1\xfb\xa9\xe7\x0c\x17\xb6\x91\xd9\x3a\x38\xa0\x10\x66\xe4\x59\x00\x47\x01\xc4\x46\xd1\x93\x8c\x33\xcd\x62\x8c\xfa\x09\x98\x5a\x36\x64\x3a\x27\x5c\x1a\x8d\x33\x5e\xe3\x0d\x23\x98\x45\xfa\x6a\x4d\xc6\x6b\x37\xf1\x74\x1a\xf9\xd1\x24\xd2\x91\x98\x3a\x3d\x3b\xe8\xf6\xf1\xad\x3b\xb4\x16\x7d\xe4\xe3\xe2\x4f\x71\x49\xb2\xc5\x0f\xd1\xd4\xe8\xbc\x53\xb1\x3f\x11\xd7\xb6\x23\x33\x6c\xcc\x2f\xd8\x06\xb9\xe7\x78\x66\xa8\x78\x66\xbc\xe5\xb6\x97\xd1\xad\x90\x16\x02\xd6\x73\x68\x8f\xbc\x37\x2c\xf1\x65\x00\xdb\x30\x35\xed\xb3\xd7\xbe\xa1\x39\x3f\x02\x76\x25\xe1\x79\x0b\xe1\xcc\x2d\x6a\x87\x41\x66\xa9\x3c\x6e\xa9\x98\x87\x8b\x7d\x31\x5b\xea\x47\xd0\x10\xa2\xfd\xe7\xa2\xb6\xff\x3c\x20\xce\x7e\x21\xf0\x59\xeb\xfe\x9a\x8e\xae\xc5\x9a\xd3\x93\x3d\xc7\xe8\xdd\x46\xdd\xf7\x8e\xed\x47\x46\x0d\x12\x14\xde\x06\x6c\x2c\xe1\xcd\x0a\x02\xf8\x59\xc3\xdb\xc0\x72\x49\x0a\x27\x6d\xe3\xda\x04\x1f\xf1\x7d\x11\xb0\x6b\x09\xdf\x03\x76\x2f\xe1\x55\x5b\xe5\x1d\xb8\xc4\xca\xaf\x1b\x29\xca\xab\xc0\x0a\xdb\x2f\x02\x38\xd2\x46\x54\x3b\x0e\xc8\x85\xb6\x52\xef\x87\x80\xf9\xe4\x7b\x00\xfb\x1c\x70\x5a\x30\xe0\x0a\x23\xad\xe0\x38\xa0\xf0\xda\xac\xcb\xdb\x00\x1c\x2e\x65\xac\x31\x79\xde\xd4\x81\x93\x80\x1c\x06\x59\x2c\xb0\x29\x9c\x70\x5f\x4c\xca\xf7\xb6\xd5\x9b\x00\x6e\xc8\x59\x1e\x06\x05\xc5\xbd\xfe\xe7\xf7\x0e\x38\x7d\xe7\x9c\x02\xd6\x45\xb4\x5e\x6a\x83\x50\x73\xbb\xe2\xfe\x7f\xbd\x61\xde\xf7\x54\x73\xa5\xa7\xcf\xb4\x03\x5f\x82\xfc\xdd\xa5\x90\x42\x71\x1d\xab\x0f\x27\x47\x8e\xed\xe6\x5d\xcb\xd4\x3d\xce\xa6\xf9\xb3\xd9\x16\xa6\xed\x98\x6b\xee\x58\xac\x9e\x05\x36\x41\xcc\x21\x87\xef\x1a\x61\x90\x0f\xd8\xf3\xc7\x76\xd9\xe2\x8f\xd6\x85\xcf\xcc\xac\xb8\x63\x7e\x24\x95\x3c\x41\x9f\x56\x08\x0f\xdb\x55\xe1\xe1\xcf\x96\x31\xe4\x56\xe7\xbf\x7f\xb2\xf5\xff\xc2\x33\xb2\x99\x82\x8c\x32\xf3\xb2\x8a\x9a\xf6\x4b\xc6\x1b\x52\xd0\x4d\xc5\xd9\x07\xda\x1d\x2d\xee\xb4\x93\xdf\x1a\x8b\xd8\x81\x84\x24\x62\xc7\x1a\x78\xb4\x3a\x2c\x3e\x89\xc8\x83\x3f\xf1\x04\xf8\xaf\x3d\xc2\x8d\x6c\x11\x91\x26\x8f\x88\x88\xec\x05\xa3\x49\xcd\xef\x94\xcd\xe2\x45\xb0\x68\xad\xa6\xe0\x9f\x78\x0a\xfc\xc7\x9e\x84\xe0\xce\xbb\xd0\x10\xbc\xf0\x34\x04\x87\xde\xfa\x20\x97\x54\x53\x0a\x41\x94\xdd\x4d\x8f\xa2\xf6\x1c\x2c\x3c\x02\xe7\xd5\xc1\xa9\x03\x1d\x90\x10\x44\x56\x3a\x89\x23\x1b\xcf\x28\xa2\xec\x48\x08\xa5\x62\x95\x6d\xaf\x8b\x84\x42\xd8\x32\x5b\xb9\x6c\xe7\xb7\x94\xe7\xcb\x37\x8d\x56\x18\x0b\x88\xca\xf2\x90\xdd\x46\xec\x8b\x84\x49\xc4\x9e\x4b\x18\x47\x6c\x12\x91\x3e\x85\x4e\xd4\x96\xec\x6f\x46\x6e\xa3\x26\xab\xc2\x24\x22\xf6\x1a\x9a\x25\x43\x57\xb5\xbe\xed\x2d\x80\x66\x10\xea\x57\x40\xcf\x48\x96\x8d\x29\x35\x32\x82\xed\xe2\x3a\x62\x7f\x4b\xb8\x59\x9e\xf6\xcc\x8d\x9d\xaf\xf2\x0b\x49\x10\xf2\x75\x94\x19\x63\x8d\x7c\xbd\x38\x35\xd5\x2b\x58\x51\xb3\x05\x82\x64\xc9\x66\x6e\x22\x9b\xb6\xc7\x26\x9c\xb9\x8a\xc8\x9d\xa6\x30\x89\x0c\x85\xd3\xb4\x92\xbb\x65\x56\xeb\xa3\x3a\x9a\xbe\x41\xe1\xbe\x75\xbf\x20\x0a\xf6\x4e\xc8\xf0\x93\x74\x4f\xf9\xf4\x1b\x7b\xf0\xbd\x71\x04\x81\x77\x19\xc1\xd8\x9b\x45\x20\xbc\xfb\x08\x42\x6f\xaa\xad\x17\xe1\x20\x82\xbb\x08\xbe\x45\xf0\x2c\x82\xd3\x88\xfd\x25\x89\x63\x9a\x39\x14\xf6\x23\xf6\x56\xc2\xfb\xd6\xce\x4e\xcd\xe4\xee\x47\x30\x23\xd3\xec\xcf\x24\x32\x24\xfd\x2b\x86\x8b\xde\x2e\x17\xfc\x48\xa8\x4d\xab\x44\xe1\xe5\x8a\x21\xbc\x8f\x50\x2a\xff\x68\xb6\xdd\x05\x4e\x7a\x53\x06\x82\x8c\x32\x8c\xc2\xfa\x91\x5d\x92\x45\x73\xc3\x9e\x93\xa5\x89\x5d\x13\x77\x81\x10\x63\x31\x76\xea\x26\x55\xe7\x58\xe8\x59\xac\xbe\xad\xd9\xb3\xb4\x60\x3b\x45\x17\xe8\x21\x27\x04\xbd\xc0\xd4\xe5\x3b\xae\x9f\x50\xfc\x58\xa5\xc2\x1f\xbb\x10\x47\x36\x49\x6e\x61\x52\xcd\xf5\x85\x5c\x82\x71\x3e\x48\x91\x9b\xe0\x95\x98\xde\xc4\x72\x2a\xd6\x42\x15\x5f\xaf\xf1\x9b\xc8\x70\x70\x23\x35\xd6\x2d\x88\xce\x1b\x3e\x09\x63\x75\x2d\xc6\x6b\x89\x9a\x64\x75\xd2\x14\x05\x53\xea\xf9\x91\x8d\x5b\xa7\x70\xd4\x48\x3c\xe5\xc8\xd1\x2a\x11\x8e\x97\x25\x14\x4b\xe1\xa2\xb9\x9e\xdb\x99\xcf\xf3\xe8\xd3\x91\x44\x1d\xe4\x6b\x63\x4d\x21\x1b\xc2\x0a\x52\xf8\xd1\x58\x39\x4f\x6a\xf6\x35\x82\xaf\x46\xef\x70\x98\x83\x9e\x84\xe7\x4d\xc4\x25\xd3\xfb\x88\xaa\x39\x7f\xb5\x0d\x38\x28\x62\x1e\x0e\x5b\xb7\x0d\x9e\xa8\xe7\x78\xbe\x3a\x96\x48\x1e\x47\x8d\xda\x1b\x0f\xac\x66\x61\x23\xdb\x02\x9b\x88\xe7\x0b\x6a\x9a\x87\x8d\x34\x64\x46\x7e\x44\xd9\x55\x3d\x9f\xa6\x60\x93\xb4\x14\x99\x81\xe0\x48\x93\xa3\xc8\xe6\x7e\x5b\xc7\x2b\x7d\x78\xe3\x0d\x0e\xab\xd9\x82\x16\x2a\xe9\xbc\x46\x16\xc4\x0d\x17\x11\x11\xf6\x4d\x91\x81\xc8\xbc\x53\xf6\x9d\x4d\x51\x04\x68\x1b\x1c\x16\x06\xa1\xfb\x80\x70\x3a\x72\x46\xb9\xc4\xdb\x75\x80\x53\xcf\x71\x52\xf8\xd2\x46\xd7\x6c\xc5\x47\x0e\x5e\xd1\x81\x3c\x2b\x52\xef\xd8\xf4\x54\x81\xfd\xd2\x60\x1a\x45\xa0\xe1\xb3\x0d\xfe\x79\xdb\xca\x7b\x2d\xb7\x78\x93\xf3\xf0\x93\x9f\x54\x7c\xf1\x13\xb6\xf3\xbd\xa5\x3c\xf7\x45\xbf\xfa\x09\x5b\x7b\xdd\xba\x3d\xde\x12\x05\x0f\xfe\x8e\x57\x44\x37\x9c\x24\xf0\x26\x01\xb3\x01\xb2\xfb\xcf\x1f\xa2\xff\x93\x64\x6c\x66\xff\x8f\xf2\xa0\x18\x8a\xc6\xb9\x2c\x21\xdb\xbb\x96\xa3\xe6\xa7\xf0\xb9\x79\x67\x06\x07\xe5\x87\x06\xfd\x7e\xcf\x6e\x17\xc7\xb1\xa1\x18\x51\x00\x5f\xcd\x79\xfa\x10\x59\xb9\xf8\x5d\x04\x1a\xef\x4b\xbe\xa1\xd4\xde\xd8\xb4\x2e\x85\x9e\x32\xff\xa4\xf0\xb1\xad\xfb\x91\xf3\x90\x6f\x19\x40\x3b\xc2\x47\x0d\x9f\x0d\x79\xa6\x3d\x27\x75\x70\x03\xfd\x81\xeb\xb9\x9d\xc2\x27\x94\xa2\xfe\x6c\x8e\xd5\x92\x0c\x05\xbd\xd5\xec\x21\x63\x47\x66\x42\xfe\x8a\xd8\x8d\x04\x19\xb3\x95\xe4\x7a\xc5\x65\xa1\x05\x0f\xd8\xa2\xb3\x65\x2b\x4d\x41\xc5\xec\x23\xe8\x98\x7d\x02\x11\xaf\xca\xe3\xe0\x38\x79\x22\x87\xec\x02\x65\x12\xb3\xcf\xc0\xe3\x9f\xf8\xa5\x1f\xf8\x0f\x8f\x03\x7f\xe1\x29\xe0\xdc\x13\xc0\xdf\x7a\x1a\xf8\x7b\x23\xe6\x85\x36\xb4\x21\x88\xdb\x23\xec\xbf\x0b\x92\xd0\xf9\x7c\x46\x92\x18\x9c\xff\x9f\x39\xd0\x0b\xf1\x03\x86\x06\xe9\x18\x1c\xcf\xc9\xae\x63\xf3\xcc\x7e\xc0\xd1\x7e\x50\xaf\x9c\x67\x4e\xfc\xce\xc9\x8c\x7c\x12\x10\xf4\x06\x78\x59\x2f\x33\xa8\x44\x4b\x69\x36\x63\x16\xe5\xfb\xeb\x48\x93\x5b\xc2\x63\x64\xb3\x22\xb6\x1f\xfd\x89\x33\xf3\x7f\x35\x3e\x29\xab\x94\xc0\x85\x2e\x4a\x29\x44\x71\x5b\xba\xc7\xef\xc2\xd0\xb1\x7a\xb7\x49\x36\xa8\x47\x0e\xe4\xb9\x15\xfc\x86\xab\xb3\x77\x24\xb0\xf8\x7c\x12\xd6\x32\xab\xf0\x3e\xa1\x88\xf1\x57\x25\x88\x11\xab\x61\x54\x54\xf6\xc9\x7c\x88\xe3\xe6\x48\xfc\xef\xc2\xc8\xa9\x75\x6c\x44\x86\xcd\xc8\xc9\x82\xd7\xeb\x19\x2a\x4b\x03\x77\x64\xba\xc1\x58\xa6\x4f\x02\x92\x1e\x12\x6d\xbc\x84\x2a\x62\x48\x50\x14\xac\x57\xb5\x33\x64\xd0\x09\x97\x77\x9e\x45\x46\x2d\x22\xa3\x33\x64\xfe\x97\x93\x39\x26\x6a\x19\x80\x2a\x37\x87\xe3\x2a\x32\xa2\x37\x30\x27\xca\xa2\x22\xaa\xf9\x28\xb3\x8a\x06\x15\x8c\xd9\x8c\x9b\x6d\x7a\x2a\x06\xe7\x4a\xeb\x1b\xef\xd1\x23\x07\x90\x7c\x85\x31\xf4\xed\xd4\x3f\x36\x84\xc0\x2b\xeb\x4c\x6b\x95\x06\xb6\xd2\x13\xac\x64\xa4\x84\x69\xcc\x84\x26\x4e\x18\x07\x78\xbd\xe8\x36\x66\x7f\x29\x98\xc4\x4c\x2a\xe8\x34\xad\x8a\x1d\x1b\x12\xe3\x60\xe6\x1d\x69\xf2\x31\x32\x83\xde\xa1\x95\xe4\xc3\x87\xe4\x2d\xd1\x48\xac\x3b\x29\x85\x49\x6c\x0d\x06\xb7\x31\x68\xd7\xef\xc3\x09\x91\x70\x8c\xec\xd2\xcc\xc0\xfb\x08\x5e\x0a\xf2\x47\x44\x61\x1a\xe7\xec\x74\xc3\xe7\x6a\xe3\x9a\xeb\xe0\x0a\xef\x47\x65\xd7\x6a\xaf\x96\x57\xa5\x9a\x1d\x55\x15\xe7\x2b\xb3\x3f\x62\x60\x9b\x59\x93\x4c\x39\xce\x0a\xfb\x99\x33\x01\xbd\x36\xd7\x71\xbb\xaa\x73\x15\x37\x5f\x72\x47\x7a\x63\x39\xc4\x4d\xcc\x26\xb1\x91\xfd\x2f\x9b\x0f\x54\x46\x1b\xf5\x32\x6d\xbc\x27\x9d\x18\x2d\xdc\x6f\x89\x80\x07\xfe\xd2\xd3\x2e\x37\x34\x4d\xb8\xfc\x25\x20\x97\xbb\x8e\xb3\xcb\x25\xc2\xcc\xee\xc8\xfc\xf5\x4e\xcc\x66\xdf\x31\xcc\x3f\xc1\x8b\xb6\xb4\x7a\x3b\x30\xa9\xa6\x74\x6c\x84\xff\x39\x22\x09\xad\x74\xf1\x21\x82\x97\x9a\x24\xd4\x76\x51\x80\x2b\x44\x66\xb3\x8e\x45\x6b\x1c\xee\x62\x10\x43\x5e\x63\x52\xa9\xb1\x40\xd4\x0f\x89\x30\xaf\xd1\x5f\xd1\x4a\xd1\x2d\x73\x3f\xf2\x16\x82\x68\xea\x76\xe5\xb5\x1b\x72\x66\x45\x1e\xc9\xaf\x85\x73\x9e\xc7\x78\xd4\xb2\x21\xe4\xdc\xf5\xa3\x80\xcf\x36\x05\x92\xb5\xb3\x83\x83\xe7\x8c\x48\xf7\x8b\x95\x16\xee\x9b\xce\xd6\x3a\x72\xf7\x83\x38\x4b\xea\x71\xd7\x7a\x02\x20\xb1\x67\xe0\x8b\x47\xd0\xbe\x7d\x04\xf7\x31\x11\x98\xab\xdf\x71\xa8\xb7\x6f\x06\xbd\x80\x2d\xcd\x02\x8a\x32\xce\x6d\x88\x69\xfd\xd0\xe8\xb6\xa3\x92\x54\x8f\xca\x41\x6c\x8f\x0a\xca\x94\x1b\xfe\xfd\x46\x18\x89\xc9\xb8\x3c\x26\xdf\x5a\x27\x19\xbd\x25\x2d\x65\x87\x59\x7a\xa6\x9c\x9b\x3e\x5b\x86\x52\x8b\xa9\x45\xc7\x1a\x7a\x24\x6d\xbc\xec\xc6\x00\x14\x9e\xb7\xe5\xa8\x59\x55\x3e\xa4\x14\x4e\x9b\xa6\xb4\x1d\x74\x16\x5a\x8d\x3e\xd7\xa2\x13\xd0\x99\x83\xc0\x70\x80\xe5\x0e\x75\xf9\x90\x52\xd8\x6f\x9d\x8f\x0f\x9a\xdc\x93\xd3\x38\x73\x34\x99\x51\xbf\x6f\xe1\x43\xfd\xbd\x22\x31\xfb\xa1\xfd\x42\x57\x89\xb1\xaa\xe2\xbe\x2e\xaa\x7c\x5e\x0f\x8b\x57\x99\x18\x30\xb0\x81\xbf\x34\xbb\x0c\x32\xb4\xff\xaa\xfc\x83\xcd\xa6\x28\xd7\x79\xf3\x2a\x15\xaf\x44\x82\xc9\x97\xcb\xc3\x90\xb8\x98\x8a\xc2\xe5\xe7\xd5\x2f\xee\x66\xfd\x95\x3c\x5a\xb8\xbe\xbd\xe2\x54\x69\x6a\x24\x8f\x00\xff\x87\xcd\xb3\xdb\x29\xaa\x38\xbc\x55\x38\xdd\x6e\xf1\x98\x03\x8d\x10\x68\xcc\x22\xd7\x87\x90\xc5\xae\x5f\xdc\xed\xf1\x5d\x0e\xb7\xcc\xaf\xa6\x78\xbe\xd3\x78\x3f\x04\x1f\xe2\xfc\x21\xcc\x1f\xa6\x30\x10\x5b\x7b\x72\x34\x23\xfb\x31\xa8\x8d\x6d\xb8\xa5\xde\x3d\x79\x1f\x83\x34\x5c\x12\x7f\x63\x9a\xe7\x7c\xaa\x96\x56\xf9\x86\x9c\x89\x6c\x14\xd9\x1b\xc3\x75\x5e\xae\x38\x06\xef\xe3\x52\x6c\x3c\x6a\x67\x72\xba\x89\xae\x58\xa9\xdd\xb0\x79\x73\x24\x5f\xc6\x20\x7a\x46\xe6\x79\x16\x83\xd8\xc0\x0d\x6a\x4f\xe1\xc5\x72\xf7\x0b\x17\x2c\x0a\x4a\x1d\x58\x9d\xa0\x49\x9f\xc8\x2b\xad\xef\x13\x9b\xbc\xa8\xdb\x35\x94\xc5\xf2\x1f\xcc\x60\x18\xb3\xef\xf0\xa3\x51\x4a\xb8\x27\x5f\xe3\x32\xc1\xf7\xf3\xd6\xe9\xb0\x91\xdf\x12\x8f\x1b\x2a\xe8\x8d\xc2\xcf\x7e\xcd\xc9\x9b\x31\x58\x10\xcc\xe6\x5d\x4b\xac\x71\xec\x79\x4c\x42\xbc\x50\xfc\x2d\xb6\x3e\xd9\x81\x11\x03\x7f\xc4\x36\xff\x1c\x67\x36\x22\x32\x60\x04\xc3\x0d\x8c\x54\xf8\x68\x73\xde\xa7\x1b\x03\x88\x18\xde\x24\x9e\x91\xa3\x4c\x96\x6d\x83\xc7\x11\x9e\x4d\x1d\x12\xb3\xfb\x80\x44\xd4\x6c\xc0\x47\x1c\x7c\x16\x3f\x12\x30\x65\xb9\xa5\x0e\x57\xeb\x22\x26\x08\xec\x52\x83\x0a\xe0\x07\x27\xee\x8e\x69\x19\x51\x40\x2f\xf8\x2b\x8d\x89\xbc\x0b\x1a\x1c\x8f\x06\x8f\xb6\x7e\x27\x61\xcf\xef\x91\x78\x63\x4a\x1f\xc5\xd4\xeb\xa7\x14\x8e\x9b\x36\x49\x35\x70\xc4\xd0\x05\x59\xc6\xa6\x70\xd7\x9f\xcf\x17\x69\xc1\x6d\x25\x89\x7a\x35\xed\x58\x71\x92\xf2\xd4\x15\x91\x91\x56\x1e\x24\x0b\x40\xb1\x18\x34\x3b\x21\xda\x30\x13\x6e\x58\x7e\xfe\x51\x59\xb4\x1e\xe8\x8a\xd7\xdd\x0a\x35\xa6\xba\xc6\xfc\xf8\x5f\x1a\x37\xc5\x25\x91\xd4\xfd\x1a\x47\x92\x60\x6e\xd9\xb7\x6d\xbb\xc2\xc9\xb3\x53\x98\x7f\x95\x11\x4c\xf6\xf3\xe8\x95\x2f\x31\xb9\x27\xc7\xb1\x5d\x06\xbb\xb8\x19\xf5\x7c\xd3\x42\x3d\xeb\xc0\x68\xa1\x1d\x36\x6c\xab\x7c\x38\x3d\x77\x73\xe7\xf7\x8f\x82\xcc\xc8\xdb\xd8\xaa\x9f\xbf\x93\xc1\x06\x0a\xe7\x27\xbf\x88\x73\x3f\x47\x79\xe0\xdd\x93\x37\x96\xca\xcf\xc8\x61\x5c\x68\xb3\x2f\x62\xf6\x0c\xbe\xff\xfb\x82\xdb\x5d\x55\xb0\xd2\x15\xc1\x4d\x83\x7f\x64\x45\xb4\x23\x14\xd1\x8c\x5c\x70\x6e\x36\xfe\x2b\x23\x07\xaf\x92\xd5\x1a\x40\x26\x05\xc4\xba\x9c\x76\xb4\x00\x6f\x49\x14\x7b\xbd\x28\xac\x6d\x2f\xd6\x98\xe1\x55\x0d\xfe\x1a\x53\x70\x97\xf5\x76\x16\xeb\x7d\x5e\x84\xb4\x24\x18\x4e\x16\x6b\xec\x56\x6b\x70\x96\x0f\xc8\x0c\x97\xe3\x47\xa2\x5e\x79\xdf\x05\xe1\x2e\xd7\x74\xd4\xf1\xac\x1e\xbd\xe6\x80\x7d\xc1\x5d\xfe\xca\x43\x9a\x3a\xe8\xc3\x07\x23\x28\xbd\x88\xe1\x24\xb6\xd5\xa1\x24\xc1\x8d\x2a\xd1\xb5\x99\x42\x6e\xe6\x27\x85\x17\x82\xc2\x7b\x6d\x74\xee\x2d\x9b\xb9\xa6\x3a\xd6\x16\xf1\x34\x77\xe9\xbc\x8a\xd9\xad\x24\x83\x47\x7d\x0a\xaf\xdb\x76\xda\x83\xff\xd4\x93\x10\x5c\x5a\x47\xda\x87\x98\x29\x05\xef\x62\xd6\x86\x5c\x6e\x8d\x93\x3d\xe7\x51\x6e\x1d\x9c\x3a\x50\xf5\x10\xbe\x33\x4c\xe0\x45\xd0\x3c\xb4\xd7\x66\x68\x44\x31\x89\x72\x4f\x79\x91\xe7\xd1\xd9\xc6\xd9\x3f\xff\x9c\x3f\xa4\x84\xfe\xde\x1b\xb9\xf0\xcf\x3f\xff\xfc\xf3\x9f\x9d\xf9\xff\xfa\xe7\x9f\xe9\xf9\xa3\x4b\x87\x1a\x22\xf7\x2a\x06\xdd\x3a\x6b\xd2\xf5\xb7\x53\xf8\xca\x89\xf3\xcf\x3f\x0e\xb5\x96\xfd\x3c\x74\x23\xb5\x7e\x51\xf4\xea\xc6\x0d\xd6\xfb\xd2\x26\x48\x29\x7c\xce\x05\xe6\x8f\xff\xee\x71\x3a\xc4\xaf\x1d\x6a\x97\xbb\x9d\x91\xdd\x2d\x1f\xcc\x9e\xc2\x9c\xc8\x62\x85\xc2\xa1\x3d\xc7\x01\xdc\x2e\x77\x46\xd3\x7c\xea\x39\xcf\x26\x13\xc7\xac\x89\xe3\xa4\x90\x6f\x22\xe1\xf2\x0f\x66\xf9\x3b\x78\x45\x69\x60\xbf\xd2\x95\x0b\xd2\x9f\x33\x41\x3a\x5f\x92\x42\x90\xfe\xe5\xf3\x50\x9e\x65\x3e\x5c\xc2\x2f\xf9\x39\x7a\xf9\x1e\x5f\xb1\x3e\x4f\x53\x73\x02\x12\x4a\xb3\xb1\x50\xda\x7a\xdc\x4c\xb7\x03\xf4\x4f\xae\x38\xfb\x9d\xe5\x33\x6d\x85\xc4\x86\x31\x7c\xc6\x7c\x19\x19\x48\x54\x4a\x44\x45\x29\x41\xf5\x87\x07\x1e\x92\x5b\x9e\xe9\x36\xe8\x3b\xa5\xcb\x09\xa7\x2a\x4a\xe0\x1f\x2b\x04\xb3\xc4\x86\xd3\xa2\x60\xf6\xa9\xcd\x0e\x87\xf8\xe2\x95\x54\xfe\x1c\x22\xf3\x4f\x82\x37\xd3\xf9\x29\x84\x2c\xe9\x39\xff\xeb\x51\x66\x16\x1f\xb6\x44\x35\xf9\x55\x8d\xf1\x30\x1b\xc8\x37\xcf\x07\xfe\xdc\x33\xbb\xd1\xc7\xbd\x18\xc0\x83\xbf\xe5\x11\x6e\xa5\x89\x28\x80\xd6\x5c\x27\xae\x3f\x48\xc1\xc7\xcb\x79\x28\x55\xfc\x11\x83\x8f\x9f\xbb\x48\x29\x7e\x39\x7c\x61\xbf\x4c\xd9\x8c\xcc\xcc\xb1\x0c\x28\xdc\xb2\x19\x79\x1d\xe1\xf7\x2d\x17\x11\x8a\x70\xcf\x7e\xf3\xde\x44\xc0\x13\xef\xd6\x20\x37\xad\x58\x53\x3e\x64\xdb\xe6\x24\x82\xb7\x91\x59\x9e\x2f\x11\xea\x43\x48\x28\xb3\xb2\x57\xb6\xec\x9d\xd1\x4c\x51\x3d\x5c\xda\xd8\xca\xae\xab\xb2\xeb\x1a\xda\x75\xd5\xf0\xc0\x45\x91\x52\xc9\xae\xe7\xe2\x76\x6b\x6d\x38\x6e\x6a\xf8\xc4\x5b\x18\xdc\x13\x9b\x4c\x73\x71\x1b\x4e\xd8\x01\xb9\x8c\x21\xb4\xa9\x3a\x8d\x98\x36\x66\x93\x92\x51\xe6\xad\x13\xef\x96\x4d\x0c\x0b\x7b\xe2\xd9\x03\x9d\x0f\xf8\x85\x1d\xf0\xb8\xee\xc1\xeb\xb0\x03\xf2\xbd\x84\x1a\xd0\xe1\x98\x75\x96\xa1\x3e\xf7\xa6\xac\x83\x58\x95\x00\xbf\x2f\x00\xb4\x7a\xd8\x15\x3b\x20\x1f\x4b\x80\x86\xa9\xb0\xab\x65\x80\xa7\xde\xd5\x02\xb8\x57\x25\xb8\xa5\x03\x92\xaf\x7a\x31\x31\x18\xa4\xd1\x24\xc5\x55\xbe\x58\xf6\x77\x2b\x8b\xea\x78\xbb\xd5\x68\x8f\xbf\x0c\x7b\xca\x82\x61\x2c\xcb\xc9\x1d\x60\x87\xe3\x2c\x08\x06\x64\xc8\x2e\x24\xa8\xb0\x49\x70\xbc\x90\x64\x55\xdc\xe8\x3d\xf9\x21\x73\x0f\x9b\x3d\xbe\x0f\x56\x45\x01\x8d\x40\x45\x23\x50\x15\x12\xeb\x8b\x43\x0b\x09\x68\xbc\xaa\xfb\xd4\xba\xcc\x30\xa2\x2b\x7b\x17\x1c\x64\xee\xb8\xe9\x89\xb8\x14\x77\x0e\x48\xac\x79\x91\x25\x93\x4e\xc2\x36\x8a\x12\x06\x44\x3e\x42\x74\x78\x23\x02\x32\x85\x20\xfc\x37\xbe\xba\xd4\x93\x8b\xa9\x5f\x6c\x32\x01\xe1\xf2\x2d\x4c\x51\x57\xd6\x14\x36\xf5\x16\x28\xa6\x40\xdb\x10\xe5\x78\x19\xcf\x32\xab\x57\x31\x91\x41\x88\x13\x39\x23\x49\x08\x3c\x34\xd2\xf5\xae\xd8\xce\x3e\x7d\x16\x86\x8d\xd7\x7d\x93\x10\x24\x0c\xb6\xb7\xfb\xb4\xf7\x78\xf0\x74\x7b\xf7\x09\x68\x46\xd4\x5e\x7f\xa4\x36\x06\xdb\xbb\xfd\xa7\xbb\x9e\xa2\x8f\xf0\xe9\xf1\xbc\x6f\xb4\x4f\xfb\xfa\xf1\xef\x1a\x12\x46\xc4\x06\x11\x58\x8a\xd7\xaf\xc4\xa3\xad\xdd\x9d\x4d\x7b\x29\xcb\xbe\x7e\xba\x3b\xef\x53\x6a\x5e\xcf\xfb\xc0\x99\xd8\x20\x5b\xbb\x3b\xbf\x27\x3d\x92\x64\x77\xb7\x92\xec\xee\x16\xaa\x76\x3b\xbf\xf3\xde\x26\x7d\x34\xd8\xd9\x9a\xf7\x21\x62\x41\x8f\x04\x7b\x83\xfe\x68\xcb\xdb\x78\x9a\x93\xb8\x07\xfe\xdd\xe3\x1b\x84\x0c\x76\xb6\x7e\x0f\x4c\xe5\x1d\xd3\xf3\x00\xf8\xa1\x17\x81\x1f\x78\x49\x6f\xbb\xdf\xff\x5d\xf7\xc8\xe6\x5e\x34\xea\x7b\x03\x9a\xa6\xe0\xb7\xaf\x71\x48\x66\x24\x0e\xad\x58\xef\xf2\xef\x29\x85\x69\x6b\x65\xbc\x9c\xb6\xb9\x6d\x67\xb7\x68\x06\xbb\x7d\x1b\x0d\xb3\xba\xdd\x40\x6c\xd9\x15\xc1\xe0\xf7\xd5\x75\x77\xfb\x25\x78\x53\x7d\xbc\x5c\x3d\xe3\x4e\x0b\xf8\x1f\x2e\xde\x22\xeb\x2f\x48\x40\x83\x05\x59\x7c\x73\xf1\xfe\xd7\x02\x91\xdf\x5e\xa0\xdd\x3b\x0b\x77\xb8\x76\x17\x48\xf4\xe3\x85\x9b\x59\x4f\x16\x2f\x61\x3d\x5d\xbc\x6f\x35\xe8\x2f\x52\xb3\xc1\x00\x43\xf2\x7f\x61\x8a\x8a\x4d\x3e\x10\x5b\xd6\xca\xff\x8b\x0b\xed\x1b\xce\x7a\xdd\x56\x79\x31\xa4\xfe\x26\x64\x33\x72\x1d\x42\x1f\x3a\x14\x2e\x9b\x8e\x7c\x3e\xdb\x7b\x72\x74\x4f\x2e\x43\x90\xff\xfa\xd7\x00\x4e\x88\x32\xdb\x63\xd0\x95\x23\xa3\x84\x2b\xea\x69\xea\x61\x78\x4f\x2b\x96\xb6\x31\x28\xfc\x78\x0b\x85\xfb\x15\x7d\x9d\x90\x19\x99\x85\x20\x37\x3e\xe2\xc7\x88\x6d\x9e\x7e\x7b\xd0\x0f\x56\xc0\xbf\x37\xf0\x9d\xbe\x03\x87\x3c\xdb\x8b\x77\x8d\xc4\x6d\x46\x0e\x42\x30\x5b\xfd\x2a\x84\x9b\xd0\xba\x87\x37\x9c\x1e\xbe\xde\x6c\xca\x3c\xba\x94\xed\x71\xb0\xe0\xc0\xdd\x5c\xd8\x8a\x5b\x0b\x5b\x71\x7b\x61\x2b\xee\x2c\x6c\xc5\xdd\x85\xad\xf8\x78\x61\x2b\x3e\x59\xd8\x8a\x4f\x17\xb6\xe2\xa0\xbf\xb8\x17\x07\x4b\x09\x28\x07\x9b\x69\x4a\x66\x64\x9c\x8f\xb9\x36\xe8\x19\xf1\xcb\xb9\x38\xad\xbc\x9e\x96\xaf\xbd\xca\xeb\x49\xf3\xeb\x4e\xf9\xda\xcd\x5e\x6f\x19\x79\xa8\x7c\xfd\xb7\x93\xc2\xb7\x90\xdd\x85\xf0\xac\x75\x25\x73\x96\x4a\x34\x93\xad\xf7\x31\xf0\x5b\xce\xe4\xab\x24\x78\x59\x9d\x82\x32\xea\xd6\xd9\xb9\x39\x02\x45\xac\xd9\xe9\x8a\x3d\x66\xc3\x0f\xdf\xbd\x7d\x9f\xc5\x1f\x66\x1e\xce\xfd\x15\x07\xa7\x76\xc5\xe4\x7d\x0b\xcf\x32\xa2\xf8\x62\x34\x4a\x91\xb9\x10\x8d\x1e\x98\xd0\x22\x67\xf0\xd1\x18\x59\x39\x11\x4c\x51\xd7\x3f\xb5\xec\x3c\x50\x82\x67\x91\xb8\x1a\xcd\xcd\x3f\xb2\xf7\xf1\xf5\xb5\x90\x3a\x7f\x7b\x6b\xdf\x96\xa1\xb9\x3a\x24\xdf\x4c\x49\x30\xcd\x82\x70\x84\x1c\xd7\x0a\xfc\x97\x59\x41\xe6\x43\x44\x65\xfb\x59\x08\x22\xb4\x9e\x2e\x23\x36\xc0\x8c\xec\x87\xe0\xf0\x9b\x9b\x49\x64\xbf\xe3\xfd\x08\xa3\xcf\x01\x23\xc7\xfb\x36\x9a\xaf\x54\xe0\xef\xc9\x69\x88\x99\x12\xfe\x8a\x6d\xf4\x5b\xfb\x9c\x3f\xf8\x17\x66\xfe\x9e\x56\xbe\xa4\x75\x14\x1a\xfd\x78\x2b\x85\x8b\x90\x5d\x4a\xf8\x1a\xb2\x03\x72\x11\xc2\xcb\x30\x33\x02\x14\x82\xcd\x51\x98\x47\x1d\x5b\x91\xe8\xb0\x88\x42\xce\xe4\x21\x8c\x0f\xfd\x11\xb2\xbf\x22\xf2\x5d\x53\x78\x6e\xe8\xda\x8f\x10\x96\x82\xd0\xeb\x47\xda\xe1\x81\x8e\x6e\x85\x93\x1f\x92\xe3\x20\xbf\x8f\xec\xdc\x08\x39\x8e\xe4\x65\xb5\x68\x90\x15\x89\xbb\x9b\x48\x89\x71\xb5\x68\x73\x49\x70\x7d\x1e\x10\xe7\xbd\x5d\x78\xd7\x46\x59\xe3\x3f\x62\xed\x3a\x99\xe2\xbd\xc6\x58\x8a\xb5\x38\x5c\xfb\xcd\xa2\xf0\x1b\xac\xfd\x96\x75\xf9\xdb\x5a\xac\xd6\x7e\xcb\x3a\xf9\x0d\x2f\xb0\xcf\xf8\xf4\x37\x8c\x86\xff\xcd\x75\xec\xd5\xda\x2c\x28\x5b\xe7\x43\x3f\x0e\x9a\x6c\x11\x7c\x3b\x33\x44\x1c\x86\x2c\x68\xc9\x70\x01\x51\xb9\x40\xb7\x9e\x06\xff\x87\xa7\xc0\x7f\xe9\x25\xe0\x9f\x9a\xf5\xda\xf1\x02\x08\xa6\x9e\x00\xbe\x63\xc4\x10\xee\xe1\x1d\xa5\xe3\x62\x82\x73\x4c\x92\xa9\x03\xcf\x71\x99\x8a\xd7\xe5\x36\x7b\x17\x90\xaf\x21\xad\x15\x26\x37\x63\xb3\xcb\xcb\x98\xf2\xa2\x24\xdf\xb6\x0b\xaf\x17\x63\xd0\x9b\x96\xb7\x5c\x91\x3c\xc4\x08\x85\xed\x22\xc0\xbe\x38\x42\x79\x70\x7b\x01\xbd\x72\xe8\x0e\xeb\xfd\x9a\x33\x6a\x5e\x1d\x07\xe4\x30\xa4\xf9\xff\xc1\x97\x70\x41\x73\x38\x37\xb3\x42\xe1\x6d\xd3\x09\xc8\x03\x34\x9a\xe8\x82\x03\xaa\x12\xa2\x86\x4a\x91\x86\xdc\x36\x26\xe0\x4b\x68\x8d\x1b\x6f\x9a\x98\x99\x21\x4b\x4f\x33\x9d\xe7\x24\x64\x0f\x5f\x50\x39\x0e\xf0\xef\x18\xff\x0a\x0c\xd2\x9e\x61\x4c\xc3\x8b\x16\x7e\xf8\x39\x31\xfa\xc9\xc5\xc8\x61\xff\xe5\x78\x0e\xb3\xf8\xb9\xfe\x53\xfc\x06\x23\xaa\x12\xdf\xdb\x5b\x3a\x90\x85\x5a\xbd\x08\xed\x64\xbf\x0a\xb3\xe0\xef\xd7\x2d\x18\xe7\x31\x71\x1f\x56\xd0\x0a\x9b\xa7\xa6\xf6\x39\xb5\x77\x61\x16\x58\xff\xb9\x05\x6e\x3e\x11\x1f\x5b\xca\x9f\x64\xe5\x7f\xb4\xb2\x9e\x13\x4e\x50\xea\xea\x3d\xb7\x99\x1e\x28\x7c\x0a\xb3\x6f\xd7\xcd\x1c\xd8\xed\x6f\x3f\x11\x3b\x48\x40\xc7\x0e\x60\x72\x04\xfc\x71\xe5\xc0\xd6\x6e\xf6\x7c\xed\x58\xb5\xc4\x10\x66\x07\x85\xb7\x73\x0a\x7f\x36\x2b\x59\xae\x56\xd1\x35\xa1\x29\xfc\xdd\x5c\xbe\xd7\xcf\xac\x47\x7f\x86\xcd\x4a\x66\xae\x25\x71\x0c\xf8\xb4\xa9\xc9\x38\xa6\x26\xab\xe8\xdc\xfc\x91\x98\xf7\x47\x49\x8f\x1c\x72\xfb\x4c\x7b\x44\xf7\x9c\x35\x87\x52\x2f\x01\x94\x38\x85\x35\xca\x18\xa4\x1d\xb0\x43\x87\x4f\x21\xcd\x92\x9c\x20\xbb\x96\x7e\xb6\xa8\xca\x6f\x9a\xdc\x8f\x9e\xf4\x0d\x55\x37\xd3\xab\x7d\x66\x28\x89\xf2\x89\xe3\x50\x24\x27\xf6\xe9\xbe\x78\xf5\xb2\x78\x3a\xf5\x1c\xc7\x90\x98\x8e\x21\x31\xf6\x65\x0a\xc2\x00\xb8\xf0\xd6\x07\xc8\x2c\x6c\xcd\xe0\xa0\x28\x4e\xfc\xc6\x18\x43\xdf\xe6\x45\xe1\x6f\x6c\xf4\xeb\x41\x79\xa0\x7e\x34\x9a\xa7\xee\xc9\x4b\x2b\x90\x0a\x9a\x56\x63\xdb\x73\x9b\xec\xff\x9f\xbb\x77\x61\x8e\x1a\x67\xfe\x85\xbf\xca\xe0\x27\xef\xf3\x48\x45\x8f\x99\x09\x64\x77\x71\x1e\x57\x2a\x84\x04\x02\xb9\x40\x08\xd7\x7d\x39\x94\xe4\x4b\xc6\xc4\x63\x0f\xb6\xec\xc9\x04\xfc\x39\xce\x07\x3a\x5f\xec\x94\x5a\xf2\x6d\x6c\x0f\x61\xff\xfb\xbf\xd4\xa9\xdd\x0a\x63\x5b\x96\x64\xa9\xd5\xdd\x6a\x75\xff\x7a\x5d\xe9\x3b\x11\xe4\xde\x74\xdd\xec\x2a\x6f\x4e\x3a\xbc\x1f\xf1\xae\xe4\xd8\xb1\xfe\xae\x56\x9d\x43\x91\x68\xf2\x2f\xfa\x43\x71\x97\xaf\x3f\x15\x41\xe5\x1d\x3e\xac\xc1\x9c\x13\xc1\xe1\xbb\x1a\xde\x48\x8f\x6e\xc9\xf4\x3e\xf9\x04\x11\x20\x68\x39\xd8\xaf\xe5\x1e\xe1\x85\x0f\xf2\xae\x4a\x78\xc0\x77\xac\x55\x4c\x12\xcc\x6e\xea\x71\xc4\x3f\x3b\xd6\xe7\x08\x19\x87\x5b\x41\x18\x47\xcb\xb7\x9e\x98\xd7\xbe\x8a\x8c\x28\x28\x04\x7c\x68\xf9\xe0\xda\x19\x33\x5f\x05\xc8\xc7\xdc\xc6\x31\xbe\x37\x95\x5d\x92\x93\xe8\x2b\xca\x90\x53\x7e\x8b\x7f\x8f\xac\x0b\x46\x26\x0d\x3a\x58\x90\x3f\x63\xfe\x19\x1b\x55\x4f\xd8\x8e\x25\xa5\xd8\x76\x21\x25\x0f\xde\x2a\x80\xf7\x91\xe0\xe8\x9b\x27\xd7\x49\x44\xe9\x06\x0c\x81\xdb\x0c\x9d\xba\xd3\xbe\x61\xed\xa6\xce\xd0\x71\x44\xbb\xb5\xaf\x45\xa9\x4b\x2b\x1c\x5c\xd9\x90\xd0\x81\x46\x4b\x12\x81\xa7\x90\xc8\xe4\x86\x79\x80\x44\x1f\x2b\xe8\x9e\x06\x6d\xa6\x1c\x6e\x04\xac\xe4\xbf\x47\xda\x78\x03\x9c\x2b\xf8\x34\x40\x98\x6f\xe7\x10\x0f\x1b\xc2\xee\xa8\xab\xe5\x7f\x4c\x30\xa4\x0e\x5e\xe2\xae\x47\xf9\xda\x31\x05\xe0\xc7\xeb\x6f\x11\x3a\x00\x54\x83\xd2\xd5\xce\xd6\x5f\x24\xc7\xc3\x93\x05\x2a\x77\x9c\x9e\x1e\xbf\x03\x16\xfd\x0b\x87\x4e\x47\x60\x2e\x58\x2a\xd4\x00\xa2\x63\xa2\xcb\x07\xfd\x49\x37\x8f\x23\x9a\xa7\x2b\x10\x81\x56\x19\x51\x96\x09\xd0\xe8\x5e\x79\x85\x34\xcb\x78\x65\x99\x18\x7d\x1a\xbb\x80\x7a\x5f\x33\x92\x95\x65\xfc\xa6\x17\xa6\xc6\xb2\x94\x1f\xc7\xf4\x9c\xdd\x90\xa8\xc4\x3d\x06\x56\xc2\xfe\x75\x67\x8e\xc9\x99\xbb\x04\x9c\xc0\x5c\x05\xfd\xee\x28\x86\x7b\x8b\x1e\xf6\x4e\xaa\xb2\xe7\x1d\x95\x4d\x7d\xc9\x48\x4e\x5c\x0e\x1b\x03\xb4\xce\x89\x2f\x97\x6f\x2e\x65\xdc\xad\x54\xbb\xb4\xc6\xc5\xe4\x32\x48\x50\xe3\xc2\xd5\x56\x11\x03\xfa\x6a\xe7\x5c\x12\x05\x06\xd5\xc8\x27\x1e\x3e\x79\xc9\x48\x86\x3f\x96\x24\x44\x78\xdd\x43\x70\x4a\xb2\x99\x21\xdf\xde\x29\x60\xce\x6d\x3f\x82\x05\xb7\x79\x04\x57\x43\x2b\x18\xa1\xfc\x4d\xb6\xb8\x4f\xa2\x31\x26\x35\x73\xac\x04\x33\x4a\x24\x2a\x49\x27\xb0\x8f\xf2\xf9\x47\x8d\xfb\x26\x37\xfc\xdc\x8e\x23\x58\x71\xdb\x89\xe0\xb0\x5b\x6d\x20\x25\xd7\x8a\xc3\x74\x32\x45\xfb\xc4\x8f\x1f\x78\xf9\xdb\x63\x65\xad\x28\x25\x18\xe6\xa0\xc0\x27\x8f\x1e\x22\x74\xbf\x2e\xf7\x68\x07\xaf\xf6\xc4\xfd\xa9\x25\x70\x63\xb5\xe4\x0a\xab\x5f\x8f\xe2\x01\x91\x63\xba\x37\xce\xac\xac\x06\xb8\xa5\x70\x33\xc8\xa2\x54\xb5\xbf\x61\xf3\x7b\x4b\x72\xc8\x01\xeb\x44\x9f\x1a\xc9\xee\x2c\xbc\xa7\x7d\x60\xae\xf9\xc6\xac\x2a\x1e\x3a\x2b\xe8\xbc\xef\x7d\x69\x77\xee\x4d\x14\xb2\x59\xa6\x50\x25\x35\x71\x37\x18\xc9\x01\x11\x50\x66\xde\x52\xf9\x3c\x04\xfd\x77\xf5\x52\xd4\xc8\x7d\x14\x10\x54\x4a\xaf\x38\x30\x84\x0e\xa7\xb0\xcf\x37\xa5\xa1\x69\xa7\x7e\x6d\xb8\x38\x5f\x0e\xaf\xdc\x12\x8e\x9c\xa1\xdb\xc9\x0d\x07\x07\x97\x05\x66\xaf\x6f\x22\x55\xa8\x2f\x3b\x24\xfb\x5c\x3e\xff\x28\xff\x2c\xc6\x24\xb8\x8f\xa9\x39\x23\x60\xa6\x43\xcb\x74\x23\x26\x87\xa0\x3f\xf3\x14\x83\xa4\x2c\xe5\x34\xca\xdc\x90\x6b\x39\xfc\x0a\xf7\x57\xf6\xaa\xc9\x07\xbe\xf7\x0d\xae\x42\x7c\xa9\x78\x02\xf8\xf6\x19\x23\xe8\x02\x8f\xad\xab\x95\xdd\xe4\x02\x3e\x62\x8f\xae\xd7\x50\x8d\x74\x4c\x7c\xc9\x0b\x71\xac\x03\xad\x18\x1d\xf0\xf5\x7c\xd8\x0d\x54\x18\xfb\x3b\x9b\x5b\x92\xc7\x51\x60\xa9\x5c\x23\xb9\x64\x2e\x67\x82\x02\x3b\x28\xef\x1f\x62\x08\xa5\x43\x81\x7f\xb4\x12\x60\x2f\xd5\xfd\x62\x1d\x1c\x4d\x51\xe7\x1f\x55\xfa\xae\x86\xe8\xc0\x64\x2d\xc9\xfd\xe9\x6e\x93\x90\xa7\xdb\x13\x95\x78\x8b\xee\xe1\xc0\x79\x26\xff\x08\x9e\xc9\x0e\xf0\x70\x7b\xc1\x75\x6a\x37\x88\xf0\xf3\x38\x4c\xa7\xd3\xde\xf2\x2f\x41\xca\xa0\x39\x87\x3f\xd6\xdf\x78\xfc\x47\xef\x0b\xf3\xf2\x85\xed\xc6\x0b\x39\xb9\xac\x4b\xa4\xf2\xcf\xa1\xfc\x93\xc3\x31\x49\x60\x22\x8b\x94\x6b\x74\xb0\x24\xd6\x39\x9d\x54\x03\x80\x20\x27\x28\xb7\x0a\x0a\x33\x0e\x33\x4e\xe1\x0d\xb7\x5b\x48\x47\xb7\x4c\x4e\xd0\x5f\x49\x0b\xf6\x45\x19\x0a\xa5\xae\x4b\x29\x1c\xf1\x6e\x9a\x19\xfd\x27\xc8\x60\xd2\x17\x9c\xd9\x40\x73\x3a\xef\xcb\xf3\x39\x5a\x20\x1a\x1a\xa6\xf4\x92\x35\xbd\xe1\x70\x94\x51\xaa\xf3\x90\x26\x65\xf6\xa6\xa3\x4c\xe7\x72\x39\xe1\x55\x36\x8f\x23\xf9\xa5\x8c\xd4\x80\x47\x6e\x96\xa0\x39\xa6\x42\x3c\xa2\x14\xbe\x70\x1d\x9e\xf4\x75\x90\xe1\xe1\xf1\xd9\x3b\x8b\x08\x3b\xd2\x82\x44\x6a\x2e\x3a\xb2\x48\x98\xac\xb0\xbe\x70\x5a\xd4\x46\xb3\xdb\x5f\x50\x59\x97\xe4\x2b\x07\x2e\x67\xaa\xd4\x5b\x8b\x02\x9e\x0c\xe8\x3e\x97\x4a\x74\xde\x2a\xf5\x3c\x55\x38\x75\x47\x08\x54\xb7\x52\x02\x74\x67\xb7\xb6\x43\x34\xaa\xce\x71\x13\x51\xde\x10\x52\xd5\xc5\x8b\x13\x0e\x0c\xf5\x5b\xbc\x0a\x4b\x69\x98\xa1\x3a\x99\x28\x4f\xee\x77\x02\x6e\x39\x38\xa8\x50\x62\xb1\x97\x0c\xd3\x88\xc2\x31\xb7\xc9\x4d\x60\x0b\x1f\xb2\x84\x1c\x06\xb6\xb1\xf0\x92\x34\x48\xc5\x53\xa5\xc9\x1f\x24\x1e\x13\x71\x62\x50\x78\x1f\xfd\x79\x18\x7c\xb6\xbf\x7b\x16\x4b\x20\xb1\x6e\x02\x60\x96\x93\x14\xf0\x3a\x22\x87\x01\xa5\x70\xf6\xb3\x91\x2f\x37\x46\x72\xa2\x3f\xf2\x76\x00\xb0\xd7\x72\xac\xdf\x1f\xf4\x42\x46\x37\x47\xba\x27\x49\x06\x03\xb1\x50\xbf\x3e\x5f\x6b\x59\x6c\x8a\x39\x2a\x03\x0f\x2e\x30\x28\x01\xb4\xd2\x2f\x27\xbe\x71\x7e\xeb\xd9\x2f\x19\xc1\x7c\xc0\x14\x32\xf9\x5b\x98\xfc\x08\x07\x35\xe9\x82\x9c\xa0\xce\x1a\x70\x95\x18\x03\xd1\x84\x1b\xca\xe6\x4a\x12\x8c\x9a\xfa\x4f\x3e\x69\x66\xfc\x4b\xcc\xad\x3d\xf5\x1c\x55\x08\x52\x03\x07\xca\x1e\xca\xa9\x3d\xe3\x52\x28\x99\x2b\x3d\x69\x67\x52\xe4\x09\xd3\x49\xab\xce\x96\xae\x19\x72\x59\x7b\xaa\x9b\x4e\xaa\xe6\x1e\x3f\xe0\xbf\xab\xbb\x48\x8a\xba\xbb\xfc\xa8\xea\xee\x23\x8b\xe9\x3d\x7a\xa3\xab\x5a\x19\x3e\xe1\xb2\xbb\x81\x4d\x42\xd5\xc1\x17\x3e\x38\x52\x50\x63\xab\x38\xf6\xd6\x6b\x9f\x84\x8d\x0e\x35\xdb\x65\xed\x76\x83\x76\xbb\x3b\xd6\xfa\x2b\x6a\xd1\xd4\xef\xa8\x65\x53\x8d\x1e\xbe\xdd\x5c\x29\xad\x51\xff\xad\x4d\x4a\xb7\xaa\x4d\xc4\xc1\x31\xf9\x6d\x55\xec\xf7\x6e\x31\xbd\x70\x9b\xa5\xfe\x68\x97\xca\x5b\x95\xe5\x55\xb1\xc7\xdd\x62\x55\x65\x75\xa9\x69\x97\xc8\xd1\x93\x28\xb5\x75\x85\x3b\x54\x79\x22\xa7\xf7\xa7\x50\xc5\xe4\x94\x27\x26\x25\xac\x0d\x07\xdf\x5e\x91\x8f\x5c\xbf\xd6\xc3\xcc\x11\xd6\x19\xd9\xde\x19\x87\x58\x71\xbd\x82\x16\xaa\xca\xdd\xb5\x3e\xf8\x45\x8d\xbf\x78\xf7\x8a\x1b\xfc\xf4\x0e\x35\x6f\x57\x6e\x3b\x7c\xf7\x4e\x6d\x38\x87\xaa\xf3\x98\x93\xe3\xf0\x2e\x4d\x3c\xbc\x5b\xe7\x25\x87\x33\x9d\xc3\x8d\x15\x36\x41\x70\x52\xc8\xef\xde\x6b\xfe\xc5\xca\x37\xd5\x8c\xca\x5f\x58\x50\x38\xe5\x36\xb9\x0e\xec\x0b\x06\x67\x51\x4b\x1a\x47\xe4\x49\x44\xae\x03\xf2\x94\x09\xcf\x8c\xe2\x25\x51\x0e\x63\x14\x2e\xfa\x95\xe8\x9e\x50\x7b\xe5\xd1\xb6\x25\x77\x63\x6c\x55\x65\x52\xae\xac\x6c\xca\x4b\x65\x65\x3d\xd1\x05\xc0\x89\x2d\x3f\x68\x22\xdb\xa4\x19\x9f\x07\x42\xc3\x19\x25\x73\x18\xe9\xd3\x81\x51\x90\xe2\xf3\x95\x27\x46\x88\xa7\x69\x1a\xa5\x2f\x5b\x27\x94\x50\xb7\xe3\xc4\xd6\x69\xd0\xe3\xf3\xf4\xc1\x87\x43\x54\x5d\xdf\xf8\xca\xa6\x07\xc7\x5c\xea\xe0\xb7\xf2\xde\xa7\x00\x4e\x7d\x08\x03\x75\xa3\xe1\xf6\xf4\xd8\x52\xbc\xe8\xa1\x6d\xdb\x24\x50\x20\x00\x52\x43\x2e\xdd\x98\xc4\x7d\xe3\x1f\x0f\xca\x33\xac\x07\xc6\xfd\x40\x6e\x9f\x17\x71\xb7\x4f\xb2\x4b\x4e\xbf\x4b\xd4\x27\x6d\x5a\x5a\x92\xb7\x7e\x15\x71\x8e\x9d\x3d\xe5\x74\x9d\x73\x1c\x93\xef\x6c\xa6\xbd\xbc\x9e\xf9\xc0\x56\xd6\x8a\x38\xbc\x72\xa3\xc1\x9c\xb2\x7c\x62\x61\xe7\x9c\xd8\x7a\xe6\x17\x4d\x67\x5d\xdc\x64\xed\x36\x5a\x5f\x91\x73\x39\x1c\xf8\x65\x3a\x06\x0a\xc7\xa9\xe3\x84\xf5\x10\xa3\xaa\x98\xb9\xb5\x57\xcf\x27\xf1\x6d\xe4\xde\x26\x53\x91\x1c\x97\x98\xa6\x85\xdf\x62\x9e\x16\x27\xc5\x44\x2d\xfc\x08\x5c\xf9\xcf\x0e\x68\xbb\xa7\x5f\x2a\x2d\x09\x27\x69\xd7\x34\xb7\x24\x01\xd7\x59\x59\x1a\xf6\xb9\x90\xa2\xe2\xc2\x2b\xc5\x85\x71\x70\x1b\xe6\xb7\x5c\x9b\xdf\x70\x30\xcf\x84\x9c\xc9\x43\x46\x5e\xe1\x89\x84\x25\xbf\xb3\xe1\x14\xaa\x78\x5a\x93\x58\xe3\x2e\xb1\x5e\x2b\x02\x65\x91\x02\x5e\x0a\xd2\x45\xc8\x56\x23\xe6\xfb\x0a\xc7\x61\x1f\x9d\x05\x37\x92\x29\x34\x08\x5e\x93\x2c\xb3\xe3\x3e\x1f\x42\x24\xd7\x9a\x50\x9f\x97\x84\x8a\xce\x79\xe7\xe4\xc2\x2f\xa3\x26\xbf\x61\x48\x30\x72\x68\xda\x1b\x77\xa7\xea\x8b\x36\xb8\x72\xcb\x12\xb3\x46\x89\x8e\x47\x99\x7c\x9c\x98\x6c\x56\xd3\xd7\x92\x9c\x2b\xfa\x52\x6b\xb7\x4b\x5c\xc8\x62\xfc\x32\x9d\x0e\xb8\x05\x85\xa7\x5c\x9f\x5d\x7e\xe3\xf6\x3a\x9e\x92\x76\x1c\x7b\x36\xa8\x1b\xaa\xe3\xe7\xa7\x87\x27\x87\x97\x87\x6d\x00\x9c\xe7\x7d\xb6\xc9\x9f\x1c\x1f\x99\xfc\x72\xe0\x04\xe9\x99\x54\x78\xbe\x71\x75\x82\xf4\x96\x77\x4f\xac\x5e\x39\xe4\xcc\xa7\x14\x5e\xfd\x6a\xb3\x3d\xe8\x0a\x9d\xa3\xab\xb7\xba\xe1\x0f\xdd\x71\xe8\xe4\x2e\xa8\x26\x99\x07\x65\x60\x6a\x3b\xdf\xc0\xe8\x99\xbf\x26\xee\x4f\x83\xf5\xb9\xf5\x03\x85\x53\x54\x50\x78\xd7\x7b\x4e\x51\x03\x2e\xbc\x18\x78\x5e\x02\x2e\xbc\xef\x35\x32\xbf\x0d\xc8\xb0\x53\x32\xdb\x29\x36\xb8\x2c\xb3\x47\x05\xe2\x1a\x28\xdf\xf1\x97\x43\xe6\xdc\x25\x79\xcf\x11\xd5\xa7\xda\x0c\xad\x2c\x0c\x69\x01\xe6\x5b\x02\xd8\x1f\xca\xff\xe0\x13\xb7\x17\xe4\xcf\x09\x4c\x61\xfb\x33\x85\xd7\x43\x86\xaa\x8e\x20\xdb\x5e\x5f\x29\xbe\xb5\x24\x1f\x78\xbf\x83\xfd\x3b\x01\x2f\xf1\x70\xe1\x13\xa7\x05\x68\x40\x96\xfe\xa8\x07\xe5\x7e\xaa\x9d\x76\x13\x93\x65\x14\xd8\x04\x79\xb8\xaf\x16\xff\x8a\xbc\xe2\x90\x81\x80\x17\xbc\x9e\xd9\xca\xbc\xba\xce\x31\x26\x92\x17\x10\x47\x09\x23\x7e\x49\xbb\xde\xc2\xf8\x6c\x77\xe0\xe5\x46\xbb\x4a\x46\xae\xc8\x73\xd9\xba\x03\x47\x1e\x79\xca\x29\x05\xd6\x10\x70\x5e\x53\xc0\x19\x52\xb6\xd5\xc2\x51\x79\xca\x06\xca\xff\xb6\x5d\x50\x7b\xb9\xaa\x8f\x55\x81\x4a\x9d\x01\x09\x6a\x47\xd7\x77\x1c\xe2\x61\xff\xd6\x3f\xda\xfe\xad\x51\xba\xf9\xe8\x34\x19\x78\x5e\x02\xf5\x89\xb4\x67\x39\x0f\xef\x0e\x2b\x31\xa9\x3f\x29\xbd\x3b\xeb\xed\x10\xd4\x6c\xbd\xc4\x4e\x95\x74\xb5\x23\x18\x26\x2a\xf2\xa0\x31\xb5\x83\xa2\x58\x39\x7c\x6f\x5b\x3c\x20\x9e\x12\xc8\xb4\x1c\xd9\x28\x55\x92\x44\x68\x49\xa2\x9c\xb4\xef\x4d\x28\x54\x32\xc5\xab\x65\x8a\x55\xd7\x28\x99\xff\xb6\x85\xd5\xb5\xa5\x49\x85\xf1\xd9\xd3\xe1\x29\x12\x33\x8e\x55\xa6\x46\xaa\x9c\xd2\x4d\x6f\xd4\xd4\xd6\x56\xa6\x32\x95\x92\xd0\x4b\xb5\x21\x27\x4b\x07\x63\x6b\x3c\x2b\x01\xfe\x58\x25\xd8\x65\xa9\xbd\x22\xaf\x03\xc8\xd2\x01\xb7\x18\xe6\xba\x89\x97\xa6\xda\x3b\xc4\x49\x95\x63\xcd\xb0\x6b\x0e\x06\xee\x78\x92\xc1\xec\x68\x0c\xdd\xde\x6a\x4b\x47\x8f\xfa\xce\xc2\x2b\x1d\x3c\x18\xba\x1d\x05\xa9\x82\x3a\xfc\x09\xdc\x08\x8f\xac\x08\x78\x2c\x3f\x69\x61\x09\xe0\xaf\x2d\x0f\x9c\xaf\x56\x06\xce\x91\x72\x30\x51\xb5\xf3\x84\x45\xce\xac\xd9\x1e\xcf\x82\xd0\x7d\x5a\x3a\xbe\x34\x6f\xbe\x4d\xbd\xa4\x79\xf3\x2a\x7e\xe7\x25\x69\x10\x47\xcd\x9b\x89\x97\x07\xeb\xf7\xf2\x46\x31\x0a\x71\x6a\xdf\x90\x65\x04\x9b\x52\xad\x0a\xcb\x03\xbe\x94\x43\x76\x60\x25\xe0\x3c\x53\x0e\x0a\xa5\x8b\x49\xe4\x07\x57\x1f\xf7\x4f\x4f\x9a\x6d\x64\x0b\x11\xac\x39\x2e\xa9\x56\x8f\x23\x3f\x36\x20\x48\xab\xd7\xc3\x2c\x15\x5e\xf2\x46\x0f\xf4\x73\x87\x28\x77\x2e\x3f\x6d\x41\x27\xc6\x29\x05\xde\xa5\x95\x5e\x34\xa4\x4a\x29\x51\x39\x8a\x10\xff\xc8\x4f\xdb\x62\x3b\x91\x62\x5b\x9d\x10\xa4\x03\xbc\xa5\x84\x3a\xca\xfb\x78\x4b\x25\xe6\xe4\x8a\x95\x1a\x3f\x4f\xcb\x00\xab\x34\x85\x7d\xd6\x5c\x78\x3b\xd6\x77\xf6\x1b\x72\x09\xcd\xf0\x28\x84\x7d\x6d\x8e\x50\xd5\x7d\x19\xb4\x76\x73\x3a\x1d\x98\x30\xc3\x58\xb9\xa7\xd9\x51\x9d\xfb\x2b\x4e\xaa\xdb\x66\xe2\x85\x31\x73\xc9\xbd\xa9\x5c\x60\xb4\x00\x77\x68\xb4\x12\x93\x5f\xab\xd0\xe3\x59\x37\x32\x66\x47\xf3\x82\x1b\xf2\x3e\x86\x4b\xcc\x04\xe5\xa3\xb5\x92\x61\x54\x09\x86\xac\xae\xf3\x7d\xee\x5b\x99\xdc\x2f\x9c\x5a\x0e\x38\xd7\x56\x2e\x88\x83\xae\xf6\x6d\x9b\x83\x03\x81\x7d\x43\x5e\x73\x78\x8a\x69\x24\x17\xba\x56\x49\x67\x28\x4d\xa4\x70\xeb\xca\x94\xb2\xd2\x2d\x59\x29\x38\x0b\x2b\x2e\xb9\xe0\x0d\x83\x4a\x67\xaa\x7d\x90\xcb\xdd\xd9\xb5\x35\x17\xed\xcd\xc3\x3e\x23\x5e\x5a\x2b\xd9\xbf\x5b\xea\xc8\x34\xc2\x9d\xce\x8a\x88\x14\xb4\xb6\xe4\x17\xb2\x7f\xdf\x64\xbf\x30\x8c\x7d\x97\x35\xc3\xd8\xeb\x06\x66\x82\xf8\x14\x9c\x6f\x18\x8e\x83\x5d\xba\x6e\x74\x49\xed\x32\xf3\x1e\x16\xe9\x5c\x5b\xae\x20\x79\xb5\xb7\x41\xa2\xf9\x14\x93\xc4\xe4\x4f\xd4\x1e\x31\x0c\xe4\xee\xa7\xda\xae\xa9\x88\x98\xde\x8a\x42\x41\xc2\xee\x26\xe9\x65\x4c\xc2\xfe\x70\x9d\xf2\xbd\x57\x59\x4b\x0c\x6d\xf7\x07\xf4\x44\xb5\x56\x3a\x7d\xd8\x2c\x12\xa6\xa4\xf9\x6c\x20\x90\x48\x34\x62\xb0\xaa\xb2\xbf\xe1\xe7\xb8\x38\xee\x5b\x36\x06\x8d\xbd\xf4\x89\x5b\x82\x62\xb8\xeb\xf1\x4f\xfc\xd4\x3a\x97\x43\x73\x8a\x3b\xa6\xad\xa2\xad\x1a\x3d\x6a\xb6\xdc\xdd\x1e\xad\x48\x9e\x2a\x09\x0f\x5e\x4b\x09\x9b\x29\x02\x57\xfa\x0c\xf7\x01\x1b\x40\x18\x09\xd6\x13\xc1\xc3\x7d\x1d\xc1\xc3\x5a\x16\xd9\xb9\xa2\x67\x55\x89\xb3\x50\x95\x48\x7a\xde\x65\xf6\xbc\x4b\x31\x0b\x2b\xb6\xe7\xb5\x7e\xd4\xa2\x5f\xac\x6f\xa1\xc8\x50\xd7\xf7\x4d\x55\xb4\xe8\x56\xf4\xcd\x4a\xed\x45\x5d\x51\x93\xea\xd4\x56\xf8\xca\x3e\x24\x17\x55\xc7\xa2\xb2\x4f\x57\xdd\xaa\x22\xeb\xaa\xf5\x61\xd3\xdf\xd7\x68\x85\xcf\xd7\xd5\x9b\xe9\x7a\x10\x17\x3f\xdf\xb4\xf9\x54\x45\x9e\xb4\xd5\xbd\xad\xd4\x7e\x01\xb3\x3e\x1e\x48\x96\x64\x2b\x45\x5e\x8e\x48\x45\x2f\x3d\x98\x42\x44\xad\x88\xde\x37\x1e\xb0\x45\xf0\x20\x9f\x1a\x05\xcc\x7b\x39\x36\x0b\xd1\x85\x6a\x62\x45\xc0\x8e\x4a\x3f\xab\xa2\x80\x45\x7f\xe9\xa0\x61\x71\xc9\xac\x79\x2a\xf5\x7e\xf6\x04\x0f\x8e\x40\xd7\xa5\xa2\x4b\xf9\x89\xb5\x05\x6c\xa9\x2b\x17\xc0\x1f\x5a\x1c\x83\x3a\xb7\x54\x3c\x31\x60\x80\x64\x41\x75\xd3\x97\x16\x86\xe8\xea\xd0\x54\xb9\xb5\xd6\x65\xdf\xca\x3f\x2a\x96\xb2\x8a\x43\x95\xaf\x61\xf4\x5a\x1d\x6e\x7b\x95\xda\x52\x5c\xc8\x8d\xf8\x72\x48\x39\x42\x33\x7d\x84\x16\x7a\x0a\xab\xd4\xbe\x89\xe0\xb0\x4f\x4a\x69\x88\x1a\xe5\xf6\x6a\xcf\x19\x49\x24\xaf\x5d\x92\x65\xaa\xce\xa5\x57\xa5\x3a\xb5\x48\x62\x37\xc3\x57\x95\xef\x71\x44\x11\x4e\x61\x2f\x31\x19\xb3\xe4\x6c\x70\xbb\xeb\x32\x16\x34\x14\xeb\xf6\xba\x0b\x3a\xf0\x97\xa3\x0b\xbf\x28\x88\xe4\xa8\xd8\x3a\x62\xe1\x55\xad\xbb\xed\x43\x28\x15\x84\x46\x29\xe4\xf6\x2c\x25\x65\x27\x34\xce\x95\x94\x77\xe1\x2c\x4e\x85\xf5\x78\xf2\xf8\xe1\x03\xa3\x21\xd6\xdd\x14\x56\xf8\x89\x84\xd9\xdf\xd5\x9c\x3a\xb6\xc0\x79\x71\xea\xdd\x99\x9c\x6f\x39\xe2\x90\xd9\x2d\xb3\x1b\xce\x2d\xaa\xaf\x52\x49\x96\xc3\xef\xd9\xeb\x76\x39\xc1\x55\x31\x6d\x28\x91\x8c\x61\x91\xca\xbd\x2a\x9f\x59\x39\xf0\x6b\x39\x23\x0c\xf8\x5c\xea\xee\xfc\x89\x95\x4a\x99\xc8\x81\x9f\xe3\x35\xd2\xce\xb6\xe5\x4b\x71\x16\x80\x13\x49\x0d\x70\x61\x31\x29\x41\x32\xa9\x86\x5e\xa5\x85\x8a\xe2\x48\xed\x34\x21\x86\x1b\xe4\x06\x85\x6b\x75\x91\x2e\x58\x64\x50\xd8\x4f\x6d\x9e\xc0\xa5\x1c\xc4\x9b\x14\xb6\x00\xad\xa1\xd7\xfa\xd7\x7e\x4a\x8c\x93\x98\xb9\x41\x74\x65\x9a\xa6\x41\x3f\x2b\xff\xf6\x83\x5e\x55\xe3\x23\x89\x4c\x11\xbf\x5d\x2c\xbc\xe4\x80\xa5\x1e\x7a\xef\xbd\x49\x7b\x4e\x32\x0f\x1c\x9d\xfa\x77\xcd\xe1\x23\x6a\x25\xd8\x15\x4d\x9c\x97\x2d\x0f\x0e\x52\x74\x6f\x42\x5f\xc3\xa3\x41\x2a\x5e\x92\xab\x04\x22\x10\x65\x2c\xd5\x49\x6a\x1f\xa5\xc4\x70\x42\x96\xa6\x67\x52\x13\xa7\xf0\x65\x40\x51\xba\x49\xe5\x27\x9f\xa4\x44\x41\x2b\x8d\xf0\xef\x78\xc9\x92\x28\x88\xae\xe4\xb7\xeb\x11\x79\x23\xd7\xb5\x0a\x0f\xfc\xaa\x86\x92\x67\x42\xc4\x72\x30\x6f\xd5\x75\x18\x18\x14\x9e\xa4\xf6\x22\x81\xe3\xd4\x9e\x27\x70\xb6\xa1\xbf\xc7\xa9\xca\x4a\x88\xd9\x26\xd5\x11\xe7\x40\x07\xcf\x52\xa9\xdb\x06\xce\xb5\x01\x67\x8e\xc2\x44\x3e\x4f\x37\x7b\xb0\xdc\x56\xdf\x14\xb1\x7c\x1c\x08\x6f\x5e\x7e\x88\x46\xb0\xc0\xb9\x6e\x14\x09\x83\xe8\x7a\xa4\x5d\xfa\x65\x49\x8f\x5a\x4b\xf2\x35\x55\x64\xf1\x24\x05\x83\x33\xe7\xfa\x2a\x89\xb3\xc8\x35\xc0\x10\x09\x8b\xd2\x05\x4b\xbc\x48\xa5\x0f\x92\x05\xfc\x38\x12\x0a\x0d\xdd\x4b\x82\xfa\xb6\x93\x25\xa9\x5c\x88\xc6\x22\x0e\x22\xe1\x25\xd5\x83\x38\x13\x61\x10\x79\x06\x18\x51\x1c\xc9\xf9\x69\x76\xc5\x90\xa3\xa1\x02\x54\xb0\x33\xea\xb0\xff\x74\x40\xbd\x2e\xbd\x93\x2f\x06\x9e\xff\x56\x22\x8d\x0e\x3c\x2f\x43\x5f\xbf\xa5\x7f\x05\xed\x13\x73\xcc\xca\xae\x2a\xf5\xeb\x56\x90\x1b\xec\x78\x05\x55\xaf\xb2\xe4\x52\x38\x41\xb4\x40\x0c\xba\xcc\xd4\x39\xf4\xb3\xc1\x2d\xeb\x5a\xb0\xd9\xf3\x5e\xd2\x38\x0f\xc8\x53\x34\x55\x22\x0f\xfe\x2e\x85\x86\xc9\x80\x9d\x5a\x13\x3c\x37\xc7\xac\xa9\xb4\x80\xb7\x6a\x2d\x88\x40\x84\x72\x9c\x5f\xf5\xad\xcd\x2a\x29\xc7\x6e\xcf\xba\xe0\x22\x1a\x23\x36\xd8\x68\x9e\x8c\xb7\x47\x73\x3e\xde\x2e\xc9\xa9\x49\x47\x5c\x44\x23\x59\x34\x9d\x8f\x78\x9c\xb8\x5e\x32\x4e\x82\xab\x99\x18\x4f\x46\xc2\xbb\x11\xe3\x79\x26\x3c\xb7\x9a\xfe\x2c\xf5\x92\x71\xea\x85\x9e\xa3\xa8\x26\x10\x01\x0b\xab\xa7\xe3\x79\x7c\x3b\xfe\x49\x91\xa5\xc7\xaf\x03\xf1\x93\x52\xba\x23\x4e\x1c\x22\x11\xfe\xc3\x71\x9c\xc6\x92\x4e\xee\xff\xcb\x36\xfe\x75\x5f\x20\x48\xaa\x8a\xe0\xf9\xda\xfb\x39\x57\x63\x9f\xb9\x9e\x8b\xd7\x9a\x70\xc7\xa9\xe7\xc4\x91\xcb\x92\x95\x22\xd6\xe7\x29\x51\x40\x5e\x94\xc2\xdb\x94\x18\x47\x88\x3b\x38\xe2\xab\x91\x98\x05\xe9\x08\x53\x10\x34\x9a\x36\xee\x97\x6c\xb5\x80\x0f\x7d\xb3\xdb\x34\x76\x44\xde\x72\x4f\xe1\x18\xda\xc6\xfd\xaf\x01\x79\x17\x74\xfd\x75\x2a\x6a\x8c\x3d\x54\xd7\x26\x1a\x9a\x58\x65\x6d\x7c\xa7\x38\x14\x33\x28\xbc\x50\x3f\x25\xaf\x7a\x3f\xc0\x71\x8e\x52\x30\x66\x89\xe7\x1b\xf0\xe0\x7f\x7d\x65\x39\x4b\x9d\x24\x58\x08\xeb\x41\xa0\x72\x9c\x4a\xad\x84\x9a\x89\xb7\x08\x99\xe3\x91\x07\xff\x7f\xfa\xe0\x0a\x0c\x83\xd2\x3d\xc3\xb0\x12\x5a\xa6\x21\x7d\x99\x2a\x8f\x9c\x41\x0e\x98\xc4\x65\x92\x89\xc1\x22\xb3\xb2\x88\x5c\x44\x35\x3e\x65\x8d\x42\x89\xc9\xd3\x3e\x75\x97\x51\x0b\xfe\xed\x5e\xd4\x08\xb8\xde\x5d\x73\xfd\x97\x02\xe9\xa5\x94\xbc\x35\x42\x5c\x25\xa2\x58\x99\xc5\x1c\xc3\x03\xaa\x00\x01\x95\x74\x08\x81\x38\x6e\x33\x82\x0e\x4f\x37\x02\xbe\x66\x24\xc3\xe0\x00\xa5\x43\xd7\x18\x72\x77\x7c\x19\x5f\x4d\xda\xaf\x76\x0a\x27\x0a\xaf\x69\xd4\xdf\xd5\x4e\x0b\x5f\x33\x42\x74\xf3\x0a\x97\x5c\x28\x05\xfd\x0e\x9d\x53\x3d\xba\xdf\x68\xb3\xfd\x50\x3d\x28\x28\xbc\xee\x25\xa2\x05\x29\x83\x34\xcc\x74\x11\x06\x42\x92\xc9\xfd\x07\x57\x08\xe8\x9f\x2b\x7e\xc4\x92\x2b\x4f\x0a\x8a\x24\xef\xa7\xc2\x35\x02\x6f\x7b\x9e\xec\xab\x7d\x63\x1f\x5e\xe3\x3b\x5c\xc2\xef\x53\xa9\xbf\x45\x39\x31\xbe\xf0\x90\x49\x91\x52\x2f\x7b\x9d\x5a\x44\x90\x25\xf9\x94\xc2\x6b\x54\xd8\xb7\x70\x9d\x88\x1c\x17\x87\x90\x8c\xca\xd3\xbf\x67\x06\x85\x4c\xff\x96\xf2\x8b\xe5\x77\x63\xa0\x59\x5e\xea\x55\x5e\x5e\x32\x15\xe4\x84\x51\xbc\x4c\xd8\xa2\xc5\x87\x0c\xcb\xd0\x0c\x48\x54\x65\x97\xe3\xe9\x64\x82\xa5\x92\x5c\xd2\x27\x76\xda\xc9\x87\x54\x0a\x29\xd9\x31\x7d\x38\xbf\xa4\x52\xc0\x2b\x4e\xf6\x31\xc5\xcc\x25\x4d\x86\x56\x32\xb0\x20\xf2\xe3\x92\x53\x4f\x9a\xc2\x1f\xfb\xfc\xa2\x62\x84\x3e\x1b\xf9\x6c\x3c\x0f\xa2\x2c\x45\x01\x80\x65\xb6\xa4\x0a\x49\x0c\xb4\xc1\xc9\x9e\x59\x7d\xac\xb3\xb7\x25\xc5\x2e\xab\x9e\x0e\xb5\xb7\x08\x37\x35\x57\x50\x08\x86\xc8\xe6\xce\xdd\x78\x2f\x27\x7e\xa8\x7d\x7c\xc3\x99\xb1\x44\x74\x7a\xf1\x26\xce\x12\xc7\x53\xfd\x80\xb8\xb7\x1b\xd1\xbf\xa7\x93\x3d\x63\xa2\x13\xdf\x5a\xf8\xb7\x00\xbf\xb7\x6c\x9c\x93\x32\x5c\x58\x32\x56\x15\x19\x8c\x37\x55\xb0\x70\xd2\xbc\xb5\x55\xdf\x02\x95\xd2\x69\x3d\x1a\x3b\xce\x7b\x73\x1f\xfc\xbf\x1b\x89\x8d\xe3\xd2\x88\xc2\x1e\x91\xb7\x97\x07\xd4\x28\xe5\x10\xef\x5f\xae\x4e\xaa\xd6\xeb\xa7\xbd\x63\xbd\x2c\x95\x82\x02\xc6\x88\x54\x20\xfd\xd4\xc0\x34\xf5\x2a\x06\x67\x6d\x6f\x72\xdd\xd8\x37\x04\x57\x91\xd4\x41\xfc\xb1\xe3\x49\x25\x57\xe9\x49\xc6\x7d\xb9\x71\xa9\x16\xf9\x05\xf1\x73\xc9\x92\x3c\xbd\x92\xd3\xd6\x4a\x96\x1a\xa1\xee\xdb\x1d\x51\x1e\x33\x12\xd1\xbd\x63\xa2\x71\xe6\x05\xea\xec\xc7\x44\x80\xbe\xe1\x35\x91\x60\x51\x7f\x4d\xe0\x98\x6c\x49\x1a\x46\x99\x9b\xe7\x76\x98\x40\xa8\xf9\x1a\xe3\xa8\x1b\xba\xf9\x06\x74\xda\x0b\x42\x3c\x7b\x49\xd2\x5c\x69\xb6\x81\x03\xc2\x23\x0d\x3c\x5a\xda\x44\x54\x1b\x14\xe9\xf3\x4a\xa4\x47\x14\x61\xd5\x84\xc9\xa7\x94\x52\xf9\x79\x26\x6f\xec\xc1\x6f\x1b\xbb\x8f\x45\x9c\x06\xca\xa4\x80\x26\xf9\xc0\xd1\xfb\x05\x35\xf2\x72\x7f\x93\x8e\x31\xc8\x75\x14\x06\xa9\x50\xca\x2a\xde\xae\xf9\xdb\x62\x3c\x91\x9a\xeb\xa3\x9a\xc3\xd5\x0a\x2e\x72\x5a\xd4\x6b\x47\xee\xd8\x0f\xbd\x9b\x51\xa7\xe2\xf2\x35\x2e\x59\x31\x28\xac\x44\x93\x5f\x49\x46\x9b\xe7\xbd\xfe\x57\x01\x29\x43\x31\x0b\x5a\xc0\x92\x38\x39\x0e\x27\xb5\x24\x0b\x31\x24\xff\x92\x35\xbc\xa2\xbd\x5e\xd7\x4e\xbc\x8b\x22\xbe\x11\x15\xf1\x4b\x7c\xed\x83\x14\x8f\x72\x5c\x87\xd8\x1b\xf7\xc2\x70\x9c\x86\x2c\x9d\x8d\xe3\x2e\x83\xd3\xfe\x11\xe8\xa2\x50\x91\xdf\xba\x84\xed\xeb\x8a\xcb\xa2\x2b\xa9\xf5\xb6\x3a\xd3\x3e\xb7\x13\x77\xe8\xd3\x50\x8f\x5c\xc5\x74\x89\x50\xf6\x08\x92\x48\x89\x27\x4a\x89\x17\xd6\x62\x56\xd2\xf3\xa8\x9a\xd6\x29\x56\xa5\x5c\x83\x72\xc0\x79\xab\xa6\x41\xdb\x3f\xf0\xe1\xab\x14\xb2\xd2\xb3\x7c\x4b\xad\x8c\x4c\xee\x25\x66\xf9\xe6\xed\x76\x6d\x41\xc1\x5f\x89\xc9\xf7\x86\xfd\xe9\xef\xb8\xcf\x9a\xca\x8e\x3f\x1c\xda\x67\xfd\xcf\xd9\x51\xed\x70\x67\xe2\x7a\xbf\xba\xa9\x6a\x92\xee\x7f\x78\xff\x94\x50\x6b\x68\x2b\x5a\xee\xd1\xba\x23\x2a\xeb\x38\x8b\xc5\x08\x07\x5c\x13\x96\xea\xed\x56\x45\x46\x35\x33\xa9\x59\x87\x46\x82\x75\x73\x64\x63\x25\x37\xa7\x30\x6f\xd1\x88\xa4\x10\xcc\x51\x85\xbb\x07\x60\xca\x4d\xff\x04\xc3\x83\xbe\xa5\x9b\xe0\xf9\xa6\x05\xbc\x0d\xfa\x02\x22\x14\x20\x25\xa2\x8d\x15\x54\x36\xbc\xdb\xa6\x3f\x92\x6d\xca\x56\x23\x60\x45\x66\xd8\x67\xc0\x3d\xc7\xb9\xec\x5f\x20\x47\xef\x82\x20\x22\x5d\x9a\xc3\x11\xa6\xd5\x3b\x10\x24\x50\xfc\x98\x21\x24\xf1\x2a\x26\x19\xc6\xba\x7e\xc1\x11\x53\xf6\xb1\x74\xe4\xa3\x2d\x88\x7e\xa6\x96\x0a\xaa\x5a\xa8\xf5\x12\x44\x8b\x4c\x2a\xf5\x57\xea\x52\x4f\x1b\x2c\x07\xd5\x56\x6d\xb9\x8b\x4a\xcb\xdd\x2a\xb7\x97\x39\x31\x9c\x99\xe7\x5c\x23\x75\x1f\xea\xed\xc2\x6a\x21\x25\xd4\x4d\x5e\x7b\x62\xe9\x1d\x04\x54\x85\x3f\x53\x34\x39\x5f\x0f\x68\x86\x68\x48\x9b\x49\x0e\xa5\x13\xe8\x45\x70\x93\xcb\x21\xd8\xef\x13\x7b\x77\x30\xa6\x2d\xc9\x55\x45\x2b\x73\x21\x09\x2c\x1c\x4f\x47\x4e\x96\x8a\x78\x3e\x96\x9b\xac\x24\x0e\xab\x4b\xd9\x47\x1e\xdf\xd4\xef\x2e\xf0\xdd\xc3\xf2\x63\xf1\x19\x4a\xb5\x76\x05\xe3\x72\x48\x57\x79\x95\x2c\x28\xa1\xf2\x2b\x95\x43\x95\x80\xf3\x80\x6a\x56\xd9\x5c\x03\x9d\x5a\xdc\xc0\x51\x91\x19\x3f\x2d\xeb\x7a\x6a\xc7\x2f\x25\x6e\xbd\x5c\x22\xbd\x44\x14\xbd\x5f\xe6\x76\x27\x17\xfb\x51\xd6\x0c\xfe\x59\x64\x75\x78\xce\x41\x5e\x85\xe7\x5c\xe6\x2a\x1d\xdd\x9b\x5c\x1f\xcb\x5f\x7b\xab\x83\xd8\xf5\x0c\x40\x8c\x02\x0a\x47\x1b\xa6\xef\xda\x5b\xb9\xf1\x32\xaa\xe6\xef\x0d\xce\xdf\xc9\xe6\x37\xb2\xc5\x5a\xf9\x2f\x08\x92\xa8\x0f\xd9\x4f\x04\x1c\x79\x14\xe4\x2e\xe9\xeb\x10\x95\xae\x63\xd8\xdc\xf6\x35\xd8\x70\x81\x7b\x32\xf0\xbc\x74\x42\x3a\xce\xed\x7f\x79\x51\x6e\x37\x4f\x4b\xfe\x05\x67\xb9\xfd\x07\x7c\xcc\xed\xe9\x43\x38\x1f\xf8\xa2\x5a\x58\x38\x92\xb4\xe2\x70\xcc\x32\x11\xf7\xe9\x34\x1b\x8d\x76\x77\x61\xc8\x4b\xf2\x35\x87\x7b\x13\x88\x68\x4d\x02\x1f\x02\x6d\x03\xdf\xc8\xd4\x95\x12\xd0\xac\x65\xda\xaa\xc5\xf8\x3f\xff\xdb\x68\xd0\x12\x9c\x2a\x5e\x91\xce\x59\x28\x79\xc5\x85\xe2\x00\x6e\x90\x4a\x29\x2e\x59\xc0\x53\xc5\x02\x02\xf9\xfb\x9b\xfa\xad\xc0\x6b\x28\x3c\xeb\x1d\xa8\x63\x12\xc1\xbd\x09\x2d\xe0\xf9\x06\xbe\x53\x5a\xe0\xa7\x95\x05\xfe\x6d\x1f\x73\x51\x2d\x69\xbf\xd4\x57\x03\xf3\xf2\x3c\x07\xcd\xfa\x14\xa5\x3d\xcb\x4b\x8a\x7b\x9b\xa3\x61\xe1\x43\xff\x2e\x84\xef\x28\xe8\x85\x23\x34\x46\xb1\x10\x32\xfb\x00\x35\x4c\x66\xe3\xe0\x9d\x0a\x78\x11\xa8\x64\x4f\xcf\x52\x74\xcc\xc2\xcc\x0d\x8e\xfd\x05\xf7\x12\x81\x7d\x40\x32\x24\xdd\x58\x1d\x80\x8b\x3d\xc3\xb0\x32\x73\x6b\xcf\x98\xb1\xb4\x9c\x08\x0b\x2f\xd2\xcc\x71\xbc\x34\x35\xfa\x34\x8f\x24\x5e\x8e\xa2\x78\x7c\x95\x09\xe1\x25\xe9\x80\xf6\x7b\xa1\x8c\x8e\xe7\x39\x24\x1d\x6a\x93\xd4\x68\xdc\x8f\x4b\x25\x61\x1e\x44\xe3\x65\xe0\x8a\x99\x01\xc6\xf6\x64\xb2\xb8\xe9\xa3\x50\x1c\x2f\x45\xa3\xeb\x4c\xf1\x69\xde\x9f\xb8\x05\xd9\xa3\x1f\x27\x15\xab\x42\x82\x90\xe3\x75\xd4\xde\xf5\x6a\x20\xf0\x8f\x79\x23\x84\xb6\x77\x2c\x4b\xc8\xf0\xb3\x9c\xd6\xc8\xe2\xa2\x9c\xa0\x63\xe2\x81\xd3\x88\x68\x62\x3f\x7e\x24\x26\x37\xb7\xf6\x5e\x04\x56\xb9\x3e\xe4\x0d\x56\xc5\x67\xde\xe6\xb2\xe6\xf2\xea\x45\x50\x50\x38\xc9\xfb\xc4\xb9\x6e\x74\x4f\xbe\x30\xa5\x16\x96\x7c\x95\x93\x27\x79\x0f\x7b\x6e\x8c\xd4\x98\x8b\x68\xd3\x3a\x5e\x24\xc1\x5c\xd9\xa4\x2f\x72\x12\x50\x60\x3d\x1a\x93\x5a\xbf\xa7\x95\xe8\xc2\x01\x95\x1a\x65\x4b\xad\xac\x5f\x3c\x40\xe9\x30\xd2\xb3\x00\x23\xcf\xbc\x32\x8d\x7e\x16\x80\xe7\x48\xda\x6a\xae\xa8\x88\xb3\xd4\xc3\x83\x1e\x64\x07\x4f\x72\x72\x9c\x37\x58\xc1\x71\x5e\xf7\xe9\xb3\xb2\x54\x0f\xb0\xce\xf2\x90\xe6\xc5\x06\x1e\xdd\x3a\x33\x79\xdf\x2d\xa8\xb6\x32\xa5\xa1\x8c\xd2\xbd\x0a\xc5\xca\x68\x2c\x8b\xfa\xab\xdc\x24\x5e\x48\x71\xa3\xb6\x92\x68\x0c\xc5\x55\xf9\x42\x4d\x3c\x5d\x37\x29\x52\x78\xb9\x41\x12\xcd\xe3\x2c\xf5\xd0\x3e\x50\x1f\xe4\x7d\xfa\x59\xf9\xd0\x63\xb9\x57\x97\x7f\x3d\x30\x3a\xe5\x11\x57\x14\xda\x7f\x40\x12\xda\x8f\x26\x20\x42\x29\x48\xbc\xd0\x7e\xf8\x07\x64\xe1\x1d\x13\x1d\xd5\x59\xa8\x92\x32\x7b\x00\xe6\x72\xa8\x96\xd1\x57\x41\x30\xed\x7e\x95\xef\x88\x75\xab\xee\x97\x99\x4e\xb8\xd9\xad\x3c\x18\x78\x5e\xca\xcc\x78\xe0\x79\x29\x73\xfd\xbe\xe7\x7a\x28\x79\x98\x35\x06\x9d\x87\x9d\x73\x3e\xe5\x33\x81\x3c\x58\x60\x7c\x2d\x7b\x86\xf1\xb5\xec\x79\xad\xb9\x23\x7f\x8e\x15\x5e\xfa\x97\x5c\x65\x81\xb8\xdd\x60\xe9\xc8\xc2\xd2\xd2\xf1\x56\x20\xde\x36\x43\x57\x08\xb1\x77\x18\x5b\x25\x0d\x79\x14\xb8\xaa\xf1\xab\xf8\x95\x1a\x33\x75\xca\xd0\xc3\xca\x7f\xc2\x55\xd7\x73\xfc\x0c\x70\x54\x6f\x88\xa3\x26\x61\x45\x0a\x71\x48\x78\xc5\x3f\xbd\xd6\xfd\xb8\xba\x2f\xea\xfb\x62\x0f\x3f\xf4\x30\x56\x5f\xf9\x02\x39\xa5\xfc\x8c\xc6\x68\x94\xaf\x45\x61\x83\x1d\x7b\x35\x3b\xfe\x92\x13\x87\x36\xa0\xad\x13\x05\xd8\x22\x77\xdc\x38\xaa\x2c\x54\x2c\x99\x35\x58\x72\x10\x36\x59\xf2\x61\xbc\x91\x25\x47\x21\xdd\x93\x2f\x4c\xa9\x85\x25\x5f\xe5\xe4\x75\x4e\x81\x24\xb6\x83\xd5\x80\x22\x28\x95\xdc\x4c\x52\x14\x26\x22\xf1\x43\xe2\xe0\x4b\x7f\x23\xf3\x56\xcc\xc6\xef\xdb\xf2\x2a\x5e\x93\x0e\x10\xfc\x7f\xa9\x8e\xa8\x06\xbc\xa9\xdd\x45\xbf\xa8\x1f\xca\x1a\x36\xeb\x87\x79\xd8\xd5\x9d\x6a\x14\x3e\xb5\x66\x03\xb5\x4a\x63\xfb\xde\x92\xcc\x32\x70\x20\x32\xf9\x43\x4c\xac\x38\x8f\x11\xa9\x0f\x7c\xfb\x9b\x47\x1c\x3c\xa4\x8c\xff\x13\xd5\xa3\x34\x94\x8d\xf5\xaa\x47\xfe\x1d\xd4\x23\x1e\x42\x0c\x11\x3a\x1e\x49\x5d\x65\x1e\x43\xc3\xc2\xaa\x10\x4f\xee\x2e\xb8\x4f\xe4\xee\x7b\x74\xed\xad\x46\x7e\x9c\x28\x4b\x47\x10\x5d\x8d\x4a\x47\x4a\x75\x6c\xf3\x37\x55\xf7\x1f\x52\x0b\x5e\xe7\x6d\x43\x72\xdd\x66\xe3\xae\x56\x11\xca\xbc\x15\x89\x64\xce\x08\x2e\xf5\x0c\x32\xfb\x5e\x62\xb2\xe5\x3f\xff\x29\xff\xf9\xf0\xe3\x87\xca\x9c\x66\x18\x96\x91\xce\xe2\xa5\x01\x2d\x2f\x9f\x4c\xc4\x4e\x3c\x5f\x84\x9e\xf0\xc6\x73\x2f\xca\x46\xc6\xfd\x4c\x4a\x6e\xf2\x0e\x39\x12\x85\x4f\xea\x67\xc3\x7a\x7a\xd3\x55\x09\xe4\x9b\xb5\x41\xe8\x3d\xae\x57\x8d\x89\x5f\xe9\x32\x61\x68\x4b\xd9\x5c\x80\xfb\x13\xd9\xb6\x35\xf0\xbc\x54\x7a\x66\x3f\x91\x9d\xf3\x81\xe7\x65\x50\xcb\xa2\x2b\xa4\x3b\xba\x50\xaf\xce\x53\x9f\x0a\x5a\x7d\xcf\x37\xb9\xf9\x7c\x4c\x89\x1b\x92\xc4\x74\xae\xe4\x70\xb4\x96\x95\x28\xb5\x26\x93\x3f\xd6\xcc\xec\x2a\xd4\x10\x85\xcb\x81\xae\xa2\x03\xfe\xa9\x80\x48\xa5\xbc\x7d\xb7\x31\x07\xc9\xe3\x02\x4e\x7e\x96\xe0\x25\x32\x9d\xab\xa2\x32\x01\xe8\xf8\x32\x4c\x58\xd2\x39\x84\x68\xda\x7e\x46\xf3\x92\x9f\x02\x11\xf6\x14\x96\x64\x99\x80\x21\x18\x3f\x8e\x5c\xef\x06\x21\x94\x85\x02\xc8\x5c\x3b\xb8\x48\xbc\x90\xa9\xc1\x1c\xf0\x80\x6a\x13\xdb\xc7\x94\x5c\x85\x4a\x3c\x2b\xd3\x52\x32\x7e\xb4\x61\xb8\xeb\x15\x73\xa1\x93\x8f\x58\x23\xe3\xbe\x0a\x9d\xc5\x44\x21\x5e\x43\x72\xac\x86\x74\x36\x29\x4f\xa7\x52\x9c\xb2\x0f\x7b\x24\x43\xbc\x5d\x2a\xb9\x2b\x26\xf3\xd8\x02\xa7\x52\x7e\x10\xaf\xfe\xd9\x2f\x69\x40\x9e\xd6\x80\x82\x4a\xdf\xf1\xee\xfe\xbe\xa7\xde\xdd\x34\x21\x38\x42\xa3\xee\xea\x46\x0e\x80\xeb\x7b\x2b\xac\xd6\xf7\x96\x92\xd6\xff\x81\x59\xaa\x55\xaa\xf5\x6c\x2f\x52\x7f\xca\x50\x27\x08\x43\x54\x20\xe6\x61\x47\x9b\x6a\x68\x1c\x49\x48\xf7\x66\x21\x09\xa8\xa5\xf5\x28\x79\xe5\xa8\x2b\x11\xd2\x3d\x37\x54\x76\x80\x0c\x86\xf0\x18\x15\x25\x63\xa0\xc8\x07\xd4\x6e\x24\xcd\x34\xc9\x45\x47\x28\x1b\x52\x11\x8e\x9d\xeb\xea\x7e\x29\x83\xa6\x93\xc9\xff\x57\x9b\x05\x07\x98\xdd\xa8\x75\xa5\x7c\xbb\x6a\x06\xb8\x08\x09\xab\x18\xa0\xb5\x24\xcb\x10\x22\xa9\x87\xbd\xa5\xbb\x15\xba\xb3\x72\x1e\x2e\x28\x1c\x0e\xb1\xa3\xc8\x64\xd7\x4a\x0b\x7f\xa2\xb4\xf0\x4c\x69\xe1\x97\x4a\xcc\xff\xa1\xb4\xf0\x60\xb7\xff\xe4\xa5\x14\xb6\x2c\x71\xa5\x2e\xb3\xd3\xa7\xf2\xc8\x87\xe3\x99\xc7\xdc\x7a\xd1\x34\x2d\xfe\x11\xcb\x47\x92\xb0\x04\xe3\xe9\xa8\x51\x16\x6f\x94\x2f\x1c\x92\xf3\x14\x26\xe0\x68\x0f\xbf\x14\x33\x70\xe8\xd5\xa7\x8e\x2d\x94\x33\x07\x96\x9b\xf6\x97\x7b\x56\x2a\xe8\x18\xe0\x96\xb7\x92\x79\x2c\xc9\x2a\x94\x63\xe7\x80\x4a\x00\xb3\x9f\x43\x7d\x00\x26\x1f\x78\xf0\x34\x2d\x1f\x1c\xd7\x09\xe5\x13\x93\xb9\x70\x91\xd6\x5b\xfc\xb5\xcf\xd6\x93\xaf\x3e\xc2\xd9\xab\xdb\xd5\x39\x49\xf2\x50\x2e\x52\xab\xbe\xaf\x93\x9f\x7c\x90\xf4\x5c\xd6\xda\x75\xde\x16\xdd\x48\xe4\x43\x32\xcf\x21\x80\x44\x03\x3b\x96\xae\x06\x6d\x0f\x84\xcb\xb4\x83\xfe\xa9\x7c\x7d\x8b\x82\x68\x46\x75\x13\xa2\x65\x70\x36\x35\x28\x5c\x87\x2d\x5f\xe5\x9b\xb0\xf6\x55\x8e\x62\x51\x9f\x47\x60\x2f\xf7\xd5\x8b\xa9\x48\xe2\xe8\xca\xa0\x70\x19\xfe\x04\xbb\x8d\x99\xef\xca\x10\x26\xa7\x81\x5d\xd1\xa3\x0c\xea\x13\x62\xf9\x67\xec\xc4\x61\x36\x57\xb8\x52\x5a\x91\x6e\xa8\x92\xa3\xe6\x59\xe7\x55\xe5\x0c\xb4\x5f\x77\x3c\xa9\xa7\x2a\x92\xb7\xbe\xe5\x84\x21\x9e\xcc\x2b\xdc\x81\xf9\xa1\xe4\x23\xeb\x1b\xb4\x51\xf3\xa2\x52\x5b\xd5\xea\xfd\xdc\x09\xfd\xbe\x7b\xcf\xff\x73\x7a\xdb\xe8\x58\x13\xc5\x24\xb0\x9d\xe6\x81\xf2\xaf\x8c\xae\x3e\x62\xfe\xaf\x18\xdc\x72\xa3\xd2\xe5\x8c\xad\x62\xbe\xe7\xb9\x9c\x39\x4d\x17\xb3\xa0\x14\xb6\x05\x85\x83\x01\xe5\xac\x74\x5b\x7e\x33\xf0\xbc\xb4\xe9\x1c\x0d\x3c\x2f\xa3\x0a\x4f\x50\x75\x7a\x5c\xc0\x97\x50\xe7\x4c\xfb\xda\xe5\xaf\xdd\xd4\xc7\x43\xae\xbb\x4d\x5f\xd7\xd6\xf9\x69\xb9\x41\xec\x3d\x6f\x96\x3b\x86\x4d\x87\xcd\xed\xe7\xbd\x27\xcd\xaa\x48\xdb\xa4\x56\x7b\x6b\xf6\xd9\xe7\x7e\xad\xdb\x1f\x53\x22\x7a\x8e\xd3\x7b\xf7\x3a\x49\xad\x2c\xdd\x6e\x52\x48\xfb\x9d\x70\x55\x14\x69\x89\x06\x8e\xd8\x2b\x9f\xf5\x51\xab\xf8\x89\x07\x4d\x82\x5e\x1b\x0a\x7c\xa9\x6b\xe0\xd9\xec\x0d\xf3\xd7\x7c\x5d\x1a\x9e\x2d\x89\xf6\x6c\x49\xb4\x67\x8b\x93\x23\x9e\x67\xc3\x63\x25\x31\xf9\x2b\xed\x7b\xd1\xf6\x36\xbc\xa3\xef\x45\x32\xe8\x7b\xf1\x35\x44\x47\xc5\xea\x3c\xfd\xc9\xa0\x8e\xda\xfc\x9a\x05\x9b\x8c\x6a\x3f\x49\x85\x5a\x17\x92\x88\xea\x1c\x39\xc7\x4a\x0c\x2c\x0c\x0a\x67\xdd\xfa\x7a\x90\x34\x3a\xce\x2e\xab\x98\x08\xf9\x7d\x6b\x03\x58\x8f\xec\x71\xd8\xc3\x7b\xf0\x9c\xbc\x84\x83\x69\x6c\xb7\xd5\xff\xd6\x2f\x57\xb7\xdf\xae\xcb\x52\x9e\x7f\x2a\x5f\x6b\xcd\xe6\x9e\x84\x78\xba\xdf\x15\x02\x6a\xb8\xd7\x1c\xfe\x1a\xe2\xb7\x03\xd3\x7c\xf7\xa8\x18\xaf\xe4\x72\x1f\x7f\xb2\x45\x3d\x0f\x87\x71\x15\x7a\xb0\x4c\x9a\x5d\x6e\x08\xb3\x3c\x87\x8f\x21\x2c\xc9\x99\xfa\xd4\x75\x24\x85\x2f\xa9\xc2\x4b\x5e\xd3\x2b\x2e\x53\xd9\xc3\xd3\xd0\x96\x5b\xa9\x1d\x03\x2e\xfa\xfa\xd2\xe5\x2f\xd1\x1a\xcf\x58\xf7\x57\x7a\x38\x32\xee\x27\x95\x7c\x2b\x28\x3c\x0d\x35\xd4\xfb\xb7\x8d\x0d\xd4\x4e\x03\xfe\x6f\x23\x37\xe0\xa3\x39\xdf\x1e\xcd\x93\x5e\xe7\x33\xe5\x50\xf8\x13\xa7\x81\x15\x2e\xdd\xeb\x5c\xf5\x75\xcd\xfe\xb8\x08\x6b\xab\x9e\x1c\xd5\x91\x71\x3f\xaa\xb9\xdb\xb3\x4d\xe6\xfb\x76\x0c\xca\xa6\x92\x8f\x9a\x25\xdf\x6e\x2a\xb9\xdd\x2c\xf9\xaa\x6f\x9c\x1a\xa1\x86\xb6\x30\xf9\x63\x08\x6c\x61\x3a\x87\x10\xcb\xab\x2f\xbb\x4d\x5a\x38\x0a\x61\xcd\x4e\xd7\xab\xf3\xc7\x61\xbd\x19\xc8\xc9\x65\x08\x8b\x5c\x01\xab\xc3\xb3\x50\x47\xf9\x25\x78\x12\x3c\x05\x66\x31\xc4\xe2\xea\x28\xd0\xc3\x75\xbc\x55\x75\x64\xba\x8e\x87\xc0\xac\xac\xa0\x10\xf4\xd6\x71\x87\x49\x5e\x91\x6f\x21\x18\x3a\x7d\x4b\x0c\xcf\x43\x4c\xe2\x14\xed\xad\xc8\x45\x08\x7d\xae\x4d\xda\x20\x01\x86\xcf\xc6\x22\x41\x97\x3e\x03\x88\xa7\xfb\x03\xcc\xf2\x8a\x8a\xe7\x7e\xae\xb2\xfa\x7f\x08\x35\x70\xc6\x3b\xa9\x58\x0f\x5b\x6b\x2b\x0d\x53\x2e\x86\x57\x4d\x7b\xf4\xab\xc4\xcb\x03\x6f\xa9\xf1\xae\xd4\x66\xe6\xc5\x46\xca\xaf\xc7\x42\x8a\xa7\x91\x71\xff\x34\xd4\xf5\xbd\x0b\x65\x8f\x23\xc8\x6c\xcf\xdc\xda\x33\x30\x80\xd3\x33\x2c\xe3\x2d\xe6\x3a\x31\x5a\x56\xc5\xb9\x1c\xc6\xae\xcd\xfc\x63\x4a\x3e\x84\x75\xf7\x32\x65\x2d\x1c\x7c\xb1\x69\x85\x16\x2d\xfb\x49\xea\x89\x72\xa0\x76\x35\x31\x16\x14\xde\xff\x84\xc1\xbd\xfc\x89\x8d\xef\xd3\x4f\xce\xaf\x5e\x87\x1a\x6f\x3c\x72\xef\x36\x84\x49\xbc\x6c\x8e\x60\x45\x94\x6f\xd0\x24\x0d\x9a\x64\x35\x28\x40\x08\x47\x21\x85\xa3\x90\xbc\x0e\x29\x44\x14\xaa\xd2\x4f\x35\x38\xae\x7e\x61\x5b\xbf\xf0\xbe\xf5\x82\x68\xbc\x70\x88\x21\x80\xcd\xca\x5f\xb6\xca\x96\x47\xa1\x89\xab\x5c\x8b\xbd\x1b\xc1\x12\x8f\x19\x14\x84\xdb\xeb\x46\xa9\x5d\xe4\x6c\xcf\x64\x2b\x44\x05\x77\x62\xcc\x61\xce\xae\x01\x71\xa9\x67\xe0\xdb\x0a\x1d\xc3\x38\xf3\x96\x25\xaa\x9a\x6c\xfb\x53\x8c\x20\xe7\xe8\xa3\x7d\xe8\x06\xa2\x7e\xf6\x32\x56\xb0\x02\x0a\x7a\xae\xd7\x5e\x50\x8b\x57\x1f\xdd\xb4\xe5\x86\x3a\x72\x81\x99\x4e\x0a\x0c\xf1\x75\xcd\x15\x2e\x6b\x66\xf2\x9d\xe6\x3a\xae\x46\xbc\x59\x5d\xef\x16\xc4\x38\xd5\x69\x7c\x46\xe5\x4e\xbf\x66\xcb\x4d\x96\xac\x16\x50\xad\x31\x94\x4e\x8f\xda\x6b\xd6\x34\xfa\xb6\xf4\x2d\x66\x57\x8b\x94\x16\xa3\x42\x55\xa4\x34\x9e\xc3\xc6\x62\xef\x94\x43\x4d\xd3\x43\x40\x2b\x67\xfb\x0e\xbc\x0a\xc9\x54\x2a\x86\x19\x45\xa7\x09\x18\x60\x45\x8a\x05\x2d\xc2\x2c\x35\x24\x35\x3c\x0d\xb5\xc5\xbe\xa2\x9d\x2a\x2e\xfb\x34\x54\xa4\xf3\xa6\x22\x9d\x2f\x21\x05\x05\xb8\x88\xa5\x13\x17\x8c\x83\x32\xe5\x50\x59\xfa\xa0\x2a\x7d\xa2\x4a\xe7\xb4\x77\x62\x56\xe4\x3c\x04\x7d\xec\xb3\x22\x2f\xa4\xae\xc0\x80\xd7\x42\xcf\x53\xa4\x39\xdb\x31\x28\x64\xae\xbd\x76\xcc\xd9\xd9\x27\x35\x75\x6f\x27\x0c\x16\x68\x26\x74\x04\x99\x00\xfe\x47\x8d\x1e\x3b\xa2\x1f\xdc\xd4\x1b\x8a\x16\xe3\x8b\x5d\x16\x8e\xe4\x5e\xa5\x6f\x5f\x89\x4f\xc7\x72\x33\xe9\x26\xf1\xa2\x59\xac\x64\x46\x89\x82\x70\x3a\x51\x7e\x43\x26\x0f\x41\x83\x3a\xdd\x28\x8b\x99\xe9\xac\x36\x9b\xc7\xea\x0e\x94\xa6\xd1\x01\x23\xe1\x40\xdf\xc7\x6e\xc0\xc2\xf8\x6a\xd4\xbc\xd0\x12\x6c\xc3\x17\xe3\x66\x19\xe3\x85\x87\x0a\xac\x1b\xe5\x3c\xb7\xfd\x5c\xc7\xaf\xb6\xf9\x7b\x8b\xbd\x3b\x61\x9c\xea\x03\xa5\xa4\xf7\x34\xb1\x6f\xa8\x63\x77\x55\x56\x2a\xfa\x8b\xf8\x71\xdc\x90\xce\x5e\xd3\x5f\xe5\x67\x73\xa7\x47\xb8\x52\x11\x81\xb9\x77\xf5\x96\x18\x2c\xc8\x43\x14\xe5\xfb\x89\x37\x5a\xc5\xd9\x28\xcd\xf4\x8f\x25\x8b\xc4\x48\xc4\x23\x95\xfe\xac\xc5\x40\xf6\x0c\x0a\xec\xa6\x37\x44\xab\x25\x3e\x6f\x18\x59\x12\xe6\xaa\x0c\x13\x4d\x07\xa0\x38\xf2\x83\x64\xae\xb8\x08\x3b\xb1\x6e\x18\x79\xca\x29\x38\x2b\xcb\x38\x54\xad\x95\x8c\x57\x76\x3d\x18\xea\xfa\xa8\x7f\xdb\x3d\xea\x8f\x9f\x69\x7a\x9e\x62\xec\x22\x86\xcf\xe8\x15\x1c\x6f\x18\xc7\x96\xd6\xea\x77\x0b\x56\x48\x45\x6c\xc7\x64\x8f\xd6\xd1\xfd\x06\x36\x1e\x3f\x3b\xcd\x5e\x0b\x6f\xc3\x91\x8c\xbb\x23\xa9\x86\xcb\x68\xd9\xc3\xfe\xee\x36\x9e\x7a\xa1\x27\x74\x78\x5a\x41\x81\xbb\xbd\x19\x7e\xfb\x2d\x17\xc7\xa4\xca\x5e\x86\xb8\x85\x7c\x07\x5d\x32\xb6\x15\xa8\x1c\x8e\xd7\x5f\x0e\x48\x69\xfa\x4b\x19\x17\x9e\x4a\x1b\xd7\x8c\x31\x69\x82\x6f\xb5\xe0\x02\x11\x03\xdf\xf0\xdc\x40\x18\x2d\xd0\xcc\x5f\xea\x41\x53\xc7\x93\xca\x82\x8e\xdf\x4b\xfb\x86\xe7\x86\x91\x77\x7c\x2d\xb2\x9e\x3f\x06\x76\x8a\x00\xfe\x7b\xdb\x65\x84\xbd\x73\x58\xb4\x8e\x0b\xbf\x86\xea\x34\x15\x9e\xfa\xca\xd5\x28\xdf\xb0\x16\xfe\x67\x06\x38\x75\xed\xfb\x49\x6b\xa1\x34\xd6\x44\xe0\xa2\x36\x98\x22\x8e\xea\xd1\xba\x7d\x41\x3d\x47\x65\x14\x4b\x38\x69\x0f\xc9\x63\x15\x3a\x29\xa4\xaa\x05\xb1\x5d\x08\xfa\x9f\x5d\xc2\x2f\x4e\x71\x7f\xa0\x11\x6a\x37\x81\x87\x7c\x58\x6a\x84\xae\x9c\xa0\x25\xf1\x5d\x48\xe0\xde\xb4\xc3\xc6\x6b\x4b\x52\xea\xca\x2e\xed\x48\x9d\xc7\x25\xd1\xde\x89\x20\x4b\xe2\xe8\xb7\xa8\xf5\x45\xd4\xa4\x5b\x50\x08\xdd\x3e\x6f\x9c\x3c\x21\xab\x04\x49\x41\x87\x12\xb9\x2d\xe5\x5e\x85\x63\xf4\x1d\xa4\x54\x49\xc1\xab\x70\x3f\x75\x6c\xba\xb5\xe1\x14\x90\xf9\x85\x3a\x1c\xdf\x78\xea\xcd\xfe\x28\xd1\x54\xc1\x43\x1c\x65\x15\xe0\xa1\xa3\x3b\xca\xf1\x2b\xcf\x53\xac\x25\x09\x2b\x41\x5c\xd3\x5e\x3d\x48\x43\x4c\x44\x4e\x5e\xee\x96\x31\x5a\x91\x4a\xd1\x8a\x6b\x22\xeb\x33\xdb\x88\x7e\xb3\x0d\xee\x0d\x0a\x0a\x5b\x6e\x13\xb4\x75\xd6\x1e\xeb\x81\x10\xd7\xd2\xb9\xb3\x4d\x97\x55\x7a\xd2\xb5\xd6\xaa\xdc\xa4\x45\x01\xf3\xbe\xb9\x6c\xb8\x63\x2c\x36\xec\xd0\xf0\xd0\x4f\x40\xa4\x66\x60\xee\xc2\x0d\x6b\x1d\x9a\x05\x3e\x49\xca\xcc\x0a\x49\x39\xb9\x15\xc2\xcc\xcc\x2d\xbd\x07\x1a\xc6\x79\xe6\x5e\x79\x23\xfc\x3b\x5e\x04\x61\x18\x2f\xf5\x85\xfe\x00\xbd\x96\x51\xa0\x8a\x78\x31\x9a\xb7\x0d\x3e\x18\x7b\xac\xf4\x95\x62\xa0\xb9\xcf\x14\x93\xee\x51\xb8\x6a\xb1\xab\x04\x94\x42\xfc\x50\x2b\xc4\xdf\x7b\x8c\xf1\x03\x47\xa7\xed\x70\xa9\x5e\x9c\x8a\x85\x8b\xf9\x71\xf8\x0a\x24\x4d\xd2\x02\x04\xad\x3a\x78\xc7\x7a\x97\xaa\x92\x89\xa4\x0f\xec\xff\xd2\xc5\xe0\x80\x99\x98\x87\x47\x98\x83\x64\xe5\xda\x5b\x09\x1c\xba\xf6\x2c\x81\x9b\xff\xc9\x2a\xd5\x35\x23\x44\xa8\x64\x2f\xfa\xe8\x47\x14\xb4\x5f\xc5\xaa\x58\xce\xf5\x06\x25\x68\xa7\xa9\x04\xed\xff\xf7\x28\x41\xd7\xf2\xdb\xaf\xff\x73\x95\xa0\xa1\x36\xd6\x94\xa0\x4b\xb5\xe3\xe3\x06\x85\x83\x0d\x22\x79\xed\x80\x4f\x1d\x3a\x6e\xd8\x68\x6f\xa3\x7b\x25\x96\x6d\x05\x28\x2e\xc9\xa5\x5b\x59\x01\xa2\xde\x03\xf9\x38\x1c\x4f\x27\x3f\x37\x06\x26\xd5\xa6\xf5\xcd\x06\xeb\x89\x3d\x14\x85\x7c\xcd\x48\x65\x62\xc2\x28\x64\x34\x9c\x27\x74\x3d\x78\xb0\x73\xa4\x5e\x85\x00\xb7\x58\xd1\x3c\xac\x03\x28\xb9\xab\xd0\x4b\xf6\x5d\x10\x5a\x8e\xea\x24\xd8\x2e\x18\xc7\x4f\x0d\xd8\x4f\x75\x68\xae\xbe\xa7\x54\x81\x11\x13\xf8\xc8\xcf\x31\x7d\x0a\xad\x1e\x4b\x4d\xa2\xf5\x50\xe5\xdc\x56\x0f\x95\x19\xd0\x6d\x3f\x67\xf5\x73\x65\x2f\x74\x47\x7c\x55\xb6\x7b\x5b\x3f\x2b\xcd\x08\xea\x41\xde\xec\x90\xf0\xf0\xb6\xe4\x83\x7a\x25\x54\x4f\x4f\x1b\x99\xbe\xeb\x63\x2a\xe5\x17\xe1\xeb\xe3\x2a\xaa\x93\xa2\x50\xc8\xa4\x8e\xe0\x29\x1d\xe1\x06\x47\x64\x52\xe9\x08\x05\x85\xa3\x5e\xed\x00\x75\xc0\xce\x06\xbd\x45\x44\x3d\xd6\xa2\x33\x36\xf7\x2c\x6d\x51\x42\x18\x14\xe5\x44\xd7\x55\x62\x36\xd4\xb1\xaf\x40\x8e\xdb\xd5\x78\x95\xc7\xed\x89\x36\x90\x6c\x1b\x14\xbe\x74\x0c\x24\xeb\x87\xc8\xfa\x0b\x4e\xdc\x86\xe1\xcb\x4b\x67\x23\x8d\xc4\xdb\xe9\xdc\xd0\xda\x6a\xaf\x8e\x74\x3e\x9e\x4e\x9a\x7d\xc6\x3a\xa3\x58\x8c\x14\x4e\x70\x96\xd4\x51\xbb\x95\x71\xa4\xb4\x8a\x3c\x2e\xad\x22\x3b\xa5\x55\xc4\xdb\xfd\x49\x97\x0f\x14\x7c\xf0\x2f\xf7\xba\x1e\x60\xdd\xeb\xed\xce\x64\x75\x2b\xeb\xfb\x40\xd1\xc7\x27\xfe\x5a\xab\xea\x1b\xee\xd2\x6e\xb9\xba\x49\xa2\xb3\x35\xa3\x6a\x61\x48\xf2\x85\xf2\xaa\x3a\x02\x00\x23\xf1\x98\xbb\x52\x3e\xf9\xf5\xe3\xf2\x54\x10\x8c\xd4\x13\x92\x57\x5f\xa9\x12\x9f\x71\x0f\xa3\x76\x75\x23\x9d\xea\x3a\x70\x94\x57\xe6\xab\x40\xb9\x5a\xae\x9d\x24\xfe\x6d\x23\xf0\xca\xf3\x92\x7a\x00\xb6\xf2\xfe\x01\xc0\x2e\x1d\xb9\x90\xd5\xce\xe6\x5f\x15\xe9\x3b\xb1\x2b\x99\xdf\xad\xba\x5a\x48\x71\x05\x4f\x06\x16\xf1\x00\x07\xfd\x5b\xe9\xe8\x2d\xa2\x60\xdf\x91\x92\x22\xd3\x39\x28\x87\xf2\x8b\x2b\x97\xb6\xc0\x3d\x55\x64\x3a\xcf\x60\x88\xfe\x35\xe4\xf7\xe8\x38\x52\x69\xf2\x74\xf0\xef\xdf\xd1\xf9\x27\x88\x45\x7e\xd7\x65\x60\xf2\x5e\x89\xf9\x17\x9b\x2e\x41\xcf\xef\xde\x7a\xfc\x37\xb7\xfe\x36\xf5\x92\xbb\xb7\xbe\xf8\xfb\x5a\x7f\x56\xc2\xb8\xdf\xbd\xf5\xd7\x7f\x5f\xeb\x17\x1a\x2f\xfe\xce\x8d\x3b\x5f\xff\xbe\xc6\x7f\xf5\xc3\x9d\xa3\x9a\xfb\xa8\x08\x03\x93\x2f\xa1\xb9\xb4\x5b\xa2\x02\x05\x50\x59\xf7\x6d\xd5\x93\x45\xc3\xe7\xb6\x05\x98\xf9\x0f\xff\x77\xff\x77\xff\x71\x0b\x2c\x73\xec\xb3\x79\x10\xae\x0c\x30\xe6\x71\x14\xa7\x0b\xe6\x34\xbc\x8b\xbf\xba\x1d\x3f\x36\x1d\x59\x50\xc3\xfb\x1e\xf7\x58\xae\x5a\x61\x31\xce\x75\xd7\xa5\xb1\xc2\x67\xea\xc5\x26\xf9\x6d\x77\xd8\x23\xe3\x89\xab\x7c\x2b\x9a\x30\xbd\x7d\xce\x24\x6d\x57\x8c\xa2\xc0\x3d\xc6\x7a\x62\xbd\xde\xd6\xb7\xa1\xe9\x01\x3c\x53\x92\x7b\xd2\xd7\x25\x95\xfd\xa4\xe1\xb0\x72\x48\xde\xb8\xe0\x81\x00\x06\xf7\xee\x65\x7f\xa9\x93\xce\xb7\xee\x86\xe7\x30\x94\x3b\x54\x1f\x9c\xea\xc3\x2b\xfc\x2b\x61\x23\x95\x38\x0b\x6a\xb2\x4c\xc5\xa1\xfc\x01\x88\xa6\xe7\x23\x98\x1e\x9b\xc0\xc0\xf9\x4b\xcb\x46\xd7\x00\x90\xd0\xce\x75\x6e\x7f\xe8\xf3\xe7\x5e\x17\xe3\xda\x57\xf7\x1d\x47\x4b\xc3\x87\x12\x2a\x0e\x56\x64\xe5\xc2\x95\x8b\xd9\x6c\xe0\x90\x1c\xba\xe0\xba\xc0\xf0\xf2\x73\x27\x49\x09\xd6\x73\xc8\xe0\x90\x08\x17\xbe\x08\xf9\xc1\xf2\xcb\x9f\x40\x64\x3a\x51\xc7\x5e\xd3\x2a\x7d\x22\x88\x1c\x1e\xd8\x02\xc3\x68\x15\xff\x7d\x78\xdc\xaf\xc3\xa2\x80\x33\xd7\xfe\xfe\xc4\xaa\x81\xdd\x81\x3f\xb6\xf4\x51\xa8\x51\xc0\xc7\xf2\x69\x6d\x06\x96\xcf\xdf\x94\x57\x05\x9c\x57\x25\x74\xc6\x07\x7c\xae\x7e\x17\x70\x8a\x16\xa3\x33\x17\x3e\xba\x70\xee\x82\x2c\x59\xa2\x46\x2e\x92\x78\xee\x89\x99\x97\xa5\x66\x10\x3f\x70\x63\x27\x55\x5d\x08\xa2\x2b\xf5\x63\xce\x22\x76\xe5\x25\x0f\x54\x95\xcf\xbd\x70\x61\x14\x9f\x29\x5c\xa8\x06\xd5\x5d\xa3\x80\xa7\x83\x3b\xc9\x83\x5e\x08\xb6\x6e\xf6\x98\x33\x77\xcd\x68\x7a\xe1\x96\x43\xad\xe7\x47\x13\x5d\x7b\xf5\x7c\x74\xd7\x13\x4b\xba\x1d\x90\x6c\x57\x12\x35\x85\x84\xee\x19\xa3\x3a\xca\xb9\xa0\xf0\xed\xa7\x26\xe9\x66\x74\x85\x71\x7f\x49\x9e\xea\xed\x75\x49\xb3\xef\x5a\xa5\x34\x5e\xef\x7b\xb9\x94\x9e\x20\x76\x8f\x0e\xeb\x81\x76\x90\x8f\xf6\x37\xd2\x3b\x0b\x7d\xd8\x07\xcf\xd5\x75\xc4\x72\x83\xc2\xdb\x01\x05\xeb\x99\xdb\x68\x90\xb3\x64\xa4\xfe\x19\x8b\xf8\xea\x2a\xf4\x18\x0f\xbd\xf1\xdc\x2d\x6f\x86\xc1\xd5\x4c\xd4\xfe\xa0\x73\x3e\xde\x19\x2d\xc4\xf8\xe1\x68\x81\xe8\x3f\x6d\x18\x23\x1e\x0b\x11\xcf\x0d\x30\xa6\x8b\x9b\x51\x1a\x87\x81\x3b\x4a\xae\x38\x23\x13\x18\xa9\xff\xcd\xe9\xf6\x0e\xad\x97\xeb\xf3\x86\xd4\x89\x04\x0b\xa2\xe6\x89\x65\x6b\x5c\x64\x57\x78\xc2\x22\xb7\x34\x4d\x77\x0e\xfc\x35\x95\x75\x75\x54\xfd\x36\x8e\xc9\x67\x1d\xef\x86\x9a\xea\x37\x34\x5d\x9f\xba\xb4\xd7\x0f\xbf\x99\xaa\xaa\xd7\x99\xae\x63\x6b\x59\x93\xb2\x41\x14\x06\x91\x57\x07\x38\x75\xbf\x6b\x20\x12\x74\xcd\xf4\x1e\x79\xcb\xd6\x16\xa8\xe1\xb4\x51\xb9\x45\x93\xd6\xb6\xad\x80\x57\x9b\xad\x32\x2d\x2e\xaa\x8f\x4c\x98\xeb\xaa\x5d\xc7\x23\x8c\xa0\x2c\x43\xa3\x34\x30\x55\xd2\xf5\xe7\x85\xb7\x52\x17\x76\xae\xd7\x15\x02\x3d\x91\x92\x40\x2a\xce\x7c\xec\x92\x86\x97\xdc\x87\x01\x83\xf0\xf4\x77\x6d\x11\x7e\x37\x54\xa0\x74\xf2\x7e\xd1\x4b\xda\x69\x75\x3c\x00\xef\x5d\x7b\x99\x10\x23\x41\xb8\xa4\x97\x83\xa3\xb1\x22\x2f\x5c\x30\x70\xcd\x81\x42\x39\x8d\x28\xbc\x77\x89\x91\x8a\x55\xe8\xa5\x33\xcf\x53\x6e\xd6\x67\x29\x18\x61\xcc\x5c\x15\xa3\x4c\x78\xa0\xd2\xa7\xe9\x27\x5e\x92\xc4\x89\x7e\xe4\x07\xc4\x38\x62\x41\xe8\xb9\x23\x11\x8f\xe4\x3b\xa3\x83\x37\x6f\x46\x7e\x12\xcf\x2d\xf4\x15\xa4\x3a\xaa\xb9\xa0\xf0\xa9\xf1\x15\x7d\x33\x44\x22\x3b\x31\xf9\x76\x4b\xf2\xbd\x74\x21\xba\x6f\x84\x01\x7f\xc0\xe3\x58\xa4\x22\x61\x8b\xf1\x23\x73\x62\x4e\xc6\x2c\x5c\xcc\x98\xf9\xdb\xd8\x0d\x52\xf1\xc0\x49\xd3\xba\x80\x39\x0f\x22\xd3\x91\x3b\xce\x0f\xae\xec\x73\x5d\x07\x6a\x4e\x6c\xe9\xa5\xf1\xdc\x1b\x3f\x32\x7f\x37\x27\xf8\x66\xf3\x76\xfd\xf2\x3b\x57\xe9\x73\x8d\xb5\xa2\x0c\xef\xc7\x92\x2b\xcd\x21\x31\xf9\x39\xdd\xad\xb1\x82\x93\xf2\x57\x6d\x1d\x6d\x28\x1d\xd5\x4d\xde\x55\x8e\xea\x0f\x7e\x2b\xd5\xa4\x3b\xd3\x58\xa9\xdc\x95\x5c\x9f\x27\x1e\xbb\x1e\x45\xd5\x52\x55\xd7\x49\xb1\x2e\x7f\x5f\x29\xe3\x39\x6b\x9e\x9a\x54\xe7\xb4\xb2\x7f\x65\x45\x65\x05\x2d\x4e\x50\xac\xd7\x83\x08\x26\xa4\x5a\x8f\x51\x01\xaf\xdb\x33\xad\xcf\x2b\x4c\x87\x83\x23\xff\x71\x40\x34\xd3\x38\x08\x93\x91\x88\x7c\x4a\x08\xa5\xb4\x28\x75\xb2\x17\x09\xf9\x7e\x6a\x55\xa5\xaa\x0c\x56\x23\x61\x32\x9b\x41\x22\x4c\xe6\xba\x87\xb9\x17\x89\x93\x20\x15\x5e\xe4\xc9\x8d\x76\xbc\x48\x95\x55\x4e\x50\x59\x22\x62\x79\x70\xc5\x44\x9c\x98\x59\xea\x25\xfb\x57\x5e\x24\xcc\x20\x72\xbd\x9b\x73\x9f\x18\x97\x49\xe0\xa2\x4b\xc9\xbf\x27\x3f\x7e\xf4\x56\x37\x63\xe9\xac\x44\xfc\x12\x5d\x9c\xe9\xc0\x27\xf7\xe4\x6c\x89\x24\x7c\xe9\xad\x7e\xfc\x48\xcc\xb9\x27\x98\xfe\x99\xce\x02\x5f\xe0\xef\xe9\xbf\x25\x55\x23\xd8\xff\x8f\x1f\x91\xa9\x90\x81\xe4\x2f\x37\x5e\x46\x72\xc1\x50\xfa\x3d\x31\x17\x89\x27\x1b\xd7\x69\xd0\x49\x1d\xba\x30\x4b\x3c\x1f\x3c\x5b\x8e\x0e\x64\x36\x8f\x89\xa0\x26\xdb\x65\xc4\x21\xd9\x3f\xff\xe9\x99\xec\x8d\x6d\xdb\x99\xc9\xde\xe0\xc5\x53\x75\xf1\x14\x2f\xce\x4d\xa6\x2e\xcf\x4d\xb6\xa7\x3d\x1b\xb2\xc2\xd2\xbe\x22\xa2\x40\xdb\x76\x01\xfc\xbd\xd5\x7b\xc2\x92\x98\xfc\x3d\x44\x80\x0d\x0b\x5a\x80\xf3\xdc\x4a\x4c\xe7\x39\x38\x4f\xe4\xbf\x4f\xc0\xc9\xe4\xbf\x99\xac\x22\xda\xb2\xa3\x84\x6c\x51\x48\xb6\xb4\x17\xa2\xd8\x1a\x62\x41\xda\x3f\x6a\x2f\xb1\x10\xb7\x18\x21\x6e\x55\x4e\x39\x6f\x6b\xf8\x5c\x4c\x27\x7d\xd8\x13\xd6\x05\x11\x70\x41\x30\x3a\x10\x99\x6b\xb6\x65\xbf\x76\xc9\x77\xfe\xde\x3a\x4c\xc1\xe1\xd6\x8a\x81\xe3\x58\x9d\x1d\xc2\x6e\x75\x82\x89\x49\xf8\xd1\xcf\x36\x32\x59\x81\x49\x52\x4c\x06\xa5\x73\xf1\x8a\x78\x5b\x60\xfc\x03\xc3\xe1\x6e\x41\x5d\xed\xe1\x01\xb4\x8f\x31\xfa\x62\x4b\x3e\x39\x87\x0b\xa9\xfa\xbf\xd9\xab\xb1\xc4\xad\x1a\x60\x3c\x31\xd9\x53\x0c\xc6\x60\x0c\x9d\x65\x0b\x39\x56\x47\x1e\x89\xb6\xa8\x1c\x3d\x37\x95\x63\xd9\xc3\xf0\x79\x68\x2d\xc8\x9f\x9f\x94\xec\xc0\xc3\x9b\x96\xa4\x2f\x8a\x82\xee\xee\x07\xf6\xf7\x53\x16\x44\xd6\xf7\x20\x0a\x84\x95\x6d\x91\x64\x8b\x92\x09\x2d\x0a\x88\xcc\xc3\x70\xbe\x57\xd6\x3b\x42\x18\x41\x85\xd4\x82\xc7\xc1\xa3\x20\x1a\x09\x8a\xff\x24\x7b\x08\xcc\x68\xd8\xb6\xb7\x77\x49\x7e\xa3\x56\x44\x92\x3f\xbd\xcf\x20\xfe\xf4\x3e\x53\x4b\xfe\xb4\xe5\x4f\xb9\xaf\x39\x0c\xe7\xb0\x1f\x50\x0b\x7f\xd9\xfb\x41\x41\xc4\x2c\x48\xe9\xee\xff\x0d\x00\x00\xff\xff\x76\x3a\xad\x97\x84\x6e\x01\x00"), + compressedContent: []byte("\x1f\x8b\x08\x00\x00\x00\x00\x00\x00\xff\xcc\xfd\x8b\x7a\xdb\xb8\x92\x28\x0a\xbf\x8a\xcd\xad\xd1\x02\x5a\x65\x46\xf2\x2d\x09\x65\x2c\xfd\xb9\x76\x9c\x4e\x9c\xc4\x76\x92\x4e\xbb\x3d\xd9\x20\x05\xda\xb4\x65\xd0\x81\x40\xdb\xb2\xc5\x79\xf6\xff\x43\x81\x57\x89\x54\xd2\x7b\x66\x9f\x73\x66\x7a\xc5\x14\x01\x14\x0a\x40\xa1\x6e\x28\x14\xd7\xc3\x44\x06\x3a\x8a\x25\x91\xf4\xc1\x49\xa6\x62\x6d\xaa\x55\x14\x68\x67\x98\x17\xac\x29\x22\x41\x81\xa6\x0f\x4a\xe8\x44\xc9\x35\xed\x72\x26\x41\xbb\x21\x53\xa0\xd3\xa2\xda\x94\x94\x55\x14\xd9\x04\x0d\x05\x68\x55\x14\x54\x7b\xcb\xc1\x11\x05\x92\xa6\x29\x2d\x41\x09\x22\x2a\xa0\xb6\x40\x94\xa0\xf4\x32\xa8\x95\xd0\x05\xd1\x60\xe1\x57\x3b\xd0\x24\xa9\x74\xb0\x0d\x49\xd9\x81\x58\x86\xf6\x4f\xfb\x4c\x88\x80\xa2\xd7\x6a\xb7\x11\xe1\x95\x6e\x77\x80\x97\xdd\x26\xcb\x00\xff\x07\x30\xe1\x24\x81\x2a\x2e\x55\x64\x12\x12\x54\x90\xd9\x85\xa0\x44\x86\x2f\xc3\xfc\xbf\x83\x5f\x40\x38\x2c\x60\x58\x45\x91\x93\xa8\x82\xe2\x63\x88\x4a\x14\x83\x65\xb0\xff\x8f\x61\x1d\x91\x00\x96\xf1\xae\x22\x1e\x90\xb8\x82\xf8\x13\x88\x4b\xc4\xa3\x65\xc8\xff\x6f\x8e\x25\x26\x11\x34\x8e\xa6\x3a\x9c\x98\x84\x95\xe1\x3c\x85\xb0\x1c\x4e\xbc\x0c\xfc\xff\x63\x23\x0c\x49\x0c\x6d\x63\xac\x0e\x72\xb6\xc0\xe6\x36\x19\x63\xd2\xe5\x23\xe9\x86\xc4\xbc\xf7\x4c\x3f\x44\x57\x5a\xdc\xda\x16\x50\x22\xb9\x55\x6f\x03\xa2\x68\x45\x44\xa5\xe1\x5d\xde\x10\xca\x21\x6f\x2f\x36\x85\xa4\xda\x98\x24\x95\xf6\x97\x65\x7b\x28\xe7\x71\x67\x19\x02\xf0\x05\x18\x84\x57\xc0\xdc\x54\xc1\x40\xb9\x46\xbb\x4d\x80\x20\x58\x06\x45\x82\x0a\x34\xbf\x0e\x0d\x4a\x32\x78\xdc\x0c\x0f\xa2\x46\x88\x24\xa2\xe9\x0d\x57\x6b\x21\x13\xa4\x5c\x4e\xbb\x34\x61\xac\x88\x29\x13\xec\x99\x52\x7c\x46\x24\x85\x84\xf5\x87\xc9\x9e\x1c\x26\xbd\x1e\x15\x27\xc9\x29\xd3\x44\xf5\x12\x3a\xcc\xf9\x7f\x4a\x61\xc2\xa6\x35\x48\x25\x1c\x5d\xc2\x11\xac\x3f\x14\x7b\xb2\xdb\x55\xae\x3f\x14\xbd\x1e\xd5\x27\xe2\x94\x29\x97\x83\x62\xe6\x55\x21\xfc\x26\x42\x9e\xe9\x73\x26\xe0\xde\x88\x16\x9a\x52\x18\x33\xb2\xd8\x41\xbe\x59\x4e\xe4\x69\x4a\x61\xd5\x40\x72\x80\x90\x64\xb8\x08\x0a\x9c\xf5\x87\x7c\x4f\x0c\x79\xaf\x47\x93\x13\x7e\xca\xf4\x09\x3f\xcd\x31\x48\x4e\xe4\x29\x53\x90\xa4\x14\xda\x87\xa5\x72\xa8\xf9\x4c\xe9\xde\x20\x9f\x2b\x5d\xce\x95\x3a\x49\x0a\xb8\xe2\x44\x9f\x32\x09\xe2\xd7\xf1\x35\xc0\x04\x02\x53\xcc\xec\x1e\x7d\x92\x9c\x82\x2a\xa6\x5e\xfd\x22\xa4\x8d\xc1\xb0\xbf\xc7\xc4\x50\x6c\x6c\x14\x80\xc4\x02\x20\x0a\x9d\xe5\x49\x5e\x35\xdc\x86\xc1\x4a\x62\x86\x5b\xa3\x8c\xff\xf6\xc2\x20\xd3\xe8\x71\x30\x0b\x54\x40\x4e\x1a\x21\x17\x04\x34\x9d\x44\x81\xc0\x11\x34\xd6\xb3\xbd\xab\xb2\x77\xb9\x21\x86\x39\x32\x7b\x49\xb7\x4b\x92\x02\x37\x3a\xcc\xf1\xe5\x39\x92\xbd\x84\x42\xc0\xfa\xc3\x60\x4f\x0c\x83\x5e\x8f\xf2\x93\xc0\xac\x73\x70\x8a\x55\x6d\x49\x92\x97\xf4\x84\xa1\xad\xa0\xa0\x01\x9e\x52\x78\xe8\x78\xfd\x94\x96\xea\xdf\x79\x95\xa2\x1f\x3a\xde\x00\xb8\x27\xc1\xf7\x54\x8a\xdb\xf4\x8a\x4d\xc9\x79\xa5\xfa\x99\x61\xbd\x39\x56\x8a\x75\x40\x33\x99\x61\x3b\xd4\x1b\x1b\x43\xaa\xd8\x39\x91\x27\xba\xbe\xc0\x45\xf3\xeb\x7a\xf3\x93\xd3\xa1\x74\xfd\xa1\x64\xd2\xf5\xa9\x72\xaf\x93\xe9\x39\x91\x2e\xaf\xb4\x34\xf5\x9e\xad\x64\x15\x27\xa7\x43\xe5\xfa\xdd\xae\x36\xbb\xd8\xec\x65\xd0\x4c\xbb\x3e\x15\x16\x1c\x2e\xa1\xcb\x41\xbb\x9c\x16\x70\xcf\x0c\xbf\xa6\xf0\x82\x11\xbd\x00\xd9\x70\xfb\x1c\x76\x52\x85\xdd\xed\x8a\x7a\x07\x20\x98\x70\x7d\x9a\xd8\x6e\x6e\xcb\x6e\x40\xd4\xbb\x4a\x4c\x57\xd1\x52\x3f\x46\x38\x94\xcb\xbb\xd8\x53\xb7\x9b\x34\x75\x07\x09\x4b\x5c\x9f\x72\xdb\xe9\x5d\xbd\x53\x48\xea\x1d\x73\xd3\x71\xd2\xd0\xb1\x91\x2a\x79\xd7\x41\x73\xd7\xdd\x2e\x6f\xef\x1f\x38\xe3\xae\x4f\x03\x8b\xc5\xe5\x32\x16\xc0\xeb\x98\x04\xb4\xce\xce\x34\x94\x02\xfc\x8c\x18\xa2\x70\xa7\xb1\xd2\xcd\x5c\x76\x9f\x68\xc3\xc1\x35\x51\x94\xa6\xf8\xdf\xb0\x02\x4a\xfc\x12\x28\xcb\x47\x66\xa6\x76\x85\x30\x35\x63\x6c\xa6\x47\x7d\xcf\x3c\xdc\xea\xd1\xc6\xc0\x1b\x60\x0f\x4b\xac\xb7\xc2\xf3\x5a\x8a\x82\x58\x4e\xe3\x89\x70\x27\xf1\x19\x91\x3d\xc7\x5b\xdb\x8b\xa4\x16\x4a\xf2\xc9\xf4\xdf\x0e\x05\x55\xdd\x73\x87\x66\x17\xe8\x73\x15\xdf\xae\xbd\x52\x2a\x56\xc4\x39\xd7\xfa\x7a\xea\x3d\x7a\x74\x16\xe9\xf3\xc4\x77\x83\xf8\xea\x91\x98\x5c\x3d\x0a\x62\x25\x1e\xf9\x93\xd8\x7f\x34\x70\xfb\x6e\xff\xd1\x79\x24\xf5\xf4\x91\xd3\x93\x3d\xc7\xbd\x1a\x3b\x15\xf1\xfc\x6a\x81\x67\x82\xd9\x18\x90\xb0\x23\x5c\xf5\x3e\x08\x3a\x34\xbc\x45\x33\xe1\x5e\xc7\xd7\x84\xd2\xa1\x29\xd3\xb8\x6c\x3e\x96\x57\xf8\x5b\x01\xf5\xa8\xdc\x14\x51\x48\x06\xfd\xfe\x9e\xa6\x39\x7f\xb5\x8b\x7f\x8f\xfd\x52\x58\xef\x0f\xa3\x90\x48\xc6\x98\xca\x6a\xd8\x37\x4e\xec\x5f\x88\x40\x3b\xeb\x4c\xcf\xae\x45\x1c\xae\xc9\xf9\x5c\x26\x93\x89\xd1\x19\x8a\xa7\xbc\x89\x93\x77\xec\xb0\xa2\x7a\xb7\x7b\x48\x76\x28\xac\x0f\x0a\x5e\x98\xac\x45\x72\x4d\xba\x9d\xbd\x7e\xb7\x4b\x24\x7b\x81\xd4\xa1\xcc\x5f\x83\x88\xa4\x51\x48\xd6\x8f\x88\x44\x69\x65\xfe\xd1\xbd\x81\x19\x5e\x86\xd5\x60\x98\xa3\x87\xbc\xe5\x82\x4d\xc9\x2b\x0a\x07\x4b\x3a\x44\x56\xeb\x55\xc6\xc9\xcb\xc5\xdb\xcf\x59\x50\xe3\xe8\xf2\xe9\xc1\x99\x18\xf5\x3d\xb9\xa7\x90\xac\xcc\x5c\xac\x4b\xb7\x93\x95\x13\xcd\xf6\x0d\xa7\x33\x1b\x87\xd2\x91\xf6\xb2\x17\x3e\x28\xd7\xc7\x17\xe6\x57\x00\xca\x0d\xac\x10\x30\x7c\x12\x95\x97\x6e\x77\xbd\xde\xd8\x72\x4f\xab\xc6\x94\x94\x3d\x9f\x1b\x68\xa3\x81\xa7\x5c\xdf\x20\xd0\xb7\x5a\xd7\xcb\x96\x71\xda\x51\xd1\xbd\x7e\x4a\xe1\x5d\xab\xbe\x93\x55\x1a\xb4\xef\x82\xfe\xde\x7e\x2e\xfa\x5a\x6b\xb0\xd6\x2a\x76\x97\xda\xe2\x62\x24\x7b\xfd\xd1\xad\xf6\xf4\xe8\x52\x7b\x33\x6d\x54\x85\x63\xd6\x2f\x57\xe3\xbe\x26\xbe\x0a\xd1\x55\x94\x7f\xaf\xcb\xe7\xbc\x06\x04\x9e\xae\xd4\xfa\x50\x31\x28\x64\xf9\xfa\x47\x15\xad\x87\xb4\xa0\x40\x81\x14\x68\x55\x48\x79\x22\x4e\xeb\x05\x2a\xd3\x2d\x4d\x41\x3e\x08\x9c\xfc\xe7\x6c\x4a\xde\x54\x28\xe9\x8d\x05\x6f\xe8\x68\xaa\x55\x24\xcf\x2a\x64\x5f\xd0\x51\x4f\x65\xa4\xe3\xe7\xaf\xd4\xd0\x22\x74\x6e\x69\x20\x23\x80\x61\x45\xb5\xa9\x08\x55\xe4\xda\x65\xd5\x1a\x3e\xaf\xdb\x88\x41\xf6\x0c\xbb\xfa\x47\x85\xbf\xa6\xac\xd9\xb9\xe4\x4c\xb9\xc1\x39\x57\x2f\xe2\xb1\x78\xa6\x49\x42\x87\x7c\x6f\x67\x67\xf3\xe9\xee\x7c\xbe\xb3\xbb\x35\x78\xba\xc7\x47\x24\x53\xe9\x3e\x58\xa5\x8e\x82\x51\xf3\xbc\xfa\xdb\x9e\x3a\x49\x7a\x03\x5b\xc8\x36\x69\x5a\x30\xa6\x8b\x38\x92\xc4\x71\x9a\x28\xac\x44\xf3\xe4\x14\x6a\x6a\x98\xd5\x76\x0b\x04\x0d\xe3\x08\x96\xf0\x4c\x7a\x3d\x08\xea\xb8\x06\xf3\x39\xe1\x3d\xdb\xc0\x20\x09\x06\x3d\x4e\xa9\x91\xa7\xc8\x21\x79\x81\x99\xae\x60\x36\xfc\x47\x4a\x78\x8e\x96\xb6\x68\xe9\x5f\x46\x4b\x17\x68\x59\xd5\xdb\xa0\x66\xf6\x5e\x29\xcf\x90\x98\x3e\xae\xd4\xb0\x72\x74\x8c\x0a\x9f\xa1\x92\x30\x54\xe2\x79\x1d\x15\x81\x2b\xb9\xbb\xb5\xd9\x9f\xcf\x77\x1e\x6f\x6d\x6f\xed\xf1\xf9\xdc\xe8\xb3\x27\x1b\x1b\xe2\xd4\xa8\xae\x39\x16\xc9\x02\x16\xf0\xbe\x8d\x16\x95\x3b\xbd\x9e\x44\x86\xc7\xa7\x14\xbe\xb6\xd7\xc2\xa9\xc5\x4a\x6f\x1b\x06\xd3\xa8\x9d\xff\x02\x11\x5b\x9d\x36\x57\xda\x8d\x5a\x9b\xd4\x89\x42\x53\xb3\x3d\x93\xfa\xa8\x93\xf9\x9c\x98\xea\x1b\x1b\xfa\xb4\x27\x2c\x49\x08\x5a\x88\xa0\x7e\x9a\xcb\xa2\x6c\xfa\x3f\xaf\xb0\x60\xff\x67\x31\x59\x5f\x40\x65\x90\x16\x38\x51\xf8\xd2\x32\xbb\x1b\x83\x3d\xe5\x46\x72\x2c\xee\x3e\x84\x76\x8a\xbf\xb5\xad\x43\x9f\xb1\x85\xaa\x9f\x5a\x99\x4c\x6e\xf3\x14\x43\x34\xf2\x6d\xc2\xa7\x7a\xbf\x68\xcf\x8a\xb2\x8d\xbc\x7a\x4a\xe1\xcf\x25\x90\x76\xaa\x0a\x43\x24\x0a\x89\xde\x1b\xe4\xfc\xb2\x53\x61\x8d\x7d\x40\xa5\x7e\x63\xb0\x67\xa6\xa5\xc4\x14\xf5\x9f\x5c\x97\x17\x14\x44\x8f\xe9\xba\x06\x8f\x0b\xf5\xfb\x4a\x8e\x09\x7f\xb4\x4a\x4e\xb9\xb1\x42\x75\x94\xbf\xa1\x09\xfc\x57\x7b\xeb\x47\xab\x5a\x3f\x52\xf3\x3e\x16\xbf\xe7\xfa\xdc\xbd\x8e\x6f\xdb\xd5\xd7\xff\x90\xad\x52\x57\xfd\x87\x1c\x96\x8b\xc8\xe4\xe8\x90\x0c\x06\xd4\xeb\xef\xe9\x6e\x57\xee\xf5\xe7\x73\x6d\xf4\xad\xfe\x9e\x1c\xe9\x9e\xf4\xb4\xd5\xc2\xb1\x47\xae\xb9\xdc\xb4\xf3\x23\x25\xc3\x57\x81\x88\x26\xa0\xb2\x1f\xe1\x24\x8e\x15\xe8\xec\x97\x8a\x13\x39\x06\x91\xfd\x9a\xc4\x67\xad\x72\xa6\xdb\x5d\x35\xea\xf9\x7c\x55\xe9\x3a\x63\x39\x6f\x4b\x24\xfb\x99\xf1\x95\x13\x8e\xe1\xf8\x3d\xbe\xc7\x92\xfc\x77\x64\xec\xe9\x6e\x37\xda\xe3\xd9\xd6\x8b\x59\x52\xdd\x73\x8a\x0e\x03\x26\x4f\xa2\x5e\xef\x94\x31\x96\x9c\xa8\x5e\xef\xb4\xdb\x25\x03\x33\x83\xf1\x88\xe8\x5e\x0f\x04\x1b\x18\xc1\xd5\xeb\x01\xf2\x67\xc6\xc8\xee\xd6\xf6\x93\x27\xdd\x98\x8e\x16\x1a\x7a\x03\x5a\xb0\xc4\xef\x24\x18\x29\x6f\x63\x80\xba\x77\x4a\x81\xcb\x76\xa6\xa6\xf6\x72\x06\x3d\xaa\x77\xa1\xeb\xa8\xd2\x91\xd9\xfc\xda\x9d\x26\xfe\x54\x2b\xa2\x60\x93\x52\x3a\x52\xbd\x4d\x6f\x63\xe0\x61\xd1\x89\x3a\xa5\x74\xe4\xfc\x6d\xf4\x6f\x66\x7e\x8d\x36\x36\x3d\xd5\x1b\x98\x0a\x1b\x46\xeb\x0b\x56\xa0\xb1\xd0\x9b\xa1\xa1\x94\x42\x2c\x1b\x79\xdb\x50\xee\x15\x8c\x4d\xf6\x7a\x05\x11\x56\x61\x48\x6a\x37\xf2\xf6\x13\xc3\xcd\x4a\xcb\x43\xa6\xc5\x03\x85\xb0\x09\xa3\xca\x7e\x1f\x96\xb3\x33\x54\x79\x47\x09\x5b\x40\x76\x63\xfb\x89\x65\x9e\xfd\xf9\x5c\xee\xb1\x84\xfa\x4a\xf0\xcb\xa1\x60\xf2\x37\xd1\x4b\xf2\xfe\xee\x89\xb2\xab\xe1\x37\x0f\xca\x8e\xa1\xdf\x38\x36\xd1\x34\xb6\xed\x27\xff\x16\xf3\xb9\xf8\xf7\xce\x63\x63\xb4\xec\xee\xd8\x5f\x8f\xfb\xa8\x13\x8a\xbd\xa7\x8f\xe7\xf3\x41\x7f\x73\x4f\x64\xe8\x68\x36\xd8\xfd\x4d\xf7\xc4\xc6\x93\xc7\xa9\x98\x4c\xc5\x5a\xf1\x62\x67\x67\x58\x7f\xb1\xfd\xa4\x44\x5a\x82\x46\x55\x48\x32\xf2\xb3\x8d\x90\x54\x38\xa2\xa2\x10\x30\xbe\xd7\x1f\xe5\xbb\xc1\xe3\xbd\x82\xc3\xaa\xbd\x20\xdb\x11\xd1\xc2\x8e\xe8\xf5\xe8\x10\xe9\x3f\x1a\x11\xc1\x06\xa0\xad\xe2\xb6\x44\xff\x11\xed\x76\x4d\xe5\x92\xe2\x79\x4e\xec\xcd\x0c\xca\x39\x73\x86\xd2\xe5\x5f\x8c\x15\xdb\x63\xce\x95\x43\x41\xba\x5c\x65\x3f\x23\x87\x0e\xb5\x9a\xe5\xc4\x78\xa1\xc9\xa1\x38\x7b\x75\x77\x8d\xbe\x7d\x9a\x06\x5c\x07\xe7\x15\x25\xff\x40\xa7\x86\xe5\xde\xc8\x76\x9e\x9b\x4c\x26\x86\x8b\xb8\x57\x59\xd3\xd5\xfe\x44\x94\x2b\xc0\x59\xdf\xa8\x67\x10\xb1\x8a\x24\x83\x98\x6d\x0c\x86\xbc\xd7\xdb\x93\xdd\x2e\x8a\x1d\x71\x27\x02\x12\x18\x1d\x31\x5e\xaf\xd6\x1c\x96\x00\x43\x26\x0a\xff\x29\xf8\x99\x26\x1d\xd2\x61\x7f\x2f\xcc\x26\x7e\xca\xc4\x49\x78\x3a\xf4\x4f\x36\x36\xc2\x53\x36\x1d\x5d\x68\x32\xa5\xde\x81\x4e\x93\xdc\x39\xf4\x25\x01\x71\xd2\x3f\x05\x61\x57\x15\x38\x9c\x11\x9f\x52\x0a\x71\xb5\xd3\x42\x0b\x2b\x5f\xb1\x08\x32\xb7\x55\xc5\x8f\x92\x80\x04\x9e\x2f\x47\x60\x76\x56\xde\x4e\x89\xeb\x09\x47\xad\xaa\x7a\x3e\x13\x85\x24\xe8\xf5\xfe\xcd\x92\x62\xdf\x0e\x4b\xc7\x1f\x57\x67\xc9\x95\x90\x7a\x9a\x0f\x72\x0b\x72\x67\xbd\x32\x83\x54\x85\xaa\x53\xd4\x3c\x51\xa7\x43\xa3\x48\xaa\x53\x26\xcc\x60\x05\x0e\x36\xf7\x6c\xda\xe1\x4a\x28\xab\x2f\x75\xb1\x79\x0a\x01\x9c\x11\x4d\x29\x4d\xa9\x59\xfd\xc9\x6a\xde\xa1\xf3\x35\xad\xae\x65\x50\x5b\x2f\x59\xe8\x64\x51\xbe\xac\x02\x77\xf6\x7a\x94\xed\xd9\x5c\xa5\xc8\x14\x4f\x0e\x91\x5d\x0c\x4a\xeb\x80\xf3\x81\x2c\xd6\xa7\x14\xaa\x0b\x13\x40\x45\x1b\x19\x2f\xb3\xa1\xd2\x8d\xdb\x87\x71\x6e\x0c\xb7\x99\x72\xa6\xda\x00\x44\x59\xad\xb0\x4c\x3b\x4b\xf5\xb6\x20\xf4\x24\x9c\xe5\x6e\xe1\xf3\x55\x5d\x6f\xa3\x85\x7d\xee\xc9\x34\x43\xf4\xaa\xad\xb6\xed\xc8\x88\x9d\x94\xc2\xd9\x0a\xe1\x92\xd5\x03\x8d\x35\xaf\x65\xb3\xe3\x76\xb1\x32\x88\xd3\x76\xdf\xeb\x72\x65\x48\x4e\x57\x79\x4c\x9b\x1a\x00\xc7\x26\xbc\xb1\x49\xe5\xcc\x6d\xa1\x11\x04\xa7\x48\x81\x33\xc9\x48\xd0\xd2\xb6\x72\xc2\xb6\xd4\x1a\x22\xec\x36\x6e\x6d\x0a\xf1\xaa\xc6\x10\x9f\x36\xf1\xd9\x0a\xff\xbc\x33\xaf\xde\x1e\x7d\x38\x70\xaf\xb9\x9a\x0a\x74\xbd\x2e\xf2\xd0\xfd\x84\xcc\xc8\x55\x00\xce\xf1\x79\x34\x5d\x8b\xa6\x6b\x32\xd6\x6b\x37\x7c\x12\x8d\xd7\x4c\xcb\xf5\x35\xa7\x27\xdd\x2b\x31\x9d\xf2\x33\x01\x17\xd2\xc0\xa0\xc8\x75\x6f\x5b\xc9\x01\xbb\x3d\x90\xd6\xd3\x5b\x92\xe3\x5d\x56\x6b\x7a\x1b\x21\x0a\x6e\x87\x3e\x04\x7c\x2a\xd6\xb6\xbc\xcc\x71\xe8\xc7\xf1\x44\xf0\x8a\xdf\x50\x8d\x5e\x26\x44\x51\xef\x85\x24\x0e\x5f\x7b\xfe\xe1\xc3\x3b\x07\x8c\xb6\x66\x5a\x6d\xe6\xad\x64\x72\xe5\x0b\x55\x7a\xef\xd4\x08\xab\xcb\xb5\xfd\x83\x63\x53\xdd\xdb\xd8\x1c\x6c\x3f\xde\x7e\xb2\xb5\xbb\xfd\x78\x4f\x75\xbb\x6a\xaf\xfc\xdd\xed\x92\xfe\x1c\xd5\x9c\xbc\xab\xf5\x68\xfa\x3a\x92\x91\x36\xb3\x35\x9f\xab\xff\x18\x2c\x42\xc3\x6a\x16\x85\xed\x05\x14\x5a\xf0\x7e\xfd\xee\xc3\xb3\xe3\x12\xf1\xdd\xbc\xd5\xa2\xbb\x28\x6f\xa5\xd6\x22\x39\xd5\x5c\x06\xe6\xe5\x11\x56\xc2\x92\x9e\xe3\xe4\x20\x8f\x8e\x0f\xf7\x0f\x7e\x2f\x61\x3e\xf5\x2a\x02\x2f\x1f\x8d\x74\x03\x5b\xdf\xbc\x2c\xeb\xee\xe4\x75\x5f\x26\xc4\x2e\xa8\x7d\xff\x38\x7f\x8f\x1c\xdc\x8d\xa6\x39\x27\x1f\x5d\x4a\xeb\xd4\x84\xb3\xbc\xff\x77\xfb\x47\x95\x11\x3d\xf9\x79\xcb\x67\x32\x6b\x2a\xd7\x9e\x1d\x1e\x3e\xfb\x56\x36\x1e\xf4\xbd\xdc\xf0\x1b\x37\xfa\x9a\x55\xe9\x61\x9e\xcf\xd7\x89\xb6\xde\xb9\x5c\x1e\x65\x40\x3f\x3c\x7f\xfb\xea\xc5\xf1\xda\x6d\xa4\xcf\xd7\xf8\x5a\x18\x89\xc9\x78\x4d\xf2\x2b\x31\x5e\xfb\xdf\x4e\x4f\xf7\x9c\xff\x8d\x1d\x5a\x91\x70\x97\x21\x75\xa2\xcb\xe3\xc0\x73\xc3\xf3\x47\xc2\xc3\xed\x70\x16\x98\x7d\x86\x6e\x59\x8b\xe2\xc0\xb3\x0a\xa7\x74\x05\xca\x85\xc5\x71\x2e\x20\x53\x8e\x30\x0a\x89\x2a\x2c\xe4\xa4\x56\x6d\xed\xdd\x87\x83\xdf\x5f\x1d\xae\x71\x84\xb5\x76\x20\xc4\x78\x0d\x85\xca\x9a\xd3\x4b\x7a\xce\x9a\x9f\xe8\xb5\x58\x4e\x66\x6b\x53\x21\xd6\x9c\x5e\x0e\xa6\xe7\xac\x09\xa9\x55\x24\xa6\xd8\x41\x65\x34\x49\xcb\x68\xae\x03\x48\x6a\xa3\xd9\xf4\x7e\x3a\xcd\x3f\x19\xa0\x9d\xed\x62\x4a\x39\x2b\xad\xf3\xc0\x2e\x0f\x0e\xfc\x9c\x4f\x3f\xdc\xca\x8f\x2a\xbe\x16\x4a\xcf\x8c\xae\xf4\x50\xc1\x37\x38\xb5\x42\x16\x91\xa5\x55\x76\x74\x16\x40\x90\x61\xcc\xd9\x39\xb9\x27\xf6\x17\x94\x4e\xb8\x97\x09\xf9\xaa\x49\x39\xa4\x2d\x2f\xef\x3f\x62\xd2\x0d\x21\x66\xd2\x3d\x83\x90\xf5\x87\xe1\x5e\x9c\xab\xbb\xa1\x51\xe3\x11\x81\xf8\x24\x3c\xcd\x96\xa7\xde\xbd\x18\x46\x2c\x22\xa6\xb3\x4a\x4f\x51\xde\xcb\xb6\x57\xa2\xbf\x30\xd7\xf8\xfa\x1c\x5b\x1a\x26\x21\xb2\x16\x3b\x05\x5e\x3e\xeb\xc0\xd4\x60\x35\x9c\xba\xfe\x70\xca\xa6\xae\x9f\x21\x33\xb5\x4e\xdd\x28\x24\x0b\xa8\xf8\x0c\x01\x82\x5f\x20\x63\x66\x27\x30\x23\x37\x0a\x60\xd6\x85\xb7\xc0\xc8\xa5\xcb\x73\x3e\x6d\x6b\xf4\x2b\xfb\x5d\x9a\x91\x55\x62\x54\x1a\x14\x26\xf5\x93\x23\xf5\x4c\x73\xb4\xdc\x1c\x4f\xd4\xb3\x59\x0c\xea\x8b\x78\x1d\x18\x31\x85\x8b\x88\xa7\xf0\x81\xcb\x2b\x73\xaa\x49\x42\x2b\x07\x5f\xcf\xaa\xf1\x41\x33\xd2\x09\xa0\x40\xa3\x21\x5a\xc8\x46\x6c\x94\xad\x5f\x2c\x1c\x70\xe4\x22\xed\xd5\xdd\xb5\x08\x74\x24\xcf\x8c\x10\x2b\x84\x57\x79\x80\x27\x0b\xd7\xfd\xf2\x91\x97\x74\x3b\x68\x38\x74\xca\x23\xa7\x25\xc1\xd5\xf7\xea\x4b\x20\x5d\x6e\xe0\xb8\x7c\x98\xc9\xb5\x4c\x50\x65\xc2\x22\xe3\xfe\x35\x26\xbc\xde\x5f\x64\xe0\x6e\x80\x30\x82\x9c\x29\x67\x1c\x36\xdf\xba\x59\xb5\x43\x59\x9c\x33\x15\x6c\xb4\x80\x30\x46\x08\xe3\x6e\x77\xb9\x56\x05\x57\x81\xb5\x44\x53\xad\xad\xb2\x56\x88\xb5\xc2\x6e\xf7\x95\xa9\x75\x06\xca\x3d\x2b\xb7\x43\x51\xeb\x1c\x6b\x9d\x37\xc1\x2a\xc4\x4d\x05\x40\x85\x04\x5f\xb5\x3b\xff\xd6\x4b\xc7\x61\xb9\x08\x55\xaf\x80\xd8\xd3\x18\x05\x64\x08\xd0\x74\x8c\x11\x29\x27\xe2\xb4\xed\x98\xf0\xa8\x55\x65\x41\x25\xc9\xca\xe3\x28\x9c\x11\x54\x5e\xc0\xb0\x43\x90\xb4\xe7\x38\x55\x35\xe6\x42\x36\x1f\x33\x1d\xd4\xdf\x9b\xfe\xf6\x57\x39\x5a\x4e\xe4\x29\xb3\xfd\xe8\x4c\xc1\x7e\x29\x99\x01\x9e\x4c\x26\x95\xee\xde\x55\xc0\x3e\x74\xbc\x3e\x70\xa3\x91\x17\xc5\xc7\xf5\xe2\xc1\x42\xf1\x7d\xbd\x78\x13\x7c\x4f\x42\xe0\x99\x3e\xac\x09\xf0\x7d\x85\x09\xb0\x85\xb5\xc7\x68\x55\xc0\x87\x15\x15\xb7\x2b\x15\x71\x24\x3f\x64\xf5\x74\xef\x39\x22\x61\x4d\x46\x1c\x82\xf0\x7e\xc8\x5e\x2f\xb3\x45\x70\x96\xcf\xbd\x93\xd3\x34\xe7\xa8\x6f\x71\x56\x2a\xf1\x26\x6f\xaa\xdc\xe1\x5e\x92\x2a\x4b\x90\xe4\x9d\x24\xcf\xb3\xad\x5d\xd9\xdc\xaf\x33\x24\xa5\x7b\x6e\x8d\x31\x45\xe1\x2d\x9e\x2d\xe0\x51\x49\x6d\x34\xd5\x75\x59\x00\xff\xda\x96\x02\x76\x73\x6c\x6d\x4e\x1c\xe2\x7b\xc9\xd6\x07\xf0\x55\xb2\x93\xd3\x72\xa4\x6f\x73\x9b\xf9\xab\xcc\xc2\x60\x28\xac\xbf\xcf\x82\x65\x4c\x8b\xfe\x50\xb2\xaf\xd2\x9d\x9e\x47\xa1\x26\x74\x48\x3f\x9b\x06\x43\x84\x55\x59\xb5\xcf\x38\x5e\xf4\xb0\x29\x37\xf7\x14\x48\xb3\x0d\xdd\x8e\xd9\x19\x7d\x7b\xee\x3e\x30\x7f\x8a\x7a\x67\xdd\xae\x72\xcf\x90\x6b\xc9\x21\x55\xee\x19\x33\x3f\x23\xe4\xce\x66\xcf\xd9\xf1\x19\x80\x58\xe0\x13\x03\xce\x48\xab\xbc\x26\x7a\xa3\x0c\xf2\x18\x54\x99\xf3\xf2\x9b\x38\x1a\x63\xd5\x00\xfb\xf7\x6b\xb3\x63\x80\x49\xc0\xf5\x4a\x29\x0a\x82\x1d\x8b\x53\x86\xa4\x72\xcf\xeb\x1b\x38\xeb\x3e\xc4\xee\xcf\xf3\x79\xa0\xd6\x11\x66\x30\x31\x64\x87\x8e\xeb\xbe\x37\x30\x06\xa8\xa9\x0a\x91\xa7\xdc\xb3\x14\xf2\xb6\xe3\xd4\xd2\xee\x97\xda\x22\x56\xcd\xc1\xea\x22\xaa\x7c\xfa\xa4\xb8\x5d\xfb\xf3\xfd\xbb\x37\x5a\x5f\x1f\x8a\x1f\x89\x98\xea\xe1\x7a\x9d\xa0\xcd\x54\x7d\x0a\x4a\x75\x67\x28\x5d\x3e\x1e\xbf\xba\x11\x52\xbf\x8b\xa6\x5a\x48\xa1\x88\x73\xad\xe2\x33\x25\xa6\x53\xa7\x26\x99\x72\xc6\xf5\x22\xbe\xba\x4e\x34\xf7\x27\xa2\xdb\x35\x54\xe9\x72\xf2\xe0\xbf\xf6\xa4\x3b\x89\xf9\x58\x8c\xc1\xff\xdd\x93\xae\x8e\x35\x9f\x60\x88\x4a\x4a\x24\x24\xe8\x02\x5b\xea\x47\x28\x15\xab\x4a\x27\xf4\x41\x11\xb3\xdb\x23\x0c\x6d\x69\x6a\xa1\xa3\x2b\x11\x27\x7a\xb9\x8d\x6a\x6f\x63\xd0\x5a\x68\xd0\xe4\xb6\x23\x82\x49\x78\x08\xf6\x3d\xe1\x2a\x31\xbd\x8e\xe5\x54\x7c\x3e\x7c\x07\xfe\xa5\xf7\xe0\xbf\xf5\x84\x3b\xd5\x5c\x27\x53\x08\x44\xf1\x7c\x2c\xee\x74\x0a\x7e\xc7\xab\xce\x92\xe5\x01\x71\x62\x0f\xc3\xcb\xa3\xf0\xd2\xef\x2a\xb3\x83\x42\xe7\x6f\xf5\xb7\x74\x28\xac\x3e\xb7\x2c\x3d\x9d\x8e\xb7\xe6\x20\x01\xf6\xf7\x78\xae\xa2\x24\x99\x93\x3c\x92\x67\xa4\x0f\x9c\x42\x54\x7b\xc5\x7b\x9b\x74\xa8\xd8\x2d\x99\xf2\x6a\x5c\x7d\xc9\xc4\x2f\x34\xf9\x14\x10\x49\x47\x51\xcf\x01\xb4\x83\xb9\x17\xd1\x14\x14\x4d\xcb\x43\x4f\x22\xdc\x33\xa1\x9f\x4d\x26\x87\xd9\xbc\xbc\x11\x7c\x2c\xd4\x94\x50\x0a\xfe\xcb\xca\x7c\x65\x7c\x43\x58\xe5\xc2\x4e\xd2\xde\x66\xbf\x3f\x9f\x6f\xf5\xfb\x7b\x2c\x7f\x45\x0b\x47\xbc\x1f\x8f\x67\x4c\x16\xed\xcd\x84\xc2\xb1\x24\x7f\x04\x44\xd3\xec\x50\x84\x29\xa2\xab\x8a\x68\x42\x47\xef\x24\x49\x5c\x4e\x3d\xd2\x0a\x60\x46\x7e\x0f\x30\xbc\x0b\x7d\x68\x44\x82\x70\xfd\x23\xa3\xa7\xa5\xd6\xf9\x2a\xdd\xf8\x5a\x48\x22\xdc\x20\x04\xe1\x06\xfb\xb0\xde\x5f\x76\x1b\x20\x5d\xfd\x15\x98\x5a\xfb\x06\xcc\x7a\xfb\xc9\xa7\xdf\x19\x6a\xd7\x1f\xda\x78\x3e\xe9\x4e\x85\xce\xb6\x9f\x9d\x29\xa2\x5d\x6e\xe3\xce\x8c\xce\x50\x41\x77\x76\x6d\x94\x51\xff\xc8\xf5\x41\xba\xc6\xb0\x7b\xa1\xc4\x58\x48\x1d\xf1\xc9\xd4\x28\x48\x7f\x80\xd9\xab\x6e\xf0\x92\x76\xbb\x44\xba\x19\xf5\x9b\x92\x97\x46\xcb\xc5\xe3\xc0\x2c\xc8\x42\xb8\xfe\xcb\x61\xa1\xac\x4c\x85\x1c\x13\x1d\x11\x4d\x47\xa4\x01\x1f\xe7\x45\x2c\xb5\x90\x7a\xc3\x60\xe0\x60\xc8\x21\x18\xd4\x3d\x7c\xaa\x6c\x15\xe9\x72\x3f\x56\x9a\xe0\xbd\x98\x9a\x7b\xae\xe2\xc7\x42\x81\xe7\x7b\xc2\xf5\x81\x37\xec\x05\xe1\x72\x23\x01\x0a\xcd\xf7\x4f\x63\x7a\x2a\xbc\x09\x33\x5c\xe1\x1c\xfb\x66\xc4\x92\x00\xe9\xfa\xdb\x20\xdd\xe0\x8d\xf9\xe7\x59\x6d\x1b\xdb\x7a\x95\x37\x16\xc9\x42\xc6\x7c\x5b\xf0\x8b\xd9\x2d\x33\x23\xb7\x12\xac\xaa\x3c\x52\x6e\x38\xe1\x67\x53\xcf\x48\x80\xb5\x3e\xa5\x43\xd4\xf1\xe7\xf3\x43\x92\x9d\x13\x46\xec\x21\x85\x98\x91\x80\x69\x82\x8a\xbe\xcb\x21\x64\x9c\x4c\x21\xa6\xe0\xb3\x06\x3e\x52\x0f\xb1\xf9\x24\xf3\xed\xfc\x09\xe3\x6f\x12\x97\x77\xbb\x84\x68\xa6\xe7\xf3\x87\x94\x9e\x88\x53\x96\xb8\x9c\x08\x0c\x4d\x33\x35\xd8\x9f\x92\x24\x95\x90\x03\x9d\x92\x08\xa6\x95\x41\x4d\x6d\x5f\x41\x16\x23\x18\x53\x08\x49\x6c\x2c\x0f\x30\x0a\x85\x22\x11\x04\xae\x0f\x09\x89\xcb\x33\xba\xfa\x5b\xf0\x47\x0f\xd7\xb1\xd2\x53\xcf\x4f\xbd\x07\x2b\x66\x3e\x49\x8c\x1a\xca\xfb\xf8\xb3\x32\x20\xc1\x1e\xce\xd0\x49\x6a\xe7\x28\x85\x84\x49\x37\x00\xce\xa4\x3b\x86\x80\x49\x57\x00\xda\xa3\x45\x38\xb3\x7b\xce\x9e\x9b\x1d\xf8\xbd\xf4\xb2\xaf\x55\x6f\x4b\x60\x89\x84\x87\x8e\xb7\x03\x7e\x03\xb9\x48\x97\xd7\xce\x77\xdd\xce\xe8\x96\x70\x10\xa8\x5a\x7a\x41\xb7\x1b\x8d\xee\xf0\x3a\x91\x72\x23\x50\xee\x85\x79\x7b\x8b\x2f\x82\x91\x72\x8d\x1c\x35\xaf\x0c\x29\x18\xda\xa1\x56\x19\xfa\xfd\x57\x95\x21\xe5\x9e\x91\x45\x5d\xa8\x45\xa1\x9e\x91\x8f\x12\xa4\x7b\x0e\x99\xce\xaa\xea\xd4\xf7\xc7\xea\xfb\x20\xa8\xc9\x5e\x7a\x0a\x26\x46\x9b\x2d\x15\xa3\xbf\x16\xd5\xd9\x2b\x53\x8e\xe2\x5d\xad\xd2\x63\xa5\x27\x21\x5e\xf0\x8e\x2b\x55\x0f\xe6\xae\x44\x86\x61\x6c\xa2\x56\x64\xbd\x0f\xb8\xcb\x8c\x46\x0e\xe6\x37\x9e\xe4\x66\xbf\x25\x35\x2a\xe6\x49\x72\x6a\x86\xe8\x84\x77\x0e\x70\x4f\x9c\x24\xa7\xf3\xf9\x43\xe4\x75\xe0\xc2\xeb\xd4\x6f\xb3\xa9\x72\x13\x67\x86\xa4\x2a\x0c\xc9\xdc\xbf\xa4\xdc\x4b\xe0\x8c\x84\x2c\x01\x9f\x09\x98\x11\x39\xfa\x24\x4f\xc2\x53\x57\x78\xf6\x6f\x58\x93\x53\xe5\x49\x8c\x3f\x54\x18\xe6\xfb\x83\x1a\x35\xf1\xba\xc2\x52\xa4\xd1\x9b\x26\x65\x5c\x28\xea\x73\xfa\x24\x39\x65\x24\x62\xdc\x6c\xdf\x18\xe3\x8b\x68\x05\x6f\x90\xa3\xd8\x8d\xd8\x39\x89\x20\x76\x23\xea\xc5\xee\x45\xf6\xe3\x82\x42\x4c\x0b\x07\x6c\x19\x7d\xac\xdc\xab\x61\xe0\xfa\xc3\x80\x05\xae\x4f\x71\xac\x66\xd7\x99\xd1\x66\x1d\x0f\x6b\xae\x5e\x44\x23\x9b\x13\x37\x06\x0d\x0f\xd7\x9e\x72\x25\xfc\xf0\x44\x6a\x89\x32\x82\x18\x42\xf0\x2b\xf7\x0d\x95\x19\xf2\x27\x79\x22\x4f\xbb\xdd\x43\xb2\x65\xab\x25\x6d\xeb\xbe\x56\x8b\xd5\xe5\x2a\xdf\x43\x1a\x38\x3b\x39\x85\x80\x21\x24\x57\x41\xc4\x88\x66\x7d\x58\x20\x75\x3b\xad\x53\xa1\x8f\xad\x58\x21\x55\xbe\x9f\xd3\x3f\x94\xc2\xb7\x52\x1c\x4c\x04\x57\x79\x33\x85\xce\xf2\xbc\x96\xed\xd3\x67\x11\xd8\xa7\x60\xc1\x3e\x2c\x94\xf9\x2c\x68\x9b\x96\x72\x94\x83\x30\xe6\xa2\x91\x78\x9c\x16\xb1\x78\xb9\x6e\x94\xe0\x5d\x98\xe4\x94\x14\xf3\xbd\x16\xa5\x14\x1e\x8c\xb6\x13\xa8\xc8\x17\x35\x5e\xc2\x73\xe3\x24\x85\x44\x36\x57\xb1\xe3\x27\x9c\xf1\xec\x0c\x8b\xd2\x4a\x44\xd0\x50\xed\xf5\xe7\x73\x8e\xba\x5a\x20\x88\x82\x01\xcd\x74\xf2\x40\x0d\x5b\x78\x49\x93\x1f\x07\x63\xc2\x69\x6e\x35\x46\x8a\x39\x89\x1c\x8b\x30\x92\x62\x5c\x3a\x26\xc7\x71\x80\x47\x80\xa3\xfc\xc1\xab\xb2\xe3\x58\xe5\x76\x1e\xbf\xbe\x16\x72\xfc\xe2\x3c\x9a\x8c\xcd\xb4\x37\x49\x4f\xbb\xcb\x84\x2b\xe3\xb1\x18\x96\x67\x75\x5c\x09\xa9\x0f\xe2\xb1\xc8\x0f\x41\x2d\x90\x43\x55\x3d\x0c\xa5\x0f\x29\x35\xba\xfa\x43\x8d\x8b\x84\xaa\xc9\x3c\x47\x87\x5f\x8d\x32\xab\xc7\x48\x3f\x09\x67\xec\x57\xd6\xff\x21\xe7\x0b\x7c\x28\x7a\x2c\x71\xfd\xf9\xbc\x0f\x59\x48\x62\x52\x06\x4b\xf6\xca\x60\x43\x64\x9d\x81\x17\xc0\xd8\x7b\xa6\xf0\xce\x94\xa7\x21\xf4\xb8\xd1\x41\x50\x05\x20\x99\x3c\x87\xe9\xff\x15\x04\x7f\x0d\xc5\xcd\x5f\x42\x11\xa9\xe2\x66\x05\x67\xdf\x86\x0b\x4f\xa2\xa0\xf0\xbd\x41\x8f\x28\xec\x9c\xd6\x16\x68\xa2\x16\xda\xec\x18\xa1\x02\x57\x9e\x82\xcb\x5c\x6c\xa7\x2d\x2c\x64\xa2\xc8\x89\x04\x75\xda\xa0\x58\x59\x93\x37\x3f\xc2\x55\xed\x7e\x9e\x0c\x06\xe8\x26\x28\xf9\x75\x46\x03\x09\x3a\x8a\xad\xd0\xf8\x0a\x38\x20\x9a\x20\x95\xd7\x1c\x11\xd6\xb9\x6a\x0b\x13\x59\x06\x07\x49\x13\xc0\xea\xf5\xc7\xf4\x17\x0e\x54\x6b\x00\x81\x37\x81\xac\xdf\x88\x4c\x7f\xe9\xc8\x75\x01\x2c\x04\x4d\x80\x17\xef\x48\x22\xe8\x5f\x38\x91\x5d\x02\x0e\x51\x13\xf8\xe5\x4b\x93\xe9\xc2\xb9\x6d\x08\x3e\x4c\xe1\x06\x26\x30\x86\x0e\x9c\xc3\x55\xad\x8b\xa5\xd2\xa6\x4e\x14\xf3\x41\xb3\x29\x08\x76\x03\x09\x9b\x00\x67\x46\x83\xec\x40\xc4\xce\x21\x66\x57\xf0\x84\x31\x46\x24\x0b\x69\xd3\x1d\x4d\x88\xdb\x6e\x69\x92\x38\x8b\xe9\x5b\x3c\x59\x4e\xdb\xa3\xfb\x8d\x3e\xc3\xfb\x4e\x45\x6b\xa2\x70\xb5\x62\x17\x3a\x7c\x50\xad\x0c\x67\x2b\xeb\x6e\xd6\xea\x5e\xaf\xac\xbb\x55\xad\xdb\x10\x6c\x5d\xa9\xba\x6d\xaa\x2a\x88\xbd\x87\x10\x5b\xe8\xb4\xc6\x06\x66\x15\x3e\xed\x18\x79\x77\xad\x1d\xc6\xe4\xc8\xb9\x76\x3c\xd9\xb2\xff\xcd\x24\xa0\x13\xab\x33\x9a\x91\x73\x05\x46\x41\x21\x9a\x49\x48\x98\x8a\x31\x04\x28\xc6\x9b\x78\xc2\xed\x00\xf7\x92\xd1\x2d\x91\x31\x24\x7b\x5b\xa3\x3b\xe5\x5d\x2a\xf8\x6e\x0c\x75\x3c\xb8\xf2\x66\xe4\x75\x7e\xa4\x98\x52\xea\x65\xb1\xff\x66\x39\x32\x0e\x72\xab\xe0\xae\x55\x93\xb9\x27\xe8\x48\xa2\xe8\x55\x4f\x29\x5c\xb6\xce\x59\x20\x0c\x19\xb8\x81\xa0\xc0\xcf\x3c\xe5\xf2\x33\xe0\xbe\xf9\xeb\xd7\x26\x03\xb9\x6e\x45\x7b\x7c\x48\x2b\x77\x0d\x0a\x4f\x3c\x47\xe7\x4b\x07\x12\xa6\x5d\x89\x41\xe2\x31\x9e\xcf\xf2\x4d\x67\x9d\x31\x91\x9b\x8c\xea\x44\x9c\xce\xe7\xc4\xfc\x61\x0f\x29\x1d\x9a\x55\x63\x8c\x89\x6e\xd7\x09\x26\x7c\x3a\x35\x3f\x92\xd1\x0b\x45\x02\x7b\xd5\x39\x30\xba\x27\x47\x8f\x9f\xad\x70\xc0\xaf\x44\x51\x49\x41\x02\x07\x92\x70\x33\x4b\xa6\x22\x3e\x97\xde\x96\xf2\xc8\x67\x41\x7b\x97\x27\xea\x74\x68\xfe\x61\x62\x24\x7a\xce\x9a\xd3\xd3\x5e\x25\xef\xc5\xa1\xaa\x9f\x32\x74\x72\x5f\x65\x11\x8f\x68\x6a\xb8\x97\x78\xe1\xe6\x92\x49\xf7\x8a\x50\x9a\x9d\xca\xf5\xab\xd5\x22\xe5\x06\x4a\x70\x8d\xde\x14\xa3\x32\xd8\x9b\x8e\x51\x48\xb6\xb1\x5a\xe5\x20\x4d\xba\x97\x68\x0f\x5e\x0c\x4d\x91\x70\x3b\x43\xba\x74\xe8\x9a\x8c\x12\x76\x92\x80\x70\x2f\x4e\xbd\x22\x68\xe8\x82\xe2\x35\xbd\xcb\xec\x6c\xf5\xe1\xc2\x4b\xe0\xda\x53\xb9\x7f\x9c\x04\xec\x50\x11\x01\xc6\xe0\x16\x93\xab\xef\xe2\x46\x48\xfd\xdd\xa8\x34\xdf\x95\x08\x19\x87\x20\x8d\x42\xb2\x55\xc5\xfa\x95\x22\xc6\x1a\x3d\x27\xd2\x3d\xa3\xa0\x40\xba\x63\x0a\xc1\xd0\x2e\xa0\x74\xc3\x51\x31\xac\x57\x13\x61\x54\xac\x83\x23\x22\xdd\x10\x30\x82\x60\xb1\x0c\xe3\x0a\x86\x81\xea\x76\x1d\x6e\xf6\x90\x1b\x74\xbb\x41\x83\x6b\x31\x98\x44\xc1\xa5\x03\x81\x22\x01\xa5\x60\x50\xc8\x7a\x1e\x56\xcf\x6a\x05\xc4\xac\x3f\x8c\xf7\xa2\x5c\x95\x8d\x7b\x3d\x1a\x9b\xca\x87\x8a\x0c\xcc\x20\x46\xd1\x49\x7c\xea\x99\x7f\xf0\xdc\xb5\x50\x70\x83\xca\x21\x92\x5a\x3a\xc7\x44\x13\xae\xea\x2e\x1c\x1a\x36\x65\x16\x62\x74\xa4\xd0\xeb\xea\x65\xfb\x5b\x8c\xf6\x6d\x73\x7c\x65\x89\x77\x74\x51\xd4\xd9\xb6\x2f\x0e\xb2\x17\xc4\xb9\xe1\x93\x44\xe0\x16\x98\xcf\x9d\xe0\x5c\x04\x97\xa8\xad\x9a\x9f\xf2\x44\x9c\xae\x33\x96\xa0\x47\x0a\xfd\x17\xd5\xa3\xae\xa3\x05\x22\x9c\xea\xd9\x44\xb4\xde\x3a\x2a\xdb\x5d\xa8\x05\x35\xcc\xd6\xac\xdc\x22\x18\x8a\x11\x3a\xb2\x9e\x69\xad\x22\x3f\xd1\x82\xd8\xb4\x06\xae\x12\x57\xf1\x8d\xa8\xbc\xae\xe2\x73\xf0\x53\xb8\x60\x94\xe5\x10\x38\x13\x6e\x3c\xe4\x0b\x7d\x1c\x1c\x91\x04\x34\x66\x2f\x58\xec\xc7\x16\x55\xfb\xda\x5f\xdc\xaf\x86\x74\x5f\x4f\x71\xbf\xe1\x13\xf2\x8e\xba\x01\xbe\x70\x5f\xc6\x18\xd7\x66\xa3\x71\x1b\x95\x68\xff\x75\x7f\xb8\x1d\xc6\x18\x47\x53\xda\xfd\xc1\xf8\x30\x88\xa5\x8e\x64\x22\xd2\x1c\xab\x3a\x59\x26\x46\x3f\x08\xd8\x4b\xc3\x6a\x78\xa3\x4f\x3c\x81\x00\x6e\x55\xb7\xfb\x70\xcd\xa7\xd3\xe8\x46\x78\x2a\x26\x9c\xee\x6d\xa6\x14\xf0\xe6\x52\x60\x4f\x2b\xda\xc1\xdb\x6a\xb9\x6e\xa9\xd5\xec\xe1\x36\x92\xe3\xf8\xb6\xc9\x65\xef\xd8\x53\xc6\x0f\xc8\x17\x5c\x6b\xfb\x14\x01\x13\x0f\x29\x38\x19\x12\x0e\x3c\x9c\x09\xed\x55\xf4\x86\x5b\xc5\xd6\xfb\x46\x36\x97\xbe\xd9\x72\xba\x5f\x2a\xe2\x83\xe1\xf1\x15\xcf\x58\x61\xd4\xba\x3f\x40\xb3\x3b\x94\x29\x20\xf3\xc0\x03\x4d\xeb\x71\xb0\x2a\x26\x8a\x22\xd7\xe7\x10\xb0\x64\x64\xe4\x1a\x77\xb9\xc7\xdd\x40\x78\x1c\x22\x36\x30\x1c\x9b\xbb\xbe\xb7\xc5\x58\xd2\xed\x72\x23\x6c\x62\x46\xa2\x6e\xd7\x50\x76\x7c\x6d\x46\xc1\xcf\xb8\xc5\x16\xc8\xe6\x52\x75\x9f\x9a\xaa\xd7\x0a\xf9\xd7\x4b\x11\xf2\x64\xa2\x09\x05\x9f\x0e\x05\x8b\xdd\x8b\xa1\xbd\x53\x97\x8f\xa0\x0c\x93\x12\xd4\x98\xcd\x01\xb5\xc1\xd2\xcb\xa1\xb6\xc3\x70\x63\x63\x68\xea\x9c\x84\xa7\xa6\x5a\xcc\x62\xf7\x3a\x8d\x09\x2a\x6e\xb9\x28\x99\xba\x3f\x98\x84\x69\x39\x63\xef\x6a\x9b\xf3\xa4\xb8\xf4\x77\x9f\xfb\x6d\xfa\xb4\x9a\x48\xe9\x58\x2d\x5a\x95\x0f\x1d\x4f\x81\xf2\x34\x4c\x3d\x01\x3a\x33\x2d\x20\xc9\x6d\x8c\xd2\xfd\x9c\x59\x46\x50\xb9\xa1\x7b\x5f\x81\x16\x85\x04\x2f\x3e\xe4\x70\xa5\xd1\x2e\x8c\x12\x82\xb1\xed\xeb\x8c\x59\xfa\x1f\x18\x3e\x33\x9f\x6f\xe2\x8b\xaa\x53\xe5\x58\x11\x0d\x7d\x10\x18\xa2\xc2\x9a\xdd\x45\x86\xed\xfe\x62\x42\x06\x23\x85\x8b\xcc\x1a\x99\x71\x29\x5d\x63\xbb\x49\x77\x0c\xc2\x13\x10\x7a\x46\x54\xf8\x9e\x74\xfd\x34\xb5\x44\x33\x48\x33\x17\x17\xcf\x1c\x5c\x3b\x15\x5f\x91\x74\x27\x36\xb4\x1a\x62\x16\x14\x51\x1e\x2c\x66\x8c\x15\x42\x20\xec\x76\x63\xb3\x8a\x21\x0b\x4e\xe2\x53\x53\x72\x12\xe3\xe6\x0f\x17\xce\x25\x8d\xac\xbe\xa4\x43\xf3\xa0\x8c\xd0\x1e\xda\x58\x9b\xfa\xfa\xb9\x97\xa0\xdc\x4b\xf0\xcd\x1a\x62\xbb\xfe\x9e\x5f\xdc\x56\xc2\xf9\x1a\x80\x00\x9f\x16\x61\x7d\x39\xb2\x53\x23\xbe\xe1\x86\x29\xf7\x02\x26\x6c\x7d\x00\x63\xd3\x1d\xca\xf3\xb1\x91\xe7\x13\xb6\xde\x87\x25\xa1\x3e\x1d\x4d\xd9\xc9\x14\xc6\x46\xa8\x4f\xed\x72\x8f\x8d\x50\x1f\xb3\xb1\x7b\x59\xf0\xb8\x0e\x53\x19\xa8\x4e\x3b\xa8\x9b\xd1\x0d\x3b\xb9\x81\x8e\x01\x75\x63\x41\x75\x0c\xa8\x0e\xeb\xb8\x97\xf9\x10\x27\xdd\x6e\x1e\x1e\xbd\xce\xd8\x4d\x7e\x8d\x64\x91\x1a\x3c\x42\x26\xa3\x36\xc3\xbe\x3f\xd4\x7b\x65\x0a\x08\x1b\x53\x21\x4f\xb4\x91\x66\x18\x27\xb7\x1c\x50\x41\xa6\x70\x43\xbd\x29\x63\xec\x86\xce\xe7\xd8\xcf\x26\x08\xb8\xb1\x53\x6c\xe6\xdd\x58\x3b\x1a\x44\x6f\xb0\x14\x89\x84\x8b\x20\x5d\x8e\x11\x1e\x3c\x5b\x83\x2d\x74\x5b\xf3\xa5\xc0\x26\x04\xf7\xbd\xd8\x21\xf0\x63\x31\x02\x74\xa9\xc6\xf3\xbc\xc6\x96\x87\x87\x6d\xe7\xd8\xcf\x79\xeb\x36\xc1\x58\x68\xf6\xc1\x50\xca\x18\x94\xd1\x50\x72\xba\xd8\x06\x01\xe7\x59\xf8\x33\x53\x6e\x54\x86\xc0\x54\x47\x72\x95\xd5\xde\x01\x01\x57\x94\x56\x3d\xd6\x15\xac\x12\xbb\xb7\xf3\xf8\x1e\xc3\xfc\xb2\xe0\x9a\x5c\xd0\x55\x31\xe0\x15\x0c\xb8\xb1\xbe\x0b\xfb\x1e\xd9\x5e\x05\xfd\xca\x05\xe8\xba\x90\x35\xfa\x76\x3d\x2e\x0f\xaf\xd5\x1b\x3d\x68\x9d\xb1\xc0\xe8\x6f\xfd\xe2\x69\xab\x78\xda\xc6\x27\x53\x33\xa8\x28\x04\x11\x93\x27\xc1\x29\xc4\x36\x4d\x49\xc4\x18\x8b\xbb\xdd\x52\x17\x32\x2d\x2b\xba\x50\x30\x9f\x67\xda\x95\xee\x76\x09\x49\x58\x44\x8d\x9c\x26\x9c\xc5\xd4\xed\x60\x98\x50\x91\x60\x62\x3e\x27\x44\x18\xed\xe9\x21\xa5\x27\xc1\x29\x8b\xed\x10\x6b\xef\xf4\x28\xd3\xde\xf4\xc8\x71\x72\xc5\x4d\x9b\x4e\xb6\xec\x5b\xcb\x65\xd1\xf8\x3b\x09\x4e\xdd\x10\xe2\x9c\xf1\x7a\xcb\xd7\xb2\x4f\x82\x53\x03\xc6\x48\x5e\x14\x22\x0f\x56\x80\x98\xe9\x33\x63\x34\x23\x34\x3d\x43\x40\x0d\x23\xaa\x63\x17\xd2\xb4\x08\xe9\xb3\xd3\x83\x7f\x64\x6d\x14\xbe\xe1\x9b\x7e\x35\x8d\x4d\xb1\x46\x3f\x96\x04\x87\x61\xc6\x86\xc1\x0b\x23\x67\xcb\x3b\x6b\xbc\x08\x85\xda\x0b\x46\xb8\xdc\xbb\x20\xe0\xe1\xc6\x8b\x20\xf2\x82\x8d\x28\xa5\x5e\xb0\x17\x65\x54\xf2\xd8\x16\x05\x20\x3c\x5e\xd1\xa3\x62\x16\xec\x45\xa3\xc0\x8b\xf2\x50\x48\x1b\x03\x69\x79\x64\x72\x12\x9e\x0e\xef\x8d\xa2\xc0\x4f\xc2\x53\xd0\xd0\xeb\xd9\x3b\x93\xd6\x87\x57\x21\xe2\xe7\x15\x9c\xab\x69\x55\x80\x33\x33\x4b\xe6\x29\x57\xe5\xcd\x30\xc2\x82\x8f\x83\xcf\xf2\xe8\x4b\x98\xb2\x3e\xdc\xb0\x3e\x4c\x98\x18\x4e\xf7\xc2\x6e\xf7\x66\xcf\xcf\xce\xf3\xc7\x8c\x1c\xb2\xe8\x64\x7a\x4a\x5d\x0e\x1d\x46\x5e\xb1\xf8\xe4\x06\x7f\x9c\xb3\x43\xd7\x87\x2b\xf6\xca\xf5\x0d\xf7\x1f\xaf\x33\xd6\xb1\x6d\xce\x4c\x83\xde\xe0\x14\xae\x4d\xe5\xde\x00\xa5\xc3\x19\x35\x45\x33\x76\xe6\x72\xb8\x65\x67\xae\x0f\x77\xcc\xa8\x87\x33\x53\x78\x8d\x85\x97\xec\xda\xe5\xf0\x8c\x5d\xbb\x3e\xbc\x60\x63\xc6\xd8\xa5\x29\x7c\xd1\xed\xde\xd1\x7b\x45\xce\xe1\x19\x24\xd0\xeb\x4d\x28\xbc\x56\x98\xf8\x6e\x0c\x57\x70\x63\xb4\xba\x49\x8f\x9d\x5b\xef\xe6\xc7\xbc\xe4\xd6\xd6\x9c\xf4\xd8\xad\x2d\x99\xf6\xd8\x26\xdc\xf4\xd8\xa6\x55\x4e\x0c\x60\x3a\xe9\xf5\x72\x58\x9d\x1c\x56\xd1\xd3\xa4\x0a\x77\xda\x63\x83\x7a\xeb\x3b\x5a\xf4\x75\x5e\xf4\x95\xd5\xbe\x57\xe4\x16\xae\x72\x6c\x97\x71\x18\x0c\xf3\x80\x9e\xf5\xb3\xf9\x7c\xb6\xce\xd8\x65\x76\x9d\x65\x11\xe6\x22\x76\x0b\x7d\x3c\x6b\xef\x63\x33\xb5\xec\x08\xc7\x53\xc5\xa5\x18\x51\x0f\x6e\x7a\x3d\xdc\x32\x66\xd5\xb3\x05\x3f\xcc\x51\xa8\xac\xbb\x5d\xea\xe5\xf6\xb6\x6d\x49\x2c\xaf\xe0\x88\x1d\xcd\xe7\x27\xa7\xc3\x0c\xed\x0a\xb9\xbc\x72\x7d\xc8\x14\xaf\x23\x8a\x1d\x93\xfe\x5e\xbe\xa7\xe6\xf3\xfe\x5e\x50\x3c\x1f\xd1\x6c\xeb\x3c\x31\x5b\xe7\xd6\x4b\xe0\xce\x0b\x60\xe6\x1d\x65\xe7\x4f\x6f\x14\x73\xbe\x8b\xc9\xd5\xd7\xdd\xe7\xef\x2a\x79\x36\x5f\xab\xa6\x63\x73\x23\x29\x31\xa6\x25\xc8\x65\x4c\x76\xc4\xf2\xa0\xbc\x04\x9e\x79\x01\x7b\x08\xbc\x3e\xdc\x7b\x02\xcc\x8b\x69\xe1\x78\xce\xf4\x11\xd3\x9e\x05\xa8\x8a\x1b\x93\x37\x70\x83\xe2\x90\x26\x87\x90\x52\x08\xdc\x80\x6d\x66\x27\xef\x35\x05\x27\x70\xef\x41\x40\x04\x81\xab\x4c\x2d\xc5\x12\x0b\x36\x70\xa7\xee\x94\x3d\xdc\x7a\x91\x85\x90\xe6\xd8\xf7\xde\xa8\xdc\x0b\x5b\x8c\xec\x63\x4d\x52\x59\x81\x94\x8f\x8b\x17\x11\x5d\xdc\xa2\x96\x23\x12\xd4\x11\x11\xc0\xdd\x7b\x08\x20\xc9\x94\x80\x63\x63\x65\x3d\x85\xc4\x4c\x70\x00\xcf\x0c\x6f\x4a\x3f\xd6\x71\xb0\xcc\x3e\x13\x31\x45\xfd\xfc\x00\x00\x27\xe6\x21\xf0\x06\x95\xb9\x8b\xaa\xf2\xf5\x7d\x85\x35\xad\x57\x8e\xd4\x17\x1c\xbe\x96\x19\xa2\x05\x69\x79\x7d\xec\xda\xa8\xa3\xa1\x11\xc1\xf9\xbd\x60\xc3\xad\x3a\xf9\x22\xf8\xf4\xbd\xc1\x46\xbb\x97\x10\xbb\x53\x88\x68\xb1\x29\x9f\x60\xe9\x43\xec\x6a\xa6\x20\x76\x13\x16\x0d\xad\xb2\x18\xbb\x53\xf7\x76\xd8\xdf\x9b\x16\xca\xa5\x45\x64\x0a\xfd\xdc\x71\x9c\xc3\x78\xda\x0c\xe3\xc6\xc0\x30\x18\xdc\xd0\x87\x1b\xf7\x99\x3b\x65\x2a\x83\x7d\xf3\x33\xc8\x16\x74\x15\xa0\x21\x48\x62\x46\xdd\xeb\xe1\xf9\x2e\xc1\x61\xd3\x7f\x17\x44\x9a\x20\xa5\x4f\x98\xb6\xa3\x36\xba\xe8\xa4\xe4\xf0\x63\xa6\xab\xba\xae\xd5\x5e\xcb\xe3\x0f\x18\xdb\x09\xee\x0d\x20\x00\xd5\xe0\x89\xb2\xfb\xa8\xc3\xb4\x2b\x32\x0d\x4b\xb9\xc1\x79\x34\x19\x1f\xc4\x63\x31\x2d\x64\xd4\x15\xeb\x0f\xaf\xf6\x3a\xb9\xb4\xbb\xca\x05\xd4\x99\xb1\x30\xd9\x64\xd4\x39\xb9\x3a\xf5\xcc\x3f\xae\x0f\xd7\xac\xd7\xe3\x3d\x72\x66\xcf\x79\x90\x32\xf7\x58\xd8\xed\x86\x7b\xec\x1a\x73\xae\x49\x72\x7e\x72\x75\x0a\x67\xd9\xda\x5f\x43\x44\xc1\xce\xc1\xc2\x0c\x14\x53\x30\xe4\xec\xba\xb8\xb6\x97\xe6\xb6\x1e\xf4\x41\xb9\x3e\x54\xf3\x41\x7e\x55\x4b\x67\x32\xe8\x19\xcc\xd5\x6d\xe9\x91\x0a\x31\xc2\x5b\x85\x57\x76\x2b\x00\xde\x2e\xba\x5b\x50\xe9\x56\x55\xa5\x7b\xd1\xf5\xa2\x81\xb3\xcf\x8a\x24\x98\xf8\x89\x31\x26\x31\x57\x52\xe9\x10\xad\x84\x1f\x7f\x56\xb5\xdb\x55\xaa\x12\xa4\xbe\x74\x00\x5b\x77\xc4\x94\xc7\x9f\x90\xb0\x43\xa4\x79\x3a\x4c\x1a\x16\x74\x3e\x27\x4d\xaf\xad\x2f\x67\x71\xf1\x87\xa2\xdb\x35\xd6\xaa\xec\x76\x17\x8e\x55\x13\x90\x95\x2c\x55\x18\x01\x30\x05\xe5\x26\x0b\x97\xaa\x32\xa7\x9e\x9b\x98\x72\x0a\x8b\x01\x04\x32\x07\xfa\x92\x6b\x4e\xfa\x50\xdc\xfe\xaf\xd6\x2e\x6c\x08\x3b\xf7\xee\x74\xd1\x72\x68\x42\x7d\xd4\xf4\xd2\xbd\x60\xca\x9d\x7a\x4d\x45\xec\xe1\xc2\x33\x43\xb8\xf6\x94\x9b\xa4\x79\xd7\xbb\x5e\x35\x06\x6e\x9a\xa5\xae\xd4\x6e\x84\x11\xeb\xb9\xf3\xc8\xce\x88\xac\xec\x8b\x13\xed\xde\x94\x8a\xa3\xcc\x6f\x01\x94\x6a\x17\x41\x78\x14\x95\xc6\x5a\x43\xc1\x4c\xd3\xa1\x28\x04\x5e\xd6\x53\x24\xa7\x42\xe9\xe7\x22\x8c\x95\x20\x87\x8a\x24\x18\x26\xef\x26\x14\xf8\x62\x3f\x4f\x3d\xe4\x19\xb6\x07\x5a\x7a\x2c\xaa\x07\xe4\x15\xb4\xcd\x3c\x5b\x29\xa0\xdd\x67\x55\x8b\x68\xad\x6f\x6c\x00\x57\xa1\x83\xa7\xb5\x71\xe0\x4e\x99\xdd\x26\xee\x6d\xb1\x64\x4f\x9a\xc8\xb5\xcc\x2c\x60\x26\x72\x39\x68\x37\x0f\x25\xad\x04\x92\x16\x5e\xeb\x97\x59\xd4\xc0\x6b\xc5\xcf\xd0\x7d\x5d\xa4\x11\xad\x4e\x53\xae\x8b\xe7\x71\xa5\xcf\x86\x31\x5a\xb4\x56\xe4\x8d\xb8\x3b\xf5\x0e\x15\x31\xd2\xcd\xcc\x5c\x35\x02\x4d\xbb\x33\x9b\xbe\xa9\x18\x4a\xe9\xc6\x64\xda\xbd\xcb\x2e\xcf\x14\x8b\x52\xb9\x43\x93\x9c\x70\xa3\x39\x07\xee\x33\x88\xd9\x26\xfa\x3f\x82\x51\x64\xbb\x8a\xb2\xae\x86\x0b\x0b\x18\x43\x6d\xd1\x03\x57\x9d\xd2\x54\x74\xbb\x18\x07\x21\x2a\x61\x3f\x38\x3b\x0b\x37\xfe\x94\x3b\x25\x92\x0e\xc7\xd6\xd9\xe6\x1d\x92\x41\xbf\xea\xa4\xfd\xa2\xb2\xf0\x75\x9b\x22\xd7\x10\xf8\xf1\xec\x5a\xe4\x84\x10\x1a\xf3\x54\x8b\x3b\x9d\x05\x48\x5a\x7d\x65\xbd\xa5\xaa\xe3\xd0\xe1\x62\x8a\x49\x9e\x3b\x88\xa7\xab\x02\x7b\x87\x8a\x9d\x93\x19\xb9\x56\x90\xb8\x92\x5f\x09\x48\x5c\xb4\x33\x31\xdb\x50\xa6\x98\xb8\x9a\x9f\x1d\xf0\x2b\xe1\xea\xf8\x5d\x7c\x2b\xd4\x0b\x3e\x15\x84\x66\x27\xa6\x72\x51\xce\x88\xd2\xb3\x24\xac\x73\xf0\x9c\x7c\x51\x24\x3a\x11\xa7\xd4\x58\x79\xc5\x21\xba\xaf\x80\x83\x82\xa0\x16\x3e\xa2\x40\x82\xae\x1c\x1b\x63\xe8\x64\x64\x04\xc4\x36\x28\x37\x78\x63\xfe\xa9\x04\x5f\x62\x2e\xc3\x3c\x2c\x22\x78\x0b\x9c\x45\x38\x3f\x10\xb0\x2f\x8a\x94\x7b\xee\x4f\xb5\x70\xd7\xde\xce\x54\x82\x69\x12\xd9\x3b\x3c\x2f\xa1\x43\xce\xbe\x1a\x35\x37\xb0\x52\x25\x60\x18\x48\x97\x9d\x1a\x7e\xab\x45\x0c\x58\x34\x45\x1d\x4d\xd1\x8a\x66\x92\xa3\x69\x6c\xcf\xf7\xdd\xae\x72\xdf\x13\x4c\x4b\x8a\x48\x47\x66\x03\xe9\x48\x4f\x8c\x51\x17\x29\x8c\x25\x86\xd0\x0c\x20\x6e\x1f\x40\xa0\x18\x1f\xda\x51\x04\x76\x14\xbe\x22\x8e\x69\xea\x50\xd2\xa1\x44\xb9\xfe\x4b\xb3\xfb\xde\x29\x12\x1a\x21\x13\x9b\xb1\xc5\x10\xa2\x1e\x08\x21\xd3\x10\x28\xd6\x87\x08\xdd\x35\xc1\xab\x6e\x97\xe4\x48\xb0\x08\xdf\x50\x3b\x78\xf8\xd4\x1c\x29\xa4\x6c\x1c\xef\x33\x19\x5d\xa1\xdf\xf9\xb5\xe2\x57\x62\xd4\xf8\xb6\x16\xec\x54\x09\xf3\x92\x30\x10\x5b\x8f\x76\xfb\xb4\x1a\xf1\xa9\x6c\x40\xaf\x20\x3a\x8f\xbb\xae\xdc\x6e\xe1\x84\x3e\x24\xa8\xab\x24\xa3\xbe\x47\x3e\x99\x25\x06\x53\x15\x06\x05\x9b\xa8\x73\x2c\xcd\x24\xa8\x11\xc1\x3a\x66\xd7\xdb\x74\xb1\x03\x4a\x3d\x54\xb1\x93\x6e\xd7\x02\x49\xd8\x66\x75\x77\xfe\xae\xca\x68\x81\x69\x6c\xa6\x66\x12\x07\x38\x22\xf7\xdc\x48\x5c\x97\xcf\xe7\x87\x64\x40\xdb\xa2\x59\x66\xe4\xaf\x08\xfe\x88\x6a\x91\x6e\xf4\x41\x75\xbb\xe7\xd1\x54\xc7\x6a\xe6\x9e\xa1\xcb\x5f\x12\x9b\x9f\x13\x47\xfa\x47\xeb\xa1\x74\x33\xb4\x1c\x94\x31\x5d\x8e\x34\xd7\x02\xcf\x30\x1c\xa8\xc0\x85\xbf\x54\x6b\xba\x8e\xd5\x40\x33\x81\xdf\x06\xf7\x61\xf1\x78\xa5\x7a\x5a\x92\x42\xc3\x69\x8d\x57\x0f\x8f\x06\xa9\x19\x59\x15\x81\xd6\xed\xe6\x4f\xd0\x54\xcd\x9e\xf2\x8c\xec\x1f\xef\x2f\x55\x8b\x58\xa8\x6b\x8e\x6f\x24\xa9\x8f\xb1\x62\xba\x48\xfa\xf0\x5c\x12\x81\x91\x71\x05\xdf\x5e\x3a\x3a\xd2\x20\xeb\xa7\x54\x98\xfc\xab\xba\xb0\x8d\xe7\x53\xda\x7e\xc6\xa1\x3d\x41\x4b\x76\x4b\xbf\x72\xa9\x40\xd3\xd1\x85\x26\xda\xe5\x98\xaa\xa3\x1a\x41\xab\xab\x81\xee\x8b\x97\x6e\x3e\xa9\xea\xf8\x30\x06\x85\xe5\xd3\xe7\x9e\x09\x9d\x9d\x26\x3f\x9f\xed\x8f\xf1\x12\x03\x91\xa3\x77\xd9\xb0\xbd\x63\x49\x7e\x8f\x8a\x1c\x1f\xc8\xf3\xb5\xae\x07\x29\x57\xa2\x08\xf5\x02\x1b\xca\x45\xe0\x89\x3a\x25\x14\x8e\x57\x85\x29\x6b\xd6\x10\xda\xa5\xdd\x69\xa0\xe2\xc9\xc4\xa6\xcf\x39\x4e\x17\x63\x43\xeb\x23\xc3\x68\x50\x4d\x68\xe5\x6e\x98\x5e\x11\xac\xd2\x8e\x6e\xd6\xeb\x3b\x11\x1a\x13\x2e\xff\x79\x1c\x5f\x33\xbd\x7a\x10\x72\x75\x8a\xad\x55\x85\xff\xb9\x22\x45\xa4\xda\xdb\x6b\x4a\x34\x96\x97\xfe\xfb\xdf\xab\x4b\x4d\x71\x5b\x2c\x68\x9d\xf6\x2d\x6d\x4c\x85\xde\x97\x5a\xa8\x1b\x3e\xa9\x16\x3e\x97\x44\xe3\x9d\x9b\xb6\x48\xdb\xa2\x91\xcc\xee\x61\xa0\x5d\xa3\x21\xd1\xc0\x35\x04\x1a\x22\x0d\xb1\x86\x50\x83\xaf\x61\xaa\xd9\xf2\xd4\x97\x71\x9b\x70\xd3\x52\xbe\x99\x95\x4f\x5a\xca\xb7\xb2\xf2\x71\x4b\xf9\x76\x56\xde\x69\x29\xdf\xc9\xca\xcf\x35\x7b\xe8\x78\xbb\x29\x5c\xe9\x96\x7c\x67\x59\x93\x6f\x9e\x02\x1e\x78\x1a\xf8\xd8\x4b\x80\x0b\x4f\x40\xf0\x02\x73\xb5\xc0\x99\x5e\x91\x65\x8c\x98\xe9\xc4\xec\x2b\x9a\x8d\x61\xa6\x19\x11\xd5\x6b\x2b\x95\x9b\x0d\xca\x0d\x30\x39\xe1\x18\x78\x9b\x0c\xb8\x25\xd7\x1a\xa4\xdb\x19\x69\x8f\x63\x6c\x07\x37\xf3\x5f\x2d\xe4\x80\x7f\x0c\xe0\x84\xda\xbc\x50\x03\x0a\xb7\x9a\xf5\xe1\x4e\xb3\x2b\xb8\xd4\x6c\x13\x9e\x35\x21\x8c\xce\x19\x7b\x06\xbc\xb1\x89\x76\x76\xa7\x9e\x3a\xd5\x28\x90\x63\x48\x98\x04\xce\x6e\x51\xf3\xf6\x41\xbb\x01\xdc\x92\x67\x38\x0e\xd0\xae\xc0\xbc\xba\x09\x28\xc6\x41\x33\x61\x26\xe7\x45\xd3\x02\xac\x61\x9b\xd6\x49\x9b\x91\x3b\x0d\x36\x45\xad\x4d\xc2\xd5\x31\x4c\x14\x0e\xff\x4f\x41\xc9\x2a\x94\x57\x8d\x50\x0e\x31\x55\x26\x1c\x69\x76\x00\x17\x3f\xa1\xd9\x03\xa4\x99\x41\x0a\xfb\xf5\x8a\x78\xd8\xe4\x57\x6f\xb3\xc9\x4a\x5e\x83\x03\x9d\xc2\x4b\xdd\x9e\x89\xb3\x33\x3a\xd0\x9e\x69\x63\x03\xce\x53\x0a\xef\x1a\x31\x95\x75\x0d\x3c\x85\xe3\x56\xa0\x36\x66\x16\xee\x9b\xe1\xa4\xf0\x5d\xb3\x77\xf0\x61\xb9\xb9\xf4\x16\x89\xa1\xbc\x96\xbf\x76\xa0\x87\xb9\x6d\x18\x60\x2e\xd8\x31\x52\xad\xc8\x6f\xeb\xcf\xc8\x77\x24\x07\xd7\xa7\x85\x43\x44\x1a\x05\x8c\x89\x22\x54\x64\x6d\xd1\x5d\x70\x81\x89\x38\x73\x33\xc9\x56\x4f\x2a\xd5\x53\x43\x4a\x3f\x56\xce\x9e\xf4\x94\xcb\x53\x0a\xcf\x75\xdb\xe5\x9a\x86\x49\xd0\x64\x46\x7e\x68\xe8\xc0\x8c\x7c\xb0\x1f\x41\xc1\xe8\x78\x78\xd3\x38\x65\x33\xf2\xdc\x0c\x6d\x46\xce\x34\xec\x6b\x78\x69\x5a\x9f\x69\x78\xa7\xe1\x48\x13\x27\xe4\x93\xa9\x70\xa8\xf9\xbf\x14\x5e\xb7\xe3\x6a\x93\xa2\x7d\xd4\xec\x77\x78\xff\x93\x8d\xb8\xae\x17\xf3\x17\x0b\x4c\x2a\x6f\x37\x21\x7e\x14\x22\xcf\x65\x5c\xdb\x74\x5f\x5b\x76\xca\x7b\x0d\x77\x3a\xdb\x07\x6f\x75\x63\xf4\x73\x14\x12\x51\x86\x99\x0b\x97\x63\x30\x12\x1e\x06\xf1\xfc\x7d\xc0\xb8\xcb\xf1\xc4\x0c\xdf\x47\xf9\xfb\x98\x45\x78\x23\x2d\xb2\xef\xc3\xfc\xbd\xcf\xc2\xf2\x5b\x21\x06\xeb\x04\xcc\xbf\x01\xfe\x1b\xe3\xbf\xa1\xcb\x61\xa7\xdf\xdf\xd3\x23\xc4\xd2\xa0\x63\xb3\x6e\x78\x77\xe4\x6d\xc6\x5e\x7a\x03\xf0\xed\xf4\xb6\x82\x52\x2d\xa5\x6a\xf1\x75\x3d\x8d\xee\xe7\x15\x1c\xbc\xe8\xbf\x6f\xb9\xc8\x97\xda\xca\x56\x53\xf2\xdf\x92\xcf\xba\x4d\x3e\x23\x1f\xb2\x29\xd7\x0b\x56\x44\xe1\xdb\x4f\x84\x4e\xe2\x09\xb8\xf5\x34\x68\x4f\x81\xaf\xf0\xc8\x04\x25\xce\xa7\x56\xea\xba\x24\xdf\x34\x28\xf7\x0e\x94\x6b\xfe\xde\xa2\x3f\xcf\xb0\x14\x1f\x93\x43\xc1\x9f\xba\x7e\x07\x41\x16\x27\x2a\x4b\xe2\xbe\x72\x07\xee\x0e\x9d\x09\x1a\x04\x93\xee\x2d\xc6\x58\x26\xe5\x72\x7e\xd1\xf0\xc9\xb0\x3a\x5f\x51\x08\x88\x45\xa0\x38\xaf\xb1\xdb\xe9\xf7\x15\x3b\xd7\x1f\xe1\xbc\xdd\xd9\xed\xe7\x19\x1d\xe7\x8f\xd6\xea\x9a\x61\x7f\x28\x19\xb0\xd9\xef\x86\x9c\x75\xa1\x05\xc2\x5f\xcb\x4d\xb3\xe8\x3f\xc3\xab\x9a\xc6\x58\x8c\xe3\x0f\x83\x73\x7e\x3f\x06\xa4\x58\x61\x88\x19\x0c\x88\x51\x1a\x9b\x26\xeb\xb6\xcc\x80\x7b\x82\xb3\x61\xe6\xcf\xcc\x9e\x11\xd8\x09\xa0\xeb\xd4\x57\x94\x60\x72\x51\x8a\x19\xcd\x0a\xf4\x95\x60\x17\xa0\x2b\x1e\xb7\x86\x2f\x49\xad\x5e\x17\x74\x52\xfa\x98\xfd\x5c\x97\xfb\x55\xe3\x7e\xd5\xe5\x2e\x7c\x45\x02\x88\xe9\x28\x47\x11\xc9\xd3\x6c\x13\x88\xb2\x85\x3b\xa5\x5e\x27\xdf\x22\x9d\x34\x05\x21\x56\x70\xc4\x46\x31\xe5\x77\xbb\xeb\xd2\xf5\x5d\x7f\x94\x49\x42\xb4\x66\x52\x48\x04\x9b\x91\x3f\x35\x5c\x99\x6e\xa5\x68\xfc\x47\x0b\xe2\xf0\x89\x50\x7a\xea\x50\x10\x82\x38\x61\x34\xd1\x42\x39\xd4\xfe\x3a\x53\x71\x72\x9d\xff\x50\x22\x10\xd1\x8d\x2d\x7c\xa3\x89\x33\x8d\x26\x42\x06\x62\x9c\xff\x8e\xe4\x79\xe4\x47\x1a\x5f\x50\xe0\xa6\xf7\xda\xca\xfa\xff\xc3\x53\x0c\x31\xf3\x89\x3d\x5b\x8c\x4b\xb1\xd9\x29\xce\xc1\xf8\x22\x7d\x2c\x4d\x3e\x09\x91\x2e\xca\xd9\xa7\xe0\xe4\x09\xc8\x2e\x34\x85\xc0\x8c\xe1\x2f\x8d\xb3\x94\x8d\xd6\xcc\x13\xbe\xe3\x76\xf2\xc4\x38\xd2\x38\xde\x48\xb4\xb2\xb6\x07\xff\xa9\x27\x81\x7f\xb3\xcc\x45\x9b\x6e\xe2\xfa\x2a\xe7\x93\x50\xc9\x54\xda\x2f\xbf\x32\x53\x4f\x9d\xae\x46\xca\x1b\xf4\x37\xb7\x7f\x23\x6a\x03\x0b\x68\xaf\xd6\x70\x40\x37\x30\xc7\x76\x6f\x77\x67\x67\x6b\x37\x85\xb0\xa9\xab\x58\x54\x6e\x52\xaa\x3d\xb6\xf3\xb8\xdb\xdd\x7e\xb2\xc7\x54\x0a\xfe\x4f\xeb\x3f\x7d\xbc\xc7\x30\xdd\x1c\x1b\x6c\x6e\xa6\x30\xfd\x95\x0e\x9e\xf6\xbb\xdd\xdd\x1d\xec\xe0\xa6\x91\xc2\x7d\xd3\x60\x3e\x9f\xda\x3f\xce\x77\xc7\xa6\x02\x09\x05\xea\x8b\x13\xc1\xce\xc8\xc9\x3d\x71\xd8\x7f\x39\xb0\x49\xe1\x9e\x38\xeb\xff\xe5\xc0\x16\x3e\x31\x07\xfa\xf6\x15\x73\x60\x40\x4f\x29\x8c\x05\x7b\x0d\x9d\x96\x9d\x34\x16\x20\xc1\x71\x68\x0a\xe7\x4d\x35\xca\x64\x33\x70\xd5\x52\x9e\x2b\xa8\x67\x02\x15\xd4\x41\x0a\xd7\x6d\x5c\xac\xfe\xc9\x22\x0a\xb3\x15\x64\x92\x01\x2e\x3f\x00\x41\xe1\xf6\x57\xe1\xde\x89\x15\x77\xac\x1e\x78\x62\x68\xef\x0f\x4f\x00\x1f\x78\x1a\x7c\xdf\x8a\xb7\x4b\xc4\xbf\x9f\xc2\xb3\x15\x4c\xf8\x56\xc0\xa5\x80\x3b\x72\x87\xb7\xf2\x7d\x63\x0c\x25\xc8\x62\x03\x14\x74\x2f\x04\xe3\x12\x0e\x05\x6b\xce\x12\xd0\xb0\xd7\x6f\xc9\x0b\x61\x0c\x27\x4c\x7f\x50\x7a\x8d\x5f\x11\x05\x1b\x03\x3a\x9a\x91\x6b\x01\xeb\x03\x98\x91\x67\x66\xa1\x04\xa5\x1e\x16\x6d\xd2\xd1\x2d\x99\x09\x58\xef\x43\x1f\xcc\x88\xea\x01\x9b\x18\xa6\x69\x34\x17\x7c\x30\x4f\xdc\x93\x46\x51\xf5\xea\xad\x0c\xfa\xbd\xc5\xa6\x2a\x6f\x96\x37\x32\xb3\xf3\xaa\x85\x7e\x0e\x0d\x5a\x67\xc2\x58\x31\xf5\x69\xab\xa8\xfc\x14\x2e\x6a\x0b\x1d\x95\x06\x68\xcc\x24\x84\xcd\x22\x32\xdb\x3a\x59\xfa\xe5\x41\xdd\x1e\xc0\x79\xc1\x2f\xc2\xb9\x3e\x2d\x4c\x03\x8e\xa6\x81\xd1\x54\x43\x82\x5f\x63\xc9\x1a\x26\x6e\x27\x77\x82\x27\x25\x27\x44\x18\x7a\x3e\xe7\x90\xb8\x3e\x4d\x6d\x59\x76\x64\xe3\x06\xa5\x81\x3b\xcb\x6a\xcd\x08\x72\x4a\xd7\xa7\x10\xe0\x9c\x1c\xb4\x12\xca\x2d\xb9\x10\x70\x64\x3f\x60\x94\x52\xd8\x17\xec\x40\xc0\xcb\x15\xe4\xbb\x59\x25\xdf\x77\x4d\xdb\xa2\x66\x1e\x15\x12\x20\xd7\xcc\x49\x1f\x33\x58\x64\x93\x55\x8e\xd7\xfc\x22\x9c\x25\xd4\x2d\xc2\x87\xf9\xd0\x5a\x3a\x33\xf2\x52\x80\x02\xa3\x5f\x1b\x0d\xbe\x6a\xf7\xe4\x35\x59\x92\x56\xe7\x6a\x7d\x80\x39\x2b\x28\x1c\x57\x88\x61\xe5\x07\x1f\x6f\xc9\x3b\x33\x09\x97\x18\xc0\x98\xc2\xbd\x60\xc7\x02\xbe\xff\x7a\xeb\x99\xed\x14\xbd\x99\xf0\x41\xb0\xef\x02\x7e\xac\x98\xc5\x7e\x75\x16\x9f\xb7\x50\xec\x0f\x61\x53\x2f\x58\xbe\x45\x53\x78\xd3\x54\x71\x5d\xa6\xf0\xba\xa9\xc0\x41\x5e\x9c\xc2\x47\xc1\x12\x09\xef\x97\xd9\x3d\xc7\x4b\x55\x01\x7e\xe8\x27\x62\xeb\xaf\x45\xe5\x30\x68\x99\xbe\x2f\xc9\x47\x01\x3c\xdb\xff\x39\x43\x91\x98\x8c\xa4\x46\xd0\xaa\xa4\xc8\x57\x44\x37\xf1\x86\x80\x66\xbb\x3b\xca\x36\x77\xb2\xb0\xaf\x91\xd5\x89\x72\x53\xc3\xd7\xc6\x19\x7a\x2f\xc8\x73\xeb\x96\x86\xb7\x8d\x2b\x75\x2f\xc8\x19\x39\x99\x91\x7d\x01\x1f\x04\x39\x17\xa4\x4f\x29\x7c\x15\xa4\x83\xa9\x67\x8d\x46\xb0\x2f\x20\x2f\xbe\xc2\x97\xf0\x4a\x34\xb0\x06\xe7\xef\xbf\xed\x64\x2e\x54\x28\xd6\xa0\x9f\xe6\xe0\x7e\x01\x92\x8d\x42\x28\x3e\x02\x45\x4f\xcd\x08\x3e\x0b\xf6\x12\xbe\x34\x8e\xb3\xf8\x48\x05\x7c\x13\xec\x2d\x7c\x6a\xdd\xcc\x72\x6f\x30\x52\xde\x2d\xf9\x66\x66\xf9\x8b\xc0\xac\x65\x68\xd5\xfc\x4a\x8b\x3e\x6c\x64\x4c\xe0\xf7\x5a\xf5\xca\xb9\xdc\x0a\x23\x88\xff\x13\xee\xe7\x23\xb1\xd4\x19\x97\xa9\x34\x23\x09\x58\xec\x4d\x95\x4c\xd0\x80\x46\x47\x9d\xb1\x7b\x5a\xf6\xc9\xef\x96\x83\xd1\x14\xfe\x12\x6c\xf1\x23\x6e\xd9\x39\x7a\x3b\xe6\x49\x86\xf9\x4f\xb1\x5e\xc6\x57\x18\xc3\x91\xda\x04\x26\x20\x13\xf6\x97\x00\x95\xac\xd6\x4d\x74\x4b\x79\xae\x9b\x88\xa6\xf2\x35\xe9\x76\x46\xca\x66\xcb\xf4\x74\x96\x35\x13\x92\xa4\x51\x77\xc8\x99\x6f\x76\x7e\x4d\x14\xcd\xb2\x87\x23\xaf\x5d\x96\x2b\xb2\x90\x2b\x85\xdc\xc1\xc0\x5f\x1f\xd3\x53\x05\x43\xbc\xd5\x54\x4c\x0d\x8e\x1d\x9b\x04\x46\xa1\xc7\xcf\x44\x99\x5f\x0a\xb3\xda\x68\x66\x2c\x81\xc8\x4c\x07\x4f\xfe\x81\x9f\xe9\x8e\x24\x89\xe5\x9f\xd9\x79\x10\x04\x49\xbb\x6a\x63\xf8\x4e\x93\x4d\x35\x23\x32\x01\x91\x80\x42\x9e\x80\x39\xba\xf1\x1a\xcc\xc6\x66\x0a\x71\xc2\xa2\x04\xc2\x84\xc5\x09\xf8\xad\xb0\x51\x1a\x1e\xeb\x5c\x1a\x4e\x1b\x17\xa3\xae\xf2\x66\x9a\xee\x4d\x63\x55\x23\xbb\x72\x2e\xfe\xd4\x72\x71\x3c\xd0\x2e\xf8\x2d\x53\xb5\x1c\x4e\xff\x03\xcc\x76\x3e\xef\xef\x59\x5d\xad\x01\x9f\x69\x52\x55\xd3\x53\x54\xe7\xf8\x7f\x9b\x3f\xdb\x23\x76\x1b\xf7\x97\xc2\x04\xe7\xfc\x71\x0a\xe3\xb6\x69\x5e\x47\x6f\xa2\x79\xe1\x76\x52\x0a\x9d\x15\x4b\x3d\x4e\xf2\xb5\x38\x4f\x58\xfb\xe5\xfc\x2a\xcd\x47\x76\xf4\xf6\x02\xa5\xa1\xde\x57\x24\x32\x13\x43\x4b\xa5\x5a\x64\xd9\x1e\x78\xae\x43\x6a\xe0\x5e\x92\x16\x95\x37\x29\xb5\x9a\x87\xea\x0d\x0c\x4d\xf7\x06\x20\xd8\x00\x12\x66\x6c\x5b\xb3\x3b\x02\x1b\x7b\x69\x2b\x45\x19\xd9\x8b\x5e\xad\x8a\xa1\xe2\xab\x84\xcd\x88\x9f\x40\xf9\xcf\x07\x41\x22\x41\x81\x70\xcd\x1e\xf8\x73\x6f\x92\x80\xbf\xe3\x91\x44\xb3\x07\x7f\xc7\xbb\x11\x10\xc4\x5e\x98\x80\x1f\x79\x37\x22\xa5\xae\xbf\x63\x5e\x24\xda\x0d\x62\xf3\x2e\xd1\xae\x1f\xa5\x0d\xe4\x82\x23\xe6\xa6\xb4\xd4\xcf\x71\x30\xaa\x32\xf2\xb5\x85\x65\xe6\xda\xe5\xcf\x73\xe7\x0a\xcb\x95\x75\x9f\x9c\x27\x08\x6a\x07\xac\x66\x9e\xa9\xe5\x03\x4c\xe4\x6b\xd6\x1f\x2f\xe1\x56\xaa\xa9\x92\x44\x7b\xf5\x5a\x20\x58\xc1\xce\xf5\x82\xdd\x30\x23\x9d\x04\x10\xe9\x20\x5e\xa2\xc0\x0c\xb5\xc2\x06\x10\xe8\x5b\xa4\x70\x2f\x08\x3a\xb8\x9a\x8c\xf0\x0a\x57\xb3\x62\x58\x1a\xde\x7c\x93\x60\xda\x77\x98\x08\x23\xf0\x89\xd0\xec\x5f\xce\xbf\x00\x39\x05\x3a\xa7\x3f\x09\x32\x30\x02\x92\x0c\xa8\x11\x30\xa4\xa6\x12\xf4\x73\x6d\x41\x68\xab\x2e\x04\x09\x08\x0d\x6f\x05\xba\x59\x29\x9c\x25\x8c\x04\xf6\xb4\xa3\x9f\x36\xed\xb7\x57\xe4\x8b\xbd\x90\x8d\xd9\xad\x46\xb9\x9a\xd8\x07\x49\xbd\xc5\x4d\x97\x1d\x83\xd5\x36\x43\x90\x4b\xb0\x68\x95\x04\x8b\xfe\xb9\xe5\x11\x40\xc2\x02\x94\x5e\x99\x70\xf8\x87\xc6\xc7\x92\xc9\x61\xe4\x45\xe2\x5a\x6b\x63\xd6\xba\xa1\x95\xb1\x8d\x57\x73\xdf\x59\xb1\xe3\xef\x92\x95\xde\x5f\x63\xe3\x1a\x8b\xf6\x38\x53\xf2\x6e\x0d\x39\x65\xef\x66\xe4\xaf\x46\xfe\xa7\x13\x92\x9d\x78\x25\x36\x5d\x12\xae\x6a\xb5\x6e\x89\x2a\x66\xf4\xc6\x6a\xd2\x68\x68\x98\xe8\xa0\x59\xe2\x66\x2d\x72\x44\x7e\xd6\xb5\x30\x30\x67\xe4\x40\x20\xa2\x07\x02\x8f\x4c\x0e\xd0\xb6\xa6\x3f\x45\x08\x1b\x7f\x47\x4d\xf6\x14\x71\x7a\xd6\x36\x4b\x76\x21\x7f\x65\x74\xc3\x9f\x4f\xe8\xaf\x8e\x2d\x9b\x56\xe0\xa7\x38\x14\x9e\x4d\xdc\x8b\x1a\x92\xcb\xc9\x5a\x72\xf0\xd7\x49\x0d\xfc\xc2\xa5\xcd\x22\x72\x18\x55\x80\x33\x72\x22\x4f\x29\xdc\x91\xbb\xa4\x18\xf4\xe2\x55\xbd\x7a\xc5\x67\xd5\x8a\xf9\x61\x5a\x51\xf3\x20\x1b\xac\xb6\x7f\x92\xf2\x57\x09\xe3\x96\x5c\x26\x39\x04\x8a\x09\x19\x8c\xca\xd6\xba\x64\x9d\x14\x54\xb6\x4c\x87\x6d\xcb\x54\x15\x5d\xbc\x22\xba\x0a\x16\xce\xab\x2c\x1c\x37\xdc\x3e\x49\x30\xf3\xc0\x5e\xee\x1c\x31\xf2\x2c\x41\xf9\x9c\x94\x7e\x11\x94\x69\x46\x3e\x17\x60\xda\xc5\x5a\x55\x9c\xf1\xba\x38\x43\x97\x4a\xf2\x8b\x76\xf0\x25\x39\xb4\x4e\xa6\x9a\xda\x62\x26\xe9\x28\x61\xaf\x92\x26\x7b\x68\x2d\xf3\x18\x66\xdf\x07\xc3\x27\x95\x19\x5b\x70\x91\xc9\xcf\x0f\x82\xdc\xeb\xcc\xc0\x22\xb1\x11\x96\x9f\xbc\xe7\x82\x90\xc8\x3e\x3a\xa9\x03\xfe\x13\xef\x2a\x81\x60\xea\x39\xe0\x40\x70\xe7\x1d\xa1\x14\x75\x1e\x1c\x08\x5e\x7b\x7d\x23\x4b\x3f\x51\x53\x29\xd2\xae\xff\xc4\xd4\x7b\x2e\x48\xa4\xdd\x60\x4a\x4d\x6d\xf3\x74\x67\x1a\xd8\xb7\x7e\x44\x4d\xb3\x06\x5a\x94\x8b\xb4\xd8\x5f\x20\xb9\xc1\x22\x65\x6d\xa6\x29\x76\xf4\x1a\x77\xfd\x6d\x02\xef\x05\x89\x6d\x17\xf8\x33\xc6\xae\x2f\xc9\x8b\xa2\xe4\x13\xcd\x5e\xc6\x88\xab\x7d\x6b\x10\x8d\x11\x8c\x95\x3c\x94\xc2\x41\xab\xad\x90\x1d\x95\xa3\x99\xb0\xff\x13\x8b\xe4\xe5\x4f\x2c\x92\x77\x49\xbb\xeb\x13\x1d\x94\x35\xdf\xe4\x71\x23\x4e\xb7\xe4\x5d\x52\x57\x64\x07\x34\x85\xfb\x65\x49\x50\xf8\x8e\x1a\x72\xdb\xe7\xac\x6b\x58\x49\x51\xa8\x59\x9e\x28\x86\xa3\xa3\xe8\x4e\x63\xba\xd2\xea\x49\x7a\xbe\x1c\xf9\xf5\x82\x6a\xf5\xfb\xc4\x5e\xb8\xad\x9e\xa4\x53\xf8\xbe\x8c\x57\xd6\x17\xc9\x1d\x98\x1d\x18\x63\x3e\xe8\xbe\x19\xf8\xc0\xe6\x93\x2c\x3e\x83\xeb\x76\x46\x98\xf2\xff\x3e\x41\xad\xa7\x43\xf1\x23\x2d\xda\x26\xcb\xf9\xd0\x06\x7c\x46\xbe\x27\xf5\xef\x88\xe7\x70\xbe\x68\x38\x4e\xec\xa7\xe6\x2d\x20\xfc\x04\xfb\x0f\xb3\x37\xce\x34\x7c\x48\xc8\x45\x62\x88\x81\xc2\xf3\x76\xc1\x6b\x89\xc2\x06\x4f\xa4\x14\xde\x24\xf6\x90\x09\x21\x3c\x4f\xc8\x8f\x84\xc2\x0f\x4d\x3a\x34\x3b\x26\x59\x3a\x3a\xc9\x0e\x9d\xa4\xb8\x5d\x3c\x71\xa2\x14\x5e\x67\xd0\x1a\x39\xc2\x95\x91\x0b\x07\xba\xf8\x0f\xb7\x41\x06\xae\xd2\x45\x1d\x26\x7c\x4c\x1a\xcf\x70\xb8\xa0\xf0\x3e\x61\xf8\x16\xd3\x13\x3b\x14\xbe\x26\x8c\x84\x9a\xa1\x00\xf9\x53\xc3\x58\xc3\xeb\xc4\xa0\xfc\xa7\x86\x73\x0d\xef\xf3\xe7\x89\x86\x37\xf9\x73\x47\xc3\xc7\xfc\xf9\x46\x43\x20\xb2\xe7\xa9\x86\x24\x7f\xb6\x46\x4c\xc3\x90\xac\x2c\x48\xe9\x69\xc5\x70\x53\xf5\x83\xd2\xa6\x6d\x49\x14\x4d\x21\xc4\x33\xf2\xb7\x49\x16\x21\xf3\x79\x85\xe9\xf3\x15\x24\x5c\xdb\x6f\x16\xc1\x97\x55\x8a\xc7\x83\xbf\xe5\x29\x08\xc6\x9e\x84\x20\xf2\x34\x04\xf7\x98\xb6\x0e\xbe\x25\x6c\x2a\xe1\x53\xe3\x86\x9c\x91\x6f\x09\x3c\x70\xe5\xad\x0f\x80\x7f\xf1\xd6\x07\x29\xfa\x4f\xfe\x4c\xd8\x23\xf7\x3f\x1f\xc1\xef\x09\x9b\x48\xf8\xa3\x15\xbb\x33\x32\x23\xef\x91\x58\x31\x80\xb6\x85\x0f\xf9\xdd\x2e\x71\xd0\xdb\xe5\xf2\xf9\x1c\xcf\x3a\x8d\xa6\x7f\x87\x56\x27\xfc\x95\xa0\x86\x4e\x31\xbf\x27\x5f\x7d\xd0\xdf\xf1\x36\x06\xd5\x33\x16\x18\x7b\x02\x84\x87\xc2\x49\xb5\xb5\x8d\x42\xb2\x81\x59\x29\xdc\xce\x7c\x6e\xe4\x69\xf1\x46\x98\x37\xc2\x20\x95\xfd\x1c\xdb\x17\xe3\xd2\xf7\x7c\x49\x24\x87\x12\x58\x96\xfa\x48\xb8\xe3\xa1\xcf\x84\x5b\x24\x6b\xc4\x6a\x7d\xf4\x55\x09\x37\x00\xfc\x39\x00\xee\xfa\xc0\xdd\x00\xb8\x3b\x06\xee\x0a\x9a\xbf\x37\xd0\x7c\xd4\x91\x72\xe7\x7d\xe6\x64\x81\x98\x19\xc9\x1d\xb2\xc4\x7e\xd0\xa7\x86\xe5\x02\x4a\x01\x44\x90\x75\x6b\xb1\x8b\x29\x84\x59\x9e\x89\x05\xb4\x4c\x79\xd6\x75\x8e\xa1\x30\x0a\x82\x19\x41\x81\x14\x66\x5f\x83\x10\x57\x52\xf3\x06\x5e\xdf\x10\xf1\x96\xc1\x37\x15\xa2\x04\xa2\x84\x16\xc1\x37\x1c\xd3\x73\xf9\xf6\x1b\xce\xf8\x51\xe9\x31\x1e\xfb\x2e\xc6\x3f\x25\x74\x91\xaf\x5f\x12\xc5\x33\x8b\xfe\x96\x68\x3b\xf9\x01\x85\x68\x51\xa7\xc3\xbe\x4d\x3d\x85\xf7\x0c\x17\xc5\x6d\x05\x4c\x50\x02\x8a\x6c\xd4\x82\x68\x1a\x9f\x45\xbd\xa8\x6a\xaf\x91\x34\xae\x40\x7d\xd9\xeb\x93\x6a\xa6\x34\xa5\x90\xf0\xc5\x98\xb7\x8d\x81\x4d\x8c\xdc\xed\x66\x4f\xe3\xca\xb3\x30\xf2\x2d\xef\xce\xfc\x44\x4a\xb4\x0f\xbc\xb4\x6d\xc7\x78\xca\x2e\x86\x01\xce\x6d\x84\x73\x6b\xe3\x0d\x7d\x9c\xdb\x3a\x5a\x56\xfd\x0a\x0a\x2a\xc1\xef\x9f\x04\xa0\x30\x95\x43\xbe\xf0\x7d\x5c\x78\xcc\x32\x92\x66\xd9\x19\xb0\x23\x8e\x17\xe7\x03\xc6\xb1\x23\x8e\xb4\x49\x04\xe3\x38\xc4\x31\x85\xd0\x10\x0f\xf8\x8c\xff\x6c\x13\x2c\x60\x91\x19\x88\x60\xe8\x3c\x31\x58\xc4\x35\x0a\x0c\x11\x91\xe2\x20\x0e\xf8\x7f\x6b\x1e\xc7\xf9\x3c\x8e\x97\xe7\xd1\x4c\x03\xe6\x7b\xc2\x9d\xec\xc3\x94\x19\xa4\x6f\xcc\xde\x86\xc9\xd2\xde\x1e\xe0\xb4\xf8\xf6\x6e\xdb\xe2\x8c\x6a\x9b\x60\xa0\x98\xd1\x2c\xad\x62\x36\xa3\xd5\x86\x01\x76\x1e\xb1\xc0\x1d\x63\x96\x19\x01\x78\x4d\x11\x30\xf4\x0b\xa6\x2c\x44\x14\x42\x44\x21\x5c\x9a\xd9\xc0\xf5\x21\x28\x67\x36\x32\x4b\xe3\x06\x10\x19\x90\x95\x9d\x6c\x68\x3e\x5e\xc2\xa5\x3a\xab\x01\x5f\xe1\x44\xcb\xa7\x8f\x9b\xa9\xe3\x66\xda\xea\x81\x8e\xf6\x26\x78\xa7\xdb\xb5\x0f\xbc\xfa\x76\x9c\xcd\x7f\xfe\xab\x34\xed\x38\x37\x82\x0f\xef\xf9\x57\xce\xeb\x9a\x5e\xaa\xb4\x3a\x6a\x5d\xe3\xa2\x39\x89\x19\x5c\x0d\x79\x22\xb7\x8a\x7e\x89\x46\x2a\x1e\x22\xdc\x45\x3e\xae\x7e\x50\x90\x7b\x92\xa7\x46\x2f\xdd\x20\xbc\x69\x32\xac\x1b\x26\xc9\x0f\x3a\xb0\x83\x28\x07\x1f\xb3\xa8\xba\x6a\x8a\x43\xe4\xf2\x72\xa1\x38\x89\xcc\xde\x89\x8b\xb5\x88\x92\xda\x60\xed\x3a\x44\x1c\x2f\x3c\xd1\x5f\x28\x8a\x92\x14\xe2\xe5\x38\xe8\x86\x78\xd4\x28\x69\x38\x74\x56\x98\x14\x5e\xe1\xc8\x95\x1d\xf9\x3e\x5e\xd7\xdb\xeb\x97\xf3\xc8\xf3\xb5\xae\x0c\x9f\xdb\x6f\xe2\xe1\xd4\x44\x66\x6a\xa2\xbc\x2c\x36\x53\xa3\xca\xa9\x89\xf3\xa9\x09\x59\xbc\x30\x35\xb1\x6b\xfe\xe7\x43\xec\x06\x30\x23\xb1\x61\xbb\x31\xb2\x96\xb6\xe9\xb1\x44\x9a\x55\xe5\x4b\x53\xd4\x5e\x3c\x23\xa1\x79\xe7\x93\xa0\x22\xcc\x91\xda\x0d\xfd\x84\xcd\x13\x98\xbb\xd1\x1e\x7e\x69\xde\x5e\xd9\xcf\xbc\x67\xf3\x53\xa5\xc7\xda\xde\x41\xb6\xd4\xc9\x14\x0e\x4b\x97\xf9\xb6\x44\x7b\x64\x9c\xa6\xa4\xb8\xf8\x97\xd3\xd6\x08\xa7\x4b\x17\x74\xc4\x0d\x1d\x04\x94\x7a\xd5\xf9\x51\xbc\x18\x56\x36\x05\x01\xad\x4e\x24\x05\x7f\x79\x9c\xb9\xc9\x81\xf5\x55\x29\xf1\xb4\xc1\x51\x97\x12\x4f\x2f\x30\xc3\x3c\xa8\xdd\x88\x1e\x6d\x25\xde\xb4\x5d\xa6\x2a\x92\x79\xfa\x75\x99\x25\x51\x60\xf6\x52\x9f\xe3\x5b\xef\x96\x08\xf3\x24\xf0\xeb\x1f\x29\x85\x9b\xfa\x96\xae\x7f\x7b\x79\x2c\x82\x78\x2c\x3e\x1f\xee\xbf\x88\xaf\xae\x63\x89\xa9\x1f\x5b\xbe\xc2\x0c\x93\xd6\x4b\x02\x17\x3a\x77\x94\x8e\xac\x26\xef\x65\xbe\xab\x3c\xae\x7c\xdc\x3e\x5d\x7f\x24\xe0\x30\x27\x4b\x52\xa7\x8d\x82\xab\x8d\x56\xdb\xed\xae\xe3\xdf\x5a\xac\x03\xaa\x42\x37\x1c\xcd\xb5\xaa\x87\xb5\x30\x63\xab\xc7\x6d\x37\xbc\x92\x29\x3d\x63\xb4\x78\x30\x3b\xe5\xc0\x61\xc2\xf1\x7b\x16\x0b\x51\xb9\x9d\x16\x3c\x41\x34\xb9\x8a\x6b\xbc\xbc\xc8\xab\x9a\xb3\x45\xe5\xea\x22\x5e\x2f\x0a\xad\xd6\xae\x8d\x82\xac\xed\xa8\x30\x15\x6b\x43\xe0\xc5\x85\xb6\xb1\xb3\x6d\xbf\xcd\x5a\x10\x69\xa3\x5e\x3b\x40\x44\x36\x87\x8f\x1c\x33\xdb\xdc\x98\x0e\x44\x98\xf9\xc3\x58\x05\xe1\xf2\x91\x70\x7d\x4f\x50\x0a\x66\x0e\xf0\xde\x77\x70\x45\xdd\xce\x28\x4e\x3c\x8c\x67\x1d\x73\x88\xcd\x56\x37\x40\xba\xf6\x5b\x28\xd4\x80\xda\x87\x7b\x7b\x3b\x0b\xce\x79\x43\x58\x5b\x11\xc5\xfe\xd2\x98\xbc\xbf\x27\x30\x00\x7c\xf5\x67\x02\x9f\x12\xe2\xfc\xfd\xf7\x08\x8d\x4e\xe9\xf2\x7d\x6a\x8f\xd8\xfc\xd1\x3d\xc9\x7c\xe7\x36\x42\x73\x46\x3e\x27\x78\xc3\x0f\x6d\x96\x03\x4d\xbd\x7b\x62\xc6\x71\xa0\x29\x98\x61\x75\x38\x7c\x4d\xe0\x07\x91\xf0\xc0\xf7\xbd\x03\x0d\x9c\x7b\x98\xab\xf0\xca\xd3\xae\x9f\xd6\x37\xc0\xdb\xc4\x13\x2e\x4f\xe1\x8a\x67\xd7\x6b\xce\x78\x11\x92\x66\x9f\x76\x52\x98\x35\x8d\xe4\x1c\xe5\xcf\x52\x52\x85\x3c\x49\x81\xfd\x46\x33\xc7\x58\xff\xfa\x5d\x6b\x63\xce\xd6\x0a\x36\xcb\x82\x27\xb5\x82\xad\xb2\xe0\x69\xad\xa0\x5f\x16\xec\xd4\x0a\xf2\x2f\xc8\xae\x9d\xf1\x85\x4f\xb7\x5e\xf3\x45\xfd\xfc\x8a\xa7\x29\xdc\xf2\xd5\xd7\x9a\xee\x5a\xca\xf3\x6b\x4d\x97\x2d\xe5\xb9\x4f\xeb\x59\x4b\x79\x7e\xed\xe9\x05\xcf\x0c\xf0\xc3\x55\x0a\x51\x6e\x5e\xcf\x8c\xe1\xf9\xdd\xe3\xe0\x0f\xbc\x00\xfc\xc7\x9e\x80\x80\x1b\x43\x34\x31\xd6\xf6\xcc\x9a\xa1\xaf\x5a\x19\x8e\xb2\x7e\x9c\xec\xe2\x0a\x7e\xaf\xd7\x3a\x61\x8e\x38\xbb\x4e\xe0\x82\xb3\xf7\x02\x0e\x9a\x30\x5e\xbb\xe0\xa4\x3c\x40\x7e\x62\x0f\x90\x69\x0a\xfb\x9c\x3d\x87\x97\x9c\xfd\x01\xef\x38\xd3\x12\x8e\x1b\x1b\xcb\x9e\xe3\xa4\x70\xbf\xa4\x24\xd9\x0f\xb5\xe4\x79\x87\x1e\x9d\xfc\x3d\xbd\xf3\xe3\xd3\x47\xae\x16\x53\x64\xa8\xc5\xd6\xcd\xae\x4e\xf7\x8a\xa3\x27\xc5\x98\x32\x7b\x41\x61\xac\x32\x7c\xe7\xec\x55\x02\x1f\x1a\x3b\xc7\x2f\xeb\x0d\xec\x7a\x36\x9f\xd5\xd7\x4e\xbf\x14\xcd\x8f\x91\x53\xf8\xc1\xd9\x8c\x1c\xf1\xc5\xcf\xbe\x3f\xdd\xfb\x22\x2a\xe8\x7d\xe0\x24\xfb\x9e\xa6\x18\xaf\x71\xbd\x76\x15\x4f\xf5\xda\xd3\xb5\x71\x74\x16\xe9\x29\xe0\xd7\x6a\xcf\x62\xbd\xe6\xf4\x8e\x39\xb1\x0d\x69\x36\x9e\x7b\x4e\x9c\xbe\xeb\xf4\x2a\x81\xae\x6e\x67\xf4\x81\x93\x7f\xed\x4b\xfb\xa1\xe9\x70\x12\x73\xed\xad\x39\xff\xea\xc9\xde\xbf\x9c\x7f\x51\xef\x83\x20\xef\x38\x19\x88\xad\xdf\xac\x90\x80\x3f\x04\xf9\xce\x49\x88\x87\x8a\xcf\x39\xbb\xd7\xf0\x86\xb3\x9f\x64\xa4\x7f\xce\x89\xec\xed\xf6\x7f\x53\xbf\xed\xf6\x7f\x1b\x88\x2d\xf3\x4c\xf4\x06\xa7\xf8\xc3\x00\x17\x3d\xfc\x3c\xfe\x6b\xde\x92\x26\xb3\x8f\x0a\x6c\x2d\xda\x18\x04\xdb\xde\xc2\xd4\x73\xdb\x3b\x8c\xe9\xd1\xc0\xeb\x43\xc2\xc4\x30\x29\xd3\x49\xf4\x7a\x65\xfe\xa4\x6a\xe3\x24\x4b\x58\xb3\xfd\x64\x3e\xdf\x79\xbc\xc7\x2b\x0b\xaf\xd8\xa0\xff\x9b\xea\xf1\x8d\xed\x27\x45\x2e\x1a\x4c\x3a\x8c\x7e\x65\xdb\xd3\x86\xf2\x14\x4d\xe1\x63\x05\xd9\xea\xbd\xb2\xe5\x05\xb4\x87\xa1\xd4\x28\x03\x19\x33\x7b\x5d\xfd\xd6\xd4\xe2\x22\x44\x52\x8b\x33\xa1\x16\x96\x41\x55\xae\x8c\xd5\x48\x00\x17\x5a\xd3\x9e\xb3\x92\x04\x6a\x2b\x97\xc2\xfb\x46\xda\x35\x70\x73\x2c\xc6\x7c\xe6\x59\x08\x18\x67\xf6\x95\xb3\xbf\xe0\x6d\x53\xab\xf5\x19\xf9\xca\x61\x1b\x24\xed\x76\x09\x3e\x0f\xfa\x7d\x90\x74\x3e\xcf\x4a\xf0\x17\x4d\xe1\x73\x13\x5b\x97\x1b\x79\x26\x4b\xa2\x1e\x6d\xcf\xfb\x74\x83\xa8\x47\x83\x7e\x7f\xde\xa7\x3d\xf3\x06\x9f\x52\xf8\xd2\xb0\x35\x72\xbf\x36\xaf\x5a\xaa\x76\x65\xfb\xf9\x92\xbe\xe7\x84\xe7\xe4\xbf\xdc\xf9\xd6\x60\x67\x6b\x57\xec\xfe\x46\xc4\xc6\xe0\xe9\xe3\xbe\x11\x80\x4f\x76\xb7\xc5\xce\x6f\x84\x24\x7b\x5b\xf3\xf9\xfa\x5b\xa3\x9d\x8c\xf8\xc6\xc0\xe3\xb4\x47\x3e\x9b\x5f\x1b\x9f\x39\xc1\xca\xa5\x60\xfb\x20\x88\xec\xa9\x9e\xa6\x69\x2e\x9f\x92\xe2\x73\x42\x59\x95\xad\xc1\x1e\x1f\x21\x32\x9e\x22\xfd\xc5\xe4\x37\x9b\x4f\xf7\xf8\x7c\xbe\xf9\xd4\x98\x1c\xdd\x6e\xd6\x6b\x5e\x7b\x73\xf7\xf1\x93\x6d\xb1\x43\x17\xd2\xee\xd4\x20\xee\xf4\x9f\x3e\xde\x2d\xea\x14\x89\x7b\xb6\xfa\x95\x3a\x8f\x1f\x3f\xde\x15\xbb\x8b\x89\x48\x6a\x60\x06\xfd\xad\xdd\x27\x45\x9d\xdd\x46\x30\x83\xad\xfe\xf6\x6e\x89\xcf\xe3\x66\x40\x3b\xbb\x5b\x15\xa4\x9f\x34\x57\x7a\xb2\x35\xd8\x7d\x52\x54\x7a\xda\xd8\xdd\x66\xff\xe9\xd3\x9d\xcd\xa2\x52\xf9\x71\xdd\x1a\xa8\xcd\xad\x9d\x27\x8f\x2b\xb5\x06\xcd\xb0\x76\x37\x77\x77\xca\x69\x2a\xbf\xe1\x5b\x87\xf5\xe4\xc9\x8e\x9d\xcc\x05\x01\x5e\xdd\xa3\x57\xb1\xd4\xe7\xb8\x43\x8f\x8d\x81\x8a\xbb\x34\x4d\x61\x39\xe6\xa5\xf5\xfa\xd8\x77\x92\x7f\x71\x24\x3b\xde\xfb\xc8\xc9\x36\x85\x03\x4e\x9c\x0d\x87\x56\x5e\x6e\x56\x5f\xe2\x6f\x4a\xe1\x5b\x93\xed\x91\x8b\xbf\xdf\x88\x61\xb6\x3d\xb4\x2b\x3e\x35\x6c\x9c\xac\x5e\x1e\x24\x5a\x43\xb9\xfa\x8f\x8d\x05\x79\x83\x1c\x00\x71\x38\x76\x96\xf1\xf2\x9a\x90\xf5\x2a\xc8\x42\xad\x1f\x0b\xf3\x5e\xdb\x7a\xae\x01\xf8\x83\x53\x1b\x73\x72\x4a\x2b\xb5\x65\xd2\x70\xae\xdc\x4f\xb1\xd9\x5f\x16\x8f\xc5\xb9\xfe\xc6\x7f\xd2\x7c\x60\x9b\xf7\x6c\xf3\xa6\x2a\x1b\x59\x15\x33\xdb\xa7\x3f\x19\x58\x59\xfe\x41\x90\x1b\xf2\xc6\xd8\x73\xfd\xfc\xff\xed\x51\x25\x06\xb8\x7e\xe1\x14\xfe\x6c\xe4\xb7\x33\xf2\x21\x81\x4f\x1c\x4f\x20\x7e\x6f\xaa\x61\x23\x99\x8d\x12\xe5\x1c\x9d\xc7\xc9\x64\xbc\x26\x63\xbd\xe6\x8b\x35\x71\x75\xad\x67\x8e\xb1\xe0\x5e\x71\x38\x12\xc4\xf9\xaa\x62\x79\xb6\xb6\x7f\xf4\xe1\xc9\x6e\x7f\xb0\x16\xc6\xea\x8a\x6b\xc7\xf4\x6b\xd9\xf7\x1f\x7c\xd5\x39\xca\xc2\x45\x0e\x18\xdb\x73\x94\xbf\x38\x93\x12\x64\xd0\xa6\xdf\x09\x49\x14\x7d\x24\xa4\xbd\xb8\xaa\x82\x96\xdb\xc4\x3a\x60\x7f\x19\x75\x4e\x06\xb0\x09\x5b\x86\x22\x04\x66\x2a\x4d\x02\x76\x47\xfe\xe0\xd0\x07\x1d\x80\x30\xff\x51\xe0\x01\x9b\x40\xb0\xdc\x63\x35\x58\xc0\xd8\xa3\x3c\x80\xad\x4d\x90\xf6\xb3\xa4\x3e\x24\xf6\x04\x34\x1b\x88\x36\x16\x46\xf6\x51\x79\x51\x5e\x94\xc5\xb8\x8f\xa1\x64\x02\x94\x3d\xdd\x8f\x9a\x31\x36\xad\xe3\x9f\xa1\xf0\x17\x27\xea\xd1\xd6\x66\x61\xe0\xea\x32\xf8\x28\xc7\xcd\xe5\x43\xc9\x66\x24\x08\x40\x42\x87\x82\x62\x78\x43\x26\x0c\x98\x92\xe0\xb7\x4e\x6a\x7f\x6f\x1f\x7f\x8f\xa4\x87\xf9\x22\x5a\x70\xcc\x03\xa3\x6f\x96\x01\x61\x48\xaf\xc8\x11\xdd\xda\xfc\x4d\xb9\x02\x04\x0b\x03\xbb\x06\x5b\x9b\xa0\x37\x06\xf8\xe5\x32\x39\xfa\x6a\xcc\xd6\x33\xea\x29\xf7\x0c\x2f\x0e\xc7\x01\x24\xe8\x2b\xcf\x65\x1b\xae\xd0\x34\x20\xca\x0d\x69\xcf\xd8\x90\x7e\x00\x3b\x20\x7e\xd3\x66\xb1\xc0\xbc\x4d\x1b\x6a\x66\x2b\x8a\xc5\x14\x26\x01\x0b\x61\x1c\xfc\x24\x0e\xc4\xa0\x5d\x0a\xee\x19\xb9\x09\x8c\x9a\xfc\x70\x86\x07\x5e\xfa\xd1\xd6\xe6\xbc\x0f\xa1\x97\x7f\xa7\xc5\xda\x31\xc0\xbd\x5b\x32\xc1\x31\xe1\x0d\x84\xec\xde\x84\xda\x30\x83\xc4\x60\x0e\xa4\x0b\x0e\x82\xe6\x21\x1d\x9d\xc6\x09\xeb\xef\xc9\xe2\xac\xfb\x3f\xb6\x36\x31\x7e\x6f\x12\x80\x06\xb9\xa1\x2b\x27\xd3\x97\x64\x8c\xdf\xce\xd8\xd0\xa6\x07\x09\x1d\x10\xc5\xf8\x93\xc0\x18\xe1\x4d\xcb\xb5\x2e\xdd\x4e\x0a\x57\x6d\x4b\x9e\x9b\x77\xf9\xad\x88\xb3\x15\x15\x6b\xd7\x27\xae\x57\x54\xac\x5f\xe2\x6a\xc2\xaa\x62\x75\xde\x36\x12\x19\x5e\xb8\x6e\x33\xed\x7a\x83\x94\x62\x38\x5f\x0a\x77\x01\x7b\x06\x97\x8b\x5f\xd0\x5b\xb8\xb1\x3e\xd8\x63\x96\xae\x4b\x07\x5b\xa6\xbf\x41\xc2\xd4\xc6\x00\xa9\x0f\xef\xfa\xea\x62\x8f\x82\x66\xdc\xa0\xff\xac\x75\xb3\xdc\x92\xcb\x00\xfd\x9b\x1d\x0c\xb6\x5a\x51\xef\x2e\xc0\x68\xb3\x67\x01\xf4\xe1\x36\x20\x8a\x6e\x0c\xb2\x3b\x02\x87\x01\xfb\x0c\xaf\x82\x7f\x70\xbf\x11\x2d\xc1\xc5\x4b\x8e\xf7\xe4\x03\x91\x27\xfd\x53\x0a\x32\xfb\x50\xdf\x80\x52\x2f\x7f\xdb\x93\x27\x83\x4a\x91\x91\xe1\x68\x49\x1e\x35\xce\xbc\x75\xb9\xfc\x2d\xd7\xd6\xd6\xd6\x9c\xcc\xe9\xf3\xb7\x74\xac\x1a\x7d\x11\xb0\x23\x09\x07\x6d\x63\x75\xfe\x96\x7f\x4b\x62\x15\xf7\xde\x80\xf6\x1c\xba\xe6\xf4\x8e\x02\xb2\x1f\x64\x47\xea\xfb\x2d\x5d\xbe\xb4\x7c\x2a\x85\x97\xcb\xa0\x57\x45\xa7\xe4\x27\x3e\xe5\x21\x43\x45\xaa\xda\x8c\x32\xaf\x82\xcc\xe6\xca\x4e\x29\xca\x24\xf6\x36\x80\xba\xfc\xc8\x51\x7e\x90\x4b\x7c\x41\x14\xd3\x2e\xb7\xf1\xe6\x8a\xd2\x6e\x77\x46\x0e\x03\x98\x26\x66\xcb\x11\xfc\x20\x06\x04\x96\x66\xc4\xc8\x71\x9d\x5e\xe2\x39\x27\xff\x72\x7a\x49\xcf\xf9\xd7\xa9\x63\x73\x1f\x60\x74\x7e\x43\x72\x09\x1b\x3c\x63\x1d\xd7\xce\x89\x9d\x2b\x97\xd3\x9e\x73\xea\x0c\x2b\x70\xa3\x55\x50\x36\xbd\xec\x72\x9c\xcb\xed\x8d\x5e\xeb\x40\x8c\x4b\x67\x68\xc8\x88\x72\xfd\x91\x73\x7c\x2e\xd6\xde\x4e\x63\xe9\xbe\x44\x37\xae\x1b\x4b\xf1\x21\x34\x96\xfb\xc5\x34\x96\x4e\x2f\xf7\xaf\x7d\xc5\x7b\xdf\x9e\xb3\x54\xd5\x31\xb6\x5d\xc8\xa3\x89\x18\xe3\xd7\x58\xce\xc5\x5a\x18\x4f\x26\xf1\x6d\x24\xcf\xac\x85\x76\x1b\x90\x98\x9a\x5a\xb7\x7c\x36\xf5\x9c\xe1\x02\x19\x19\xd2\xc1\x01\x85\x30\x23\x2f\x02\x38\x08\x20\x36\x56\xa0\x64\x9c\x69\x16\x63\x48\x50\xc0\xd4\xb2\x97\xd3\x39\xe4\xd2\x98\xa3\xf1\x1a\x6f\x18\xc1\x6d\xa4\xcf\xd7\x64\xbc\x76\x1d\x4f\xa7\x91\x1f\x4d\x22\x1d\x89\xa9\xd3\xb3\x83\x6e\x1f\xdf\xba\x43\x6b\xa1\x49\x3e\x2e\xfe\x14\x97\x24\x5b\xfc\x10\xfd\x90\xce\x47\x15\xfb\x13\x71\x65\x3b\x32\xc3\xc6\xe4\x83\x6d\x90\x7b\x8e\x67\x86\x8a\x7b\xc6\x5b\x6e\x7b\x16\xdd\x08\x69\x21\x60\x3d\x87\xf6\xc8\x91\x11\x89\x17\x01\x6c\xc3\xd4\xb4\xcf\x5e\xfb\x78\xc1\x2f\x60\xe7\x12\x8e\x5b\x18\x67\xee\x6e\xbb\x0f\x32\x37\xe6\xf7\x96\x8a\x79\x2c\xd9\x07\x43\x52\xef\x82\x86\xf8\xed\xdf\x17\x5d\x01\xc7\x01\x71\x5e\x14\xba\x9e\x75\xfd\xaf\xe9\xe8\x4a\xac\x39\x3d\xd9\x73\x8c\x51\xae\x5c\x4e\xbd\xef\xf6\x0b\xa4\x06\x09\x0a\x3f\x02\x36\x96\xf0\x7c\x05\x03\xfc\xac\xe1\x47\x60\xa5\x24\x85\x37\x6d\xe3\xda\x04\x0c\x67\x83\xd7\x01\xbb\x92\xf0\xb1\xad\xda\x0e\x9c\x61\xb5\xf7\x8d\xbc\xe4\x63\x60\x75\xf0\xd7\x01\x5c\x68\xa3\xa4\x7d\x0f\xc8\x81\xb6\xca\xf0\xd7\x80\xf9\xe4\x5a\xc2\x21\x07\x9c\x10\x8c\xc3\xc2\x00\x2c\xf8\x1e\x50\x78\x6f\x56\xe4\x47\x00\x0e\x97\x32\xd6\x98\x53\x6f\xea\xc0\x9b\x80\xdc\x07\x59\x88\xb0\x29\x9c\x70\x5f\x4c\xca\xf7\xb6\xd5\xf3\x00\xce\xc8\x49\x1e\x1d\x05\xc5\x75\xff\xe7\x33\x07\x9c\xbe\x73\x4a\x01\xeb\x22\x5a\x47\xda\x20\xd4\xdc\xae\x48\x0b\x50\x6f\x98\xf7\x3d\xd5\x5c\xe9\xe9\x33\xed\xc0\x87\x20\x7f\x77\x26\xa4\x50\x5c\xc7\xea\xf3\xe1\x3b\xc7\x76\xf3\xb6\x65\xea\x1e\x67\x13\xfc\xd9\x10\x84\x69\x3b\xe6\x9a\x3b\x16\xab\x17\x81\xcd\x1b\x73\xcc\xe1\xb5\x46\x18\xe4\x2b\xf6\xfc\x25\x60\x9f\xe0\x5b\x13\x44\x32\x23\x5f\x02\x3c\x56\x90\x74\x34\x23\x7f\x0a\x18\x60\xb2\x0c\xda\x73\x1e\xf1\xeb\xe8\xd1\xcd\xc0\x49\xe1\x53\xbb\x52\xf2\x67\x2b\xc5\x64\xce\x5b\x24\xb5\x97\x49\x25\xfb\xd0\xef\x2b\xb4\x8e\xed\xaa\xd6\xf1\x47\xcb\x14\xe4\xbe\xec\xbf\x7e\xb2\x67\x64\x64\x36\xd7\x66\x0a\x2a\xca\x9c\xd6\x3a\x6a\x22\xb7\x4c\xa8\xa4\x20\x9a\x8a\xb3\xcf\xbe\x3b\x5a\xdc\x69\x27\x83\x9c\x44\x6c\x26\x81\x47\xec\x5e\x43\x10\xad\x0e\xb6\xe7\x11\x79\xf0\x5f\x7a\x02\xfc\x23\x8f\x70\x96\x80\x88\x48\xd3\x39\x4b\x12\xd9\x6b\x4b\x2f\x6b\xa7\x59\xd9\x2c\xee\x07\x8b\x3e\x70\x0a\x7e\xc7\x58\x5b\xa1\x27\x21\x78\xe9\x1d\x68\x08\xf6\x3d\x0d\xc1\x1f\xde\xfa\x20\x57\x71\x8d\x89\x12\x65\x37\xde\xe3\xa8\x3d\xb3\x4b\x10\x81\xf3\xfb\xab\x63\x07\x3a\x20\x21\x8a\xac\x5a\x13\x46\x36\x4a\x32\x89\xb2\x1d\x25\x94\x8a\x55\x46\x9d\x07\x09\x05\xbf\x65\xb6\x72\xa5\x70\xda\x52\x9e\x2f\xdf\x4d\xb4\xc2\x05\x41\x54\x96\xdd\x6c\x12\xb1\xef\x12\xc6\x11\x7b\x27\xa1\x13\xb1\x71\x44\xfa\x14\xce\xa3\xb6\x14\x82\x33\x32\x89\x9a\x7c\x15\xe3\x88\xd8\xcb\x6d\x96\x7f\x5d\xd5\xfa\xb6\x77\x0b\x9a\x41\xa8\x5f\x01\x3d\x23\x59\x8e\xa7\xd4\x28\x17\xb6\x8b\xb3\x88\xfd\x2e\xe1\x7a\x79\xda\xb3\xc3\xf1\x7c\x95\xdf\x98\x3d\x38\x89\xe0\x2c\xca\x5c\xbc\x46\xdf\x5e\x9c\x9a\x0a\x12\xe7\x51\xb3\x5f\x83\x64\x29\x6c\xae\x23\x9b\x0c\xc8\xa6\xb1\xb9\x8a\xc8\x9d\xa6\x30\x8e\x0c\x83\xd4\xb4\x92\x11\xe6\xb6\xd6\x47\x75\x34\x7d\xbc\x43\xd2\x4a\x2f\x88\x82\xbd\x69\x32\xfc\x24\xdd\x63\x3e\xbd\x64\x0f\xbe\xd7\x89\x20\xf0\x66\x11\x8c\xbd\xdb\x08\x84\x77\x17\x41\xe8\xf9\xda\x9e\x4d\x5c\x46\xf0\x2c\x82\x17\x11\x1c\x46\xf0\x2a\x62\x7f\x48\xe2\x98\x66\x0e\x85\xa3\x88\x7d\x90\x70\xd1\xda\xd9\x2b\x33\xb9\x47\x11\xcc\xc8\x4d\xf6\xcf\x38\x32\x12\x61\x1f\x83\x50\x27\xcb\x05\x2f\x13\x6a\x93\x35\x51\x38\x58\x31\x84\x8b\x08\xd5\xf9\x2f\x86\xec\x0e\x70\xd2\x9b\xf2\x1a\x64\x9c\x61\xe4\xd7\xb7\xec\x92\x12\x9b\xbb\x0b\x9d\x2c\xf9\xec\x9a\xb8\x0b\x84\x18\x8b\xb1\x53\x77\xd4\x3a\x07\x42\xdf\xc6\xea\x72\xcd\xee\xa5\x05\x8f\x2c\x1e\xac\x1e\x73\x42\xf0\x6c\x99\xba\xfe\xa5\xeb\xbf\xa5\xf8\x09\x4c\x65\x7e\x04\x02\xc2\xc8\xa6\xde\x2d\x1c\xb5\xb9\xa1\x91\xab\x3e\xce\x67\x29\x72\xc7\xbe\x12\xd3\xeb\x58\x4e\xc5\x5a\xa8\xe2\xab\x35\x7e\x1d\x19\xd1\x6f\xd4\xcd\xba\x5f\xd2\x79\xcf\x27\x61\xac\xae\xc4\x78\x2d\x51\x93\xac\x4e\x9a\xa2\x46\x4b\xbd\x69\x64\xa3\xe1\x29\xec\x37\x32\x4f\x39\x72\xb4\x4a\x84\xe3\x65\x69\xca\x52\x78\xd9\x5c\xcf\xed\xcc\xe7\x79\x4c\xeb\x48\xa2\xf1\xf2\xae\xb1\xa6\x90\x0d\xc1\x0a\x29\x1c\x37\x56\x2e\x52\xa5\x45\xb0\x6f\x0c\x16\x87\x39\x78\x3e\x71\xdf\xc4\x5c\x32\x83\x91\xa8\xda\x91\xb2\xb6\x61\x0c\x45\x24\xc5\xf7\x56\xb2\xc1\x1d\x75\x8f\xfb\xab\x63\x99\xe4\x87\xa8\xd1\xec\xe3\x81\x35\x49\x6c\xbc\x5c\xf0\x02\x0f\x18\xbe\xa1\x89\xfa\xbd\x91\x87\xcc\xc8\x71\x94\x5d\x00\xf4\x69\x0a\x36\xf5\x4b\x91\x6f\x08\x2e\x34\xd9\x8f\x6c\x46\xb9\x75\xbc\x28\x88\xf7\xe8\xe0\xbe\x9a\x83\x68\xa1\x92\xce\x6b\x64\xa1\xe1\xf0\x32\x22\xc2\xbe\x29\xf2\x1a\x99\x77\xca\xbe\xb3\x89\x8f\x00\x3d\x8e\xc3\xc2\x93\x74\x1b\x10\x4e\x47\xce\x28\x57\x95\xbb\x0e\x70\xea\x39\x4e\x0a\x3f\xda\xf8\x9a\xad\xf8\xc8\x31\x63\xf8\x86\xb9\xa3\xf3\x7c\x4b\xbd\x0f\xa6\xb7\x0a\xfc\x03\x83\x6d\x1c\x81\x86\xcf\x36\xac\xe8\x79\xab\xfc\xb5\x12\xe3\x4d\x2e\xc7\x5f\xff\xa4\xe2\xc7\x9f\x88\x9e\xf7\x2d\xe5\xf9\x29\xf7\xd7\x9f\x88\xb6\xb7\xad\x24\xf2\x83\x28\x78\xe0\x87\x5e\x11\x37\xf1\x3c\x81\x1f\x09\x18\x22\xc8\x6e\x56\x7f\x8e\xfe\x4f\xd2\xbc\x99\x3d\x30\xca\xc3\x6d\x28\x7a\xf6\xb2\x54\x6f\x5f\x5a\xb6\x9b\x9f\xc2\xb7\x66\xea\xf4\x55\xf9\x09\x43\xff\x69\xcf\x92\x8c\xe3\xd8\x20\x8f\x28\x80\x7d\x8c\xd9\x88\xac\x6a\xfd\x25\x02\x85\x37\x31\xbf\x51\x6a\xef\x82\xda\xc3\x8a\x9e\x32\x7f\x52\xf8\xd4\xd6\xfd\xc8\x79\xc8\xc9\x06\xd0\x09\xf1\x45\xc3\x37\xc3\xa2\x69\xcf\x49\x1d\x24\xa2\x3f\x71\x3d\xb7\x53\xf8\x1d\x35\xa9\x3f\x9a\xa3\xc0\x24\x43\x65\x6f\xb5\x88\xc8\x44\x92\x99\x10\x19\xb3\x33\x09\x2a\x66\x2b\x59\xf6\x8a\x6b\x48\x0b\x67\x6b\x8b\xc7\x38\x5b\x69\x0a\x3a\x66\xdf\x40\xc4\xec\x4f\x48\xe2\x55\x19\x22\x1c\x27\x4f\x11\x91\x5d\xcd\xe4\x31\xfb\x02\x41\xfc\x93\x13\xef\x07\xbe\xef\x71\xe0\x07\x9e\x02\xce\x3d\x01\xbc\xef\x69\xe0\xdb\x46\xd5\xbb\xb2\x41\x13\x51\xdc\x1e\xbb\xff\x5a\x90\x84\xce\xe7\x33\xc2\x63\x70\xfe\x7f\x66\x53\x2f\x44\x26\x18\x3e\x24\x62\x70\x3c\x27\xbb\xe8\xcd\x33\xe7\x03\x47\xe7\x43\xbd\x72\x9e\x93\xf1\x35\x27\x33\xf2\x49\x40\xd0\x1b\xe0\x35\xc0\xcc\x1b\x13\x2d\x25\xf0\x8c\x59\x94\xd3\xd7\x85\x26\x37\x24\x88\x51\xd4\x26\xb1\xfd\x9c\x50\x9c\x9d\x1d\x54\x23\x9f\xb2\x4a\x09\x1c\xe8\xa2\x94\x42\x1c\xb7\x25\x92\x7c\x2d\x0c\x2f\xab\x77\x9b\x64\x83\x7a\xe4\x40\x9e\xb5\xc1\x6f\xb8\x94\x7b\x49\x22\x8b\xcf\x27\x61\xdd\xba\x0a\x6f\x2a\x26\x31\xfe\xaa\x84\x47\x62\x35\x8c\xb7\xca\x3e\xc6\x0f\x61\xdc\x1c\xe3\xff\x5a\x18\x5d\xb5\x8e\x8d\xc8\xb0\x19\x39\x59\x58\x7c\x3d\xf7\x65\xe9\x1d\x8f\x4d\x37\x18\x25\xf5\x49\x40\xd2\x43\xc6\x8d\xd7\x5b\x93\x18\x12\x54\x07\xeb\x55\xed\x0c\x19\x74\xfc\x65\xca\xb3\xc8\xa8\x45\x64\x74\x86\xcc\xff\x72\xb2\x53\x8d\x5a\x6e\xa1\xca\x9d\xe4\xb0\x8a\x8c\xe8\x0d\xcc\x8e\xb2\xa8\x88\x6a\xa6\xcb\xac\xa2\x41\x05\xe3\x18\xe3\x66\x87\xa0\x8e\xc1\x39\xd7\xfa\xda\x7b\x94\x9b\x97\x7e\x0c\x7d\x3b\xf5\x8f\x0d\x23\xf0\xca\x3a\xd3\x5a\xa5\x81\xad\xf4\x04\x2b\x19\x4d\xe1\x26\x66\x5a\x13\x27\x8c\x03\xbc\xb8\x34\x89\xd9\x1f\x0a\x3a\x31\xfb\x4b\xc2\x79\xd3\xaa\xd8\xb1\x21\x33\x0e\x5e\x78\x17\x9a\x7c\x8a\x88\x76\xf9\x21\xad\xa4\x35\xbe\x27\x3f\x88\x46\x66\x8d\xb9\x14\x62\xeb\x73\x98\xc4\xa0\x5d\xff\x29\xbc\x21\x12\x3e\xa0\xc8\x34\x33\x70\x11\xc1\x91\x20\x7f\x46\x14\x6e\xe2\x5c\xa4\x6e\xf8\x5c\x6d\x5c\x71\x1d\x9c\xe3\xcd\xab\xec\xc2\xee\xd5\xf2\xaa\x54\xf3\xae\xaa\x62\x7f\x65\xce\x4b\x0c\x99\x33\x6b\x92\x19\xc8\x59\x61\x3f\x3b\x89\xc0\x23\x9f\xb3\xb8\xdd\xdc\xb9\x8a\x9b\xaf\xcf\x23\xbf\xb1\x12\xe2\x3a\x66\x9d\xd8\xe8\xff\xb3\xe6\x0d\x95\xf1\x46\xbd\xcc\x1b\x6f\xc9\x79\x8c\xee\xf1\x1f\x44\xc0\x03\xff\xe4\x69\x97\x1b\x9e\x26\x5c\xfe\x09\x50\xca\x9d\xc5\xd9\xb5\x15\x61\x66\x77\x64\xfe\xf5\xde\x10\xf3\xc7\x28\x00\x09\x5e\xe1\xa5\xd5\x7b\x87\x49\x35\x59\x64\x23\xfc\x6f\x11\x49\x68\xa5\x8b\xcf\x11\x1c\x69\x92\x50\xdb\x45\x01\xae\x50\x9b\xcd\x3a\x16\xad\x71\xb8\x8b\xe1\x11\x79\x8d\xab\x4a\x8d\x05\xa6\x7e\x4f\x84\x79\x8d\x29\xe8\x5a\x39\x3a\xd2\x93\xff\xd5\x5b\x08\xcf\xa9\x3b\xa5\xd7\xce\xc8\x89\x55\x79\x24\xbf\x12\xce\x69\x1e\x3d\x52\xcb\xb3\x50\x48\x57\x01\x9f\x6d\x72\x25\xeb\xa4\x07\x07\xf7\x19\x91\xee\x37\xab\x2d\xdc\x35\xed\xad\x75\x94\xee\x97\x71\x96\x2e\xe4\x59\xeb\x0e\x80\xc4\xee\x81\x6f\x1e\x41\xe7\xf8\x57\xb8\x8b\x89\xc0\xaf\x00\x38\x0e\xf5\x5e\x11\x01\x8b\xd8\xd2\x2c\x54\x29\x93\xdc\x86\x99\xd6\x37\x8d\x6e\xdb\x2a\x49\x75\xab\x5c\xc6\x76\xab\xa0\x5e\xb9\xe1\xcf\x36\xc2\x48\x4c\xc6\xe5\x36\x79\xd1\x3a\xc9\x78\xd4\xd2\x52\x76\x9f\x25\x7e\xca\xa5\xe9\xe1\x32\x94\x5a\xb4\x2e\x9e\xca\xe1\x71\xa6\x8d\xc4\xdd\x18\x80\xc2\xfd\xb6\x1c\x8f\xab\xca\x87\x94\xc2\xab\xa6\x29\x6d\x07\x9d\x05\x6d\xe3\x81\x6d\xd1\x09\xe8\xec\x74\xc1\x48\x80\xe5\x0e\x75\xf9\x90\x52\x38\x6a\x9d\x8f\xaf\x9a\xdc\x92\x57\x71\x76\x4a\x65\x46\x7d\xd1\x22\x87\xfa\x7b\x45\xca\xf7\x7b\xfb\xed\xaf\x12\x63\x55\xc5\x7d\x5d\x54\xe5\xbc\x1e\x16\xaf\x32\x35\x60\x60\x43\x8a\x69\x76\xcd\x64\x68\xff\xaa\xfc\x53\xd0\xa6\x28\xb7\x7b\xf3\x2a\x95\x23\x8d\x04\xd3\x3a\x97\x9b\x21\x71\x31\xc9\x85\xcb\x4f\xab\xdf\xf2\xcd\xfa\x2b\x65\xb4\x70\x7d\x7b\x79\xaa\xd2\xd4\x68\x1e\x01\xfe\x0f\x9b\x67\xf7\x5e\x54\xb1\x79\xab\x70\xba\xdd\xe2\x31\x07\x1a\x21\xd0\x98\x45\xae\x0f\x21\x8b\x5d\xbf\xb8\x35\xe4\xbb\x1c\x6e\x98\x5f\x4d\x1e\x7d\xa7\xf1\xe6\x09\x3e\xc4\xf9\x43\x98\x3f\x4c\x61\x20\xb6\xf6\xe4\x68\x46\x8e\x62\x50\x1b\xdb\x70\x43\xbd\x5b\x72\x11\x83\x34\x52\x12\x7f\x63\x02\xe9\x7c\xaa\x96\x56\xf9\x8c\x9c\x88\x6c\x14\xd9\x1b\x23\x75\x0e\x56\x6c\x83\x8b\xb8\x54\x1b\xf7\xdb\x85\x9c\x6e\xe4\x2b\xa8\xb5\x1b\x31\x6f\xb6\xe4\x41\x0c\xa2\x67\x74\x9e\xc3\x18\xc4\x06\x12\xa8\xdd\x85\x2f\x97\xbb\x5f\xb8\xba\x51\x70\xea\xc0\xda\x04\x8d\xf6\x44\xfe\x29\xe9\x57\xc4\xa6\x45\xea\x76\x0d\x67\xb1\xf2\x07\xf3\xcd\xc7\xec\x23\x1c\x37\x6a\x09\xb7\xe4\x5d\x5c\xa6\x0e\xbf\x6f\x9d\x0e\x1b\x53\x8e\xf9\xa6\x11\xe4\xf7\x46\xe5\xe7\x55\xed\x84\x38\x13\xb0\x20\x98\xcd\xe8\x96\x58\x07\xd9\x7d\x4c\x62\xbc\xaa\xfc\x22\xb6\x07\xba\x03\xa3\x06\x1e\xc7\x36\xb3\x1d\x67\x36\xd6\x32\x60\x04\x63\x15\x8c\x56\xf8\x68\x73\xde\xa7\x1b\x03\x88\x18\xde\x51\x9e\x91\xfd\x4c\x97\x6d\x83\xc7\x11\x9e\x4d\x4a\x12\xb3\xdb\x80\x44\xd4\x10\xe0\x23\x0e\x3e\x8b\x1f\x09\x98\xb2\xdc\x5b\x87\xab\xf5\x32\x26\x08\xec\x4c\x83\x0a\xe0\x25\x27\xee\x0e\x66\xd8\xa5\x80\x47\xe8\x1f\x35\xa6\x08\x2f\x78\x70\x3c\x1a\x3c\xda\xfa\x8d\x84\x3d\xbf\x47\xe2\x8d\x29\x7d\x14\x53\xaf\x9f\x52\xf8\xd0\x44\x24\xd5\xa8\x13\xc3\x17\x64\x19\xd8\xc2\x5d\x7f\x3e\x5f\xe4\x05\x37\x95\xf4\xec\xd5\x84\x66\xc5\x4e\xca\x93\x62\x44\x46\x5b\x79\x90\x2c\x00\xc5\x62\xd0\xec\x0d\xd1\x46\x98\x70\x23\xf2\xf3\xcf\xd5\xa2\x07\x41\x57\x8e\xec\xad\x52\x63\xaa\x6b\x9b\x79\xbf\x91\x28\xae\x89\xa4\xee\x45\x1c\x49\x82\x59\x6b\x9f\xb7\x51\x85\x93\xe7\xbd\x30\x7f\x95\x51\x4c\x5e\xe5\xa1\x2f\x3f\x62\x72\x4b\x3e\xc4\x76\x19\xec\xe2\x66\xdc\xf3\x4d\x0b\xf7\xac\x03\xa3\x85\x75\xd8\x40\x56\xf9\x70\x7a\xee\xe6\xce\x6f\x5f\x04\x99\x91\xe7\xb1\x35\x3f\x7f\x23\x83\x0d\x54\xce\x5f\xff\x22\xce\xfd\x1c\xe5\x81\x77\x4b\xde\x58\x2e\x3f\x23\xdf\xe3\xc2\x9a\xfd\x18\xb3\x17\xf0\xfe\x9f\x2b\x6e\xcf\xaa\x8a\xd5\x8b\x8a\xe2\xf6\x02\xfc\xaf\xa8\xa2\xf9\x5f\x51\x45\x33\x7a\xc1\xa9\x21\xfc\x23\xa3\x07\xaf\xd2\xd5\x1a\x40\x26\x05\xc4\x9a\x9e\xe6\x7f\x5d\x80\xb7\xa4\x8a\x1d\x2f\x2a\x6b\xdb\x8b\x35\x5e\xe3\x25\x10\x7e\x8c\xc9\xbd\xcb\x7a\x3b\x8b\xf5\x9e\x2e\x42\x5a\x52\x0c\xaf\x16\x6b\xec\x56\x6b\x70\x96\x0f\xc8\x0c\x97\xe3\xe7\xa7\x8e\xbc\xd7\x82\x70\x97\xbf\xa0\xa3\x8e\x67\xed\xe8\x35\x07\xec\x0b\xee\xf2\x23\x0f\x79\xea\xa0\x0f\x5f\x8d\xa2\xf4\x31\x86\xd7\xb1\xad\x0e\x25\x0b\x6e\x34\x89\xce\xcc\x14\x72\x33\x3f\x29\xbc\x11\x14\x5e\x69\xc2\xdd\x20\xb0\x39\x71\xaa\x63\x6d\x51\x4f\xf3\x63\x9d\xaf\x31\xbb\x91\x64\xf0\xa8\x4f\xe1\x6d\x1b\xa5\x3d\x04\xe7\x9e\x84\x40\xda\xc3\xb4\xcf\x31\x93\x0a\xbe\xc4\xac\x0d\xb9\xdc\x1b\x87\x4e\xbb\x9e\xf3\x28\xf7\x12\x4e\x1d\xa8\x1e\x34\xbe\x35\x82\xe0\x75\xd0\x3c\xbc\xb7\x66\x78\x44\x31\x89\xba\x4f\x79\x4d\xe8\xd1\xc9\xc6\xc9\xdf\x7f\x9f\x3e\xa4\x84\xfe\xd6\x1b\xb9\xf0\xf7\xdf\x7f\xff\xfd\x9f\x9d\xf9\xff\xfa\xfb\xef\xe9\xe9\xa3\x33\x87\x1a\x46\xf7\x35\x06\xdd\x3a\x73\xd2\x0d\xc6\x29\xec\x73\xe2\xfc\xfd\xb7\x43\xad\x87\x3f\x8f\xfd\x48\xed\xf1\x2a\x46\x88\xc7\x0d\x5e\xfc\xd2\x2f\x48\x29\x7c\xcb\x95\xe6\x4f\xff\x74\x4b\xdd\xe3\xb7\x14\xb5\xcb\xdd\xce\xc8\x52\xcc\xae\xa1\x2b\xcc\xb8\x2c\x56\x18\x1d\x2f\x3c\xc7\x01\x24\x99\x3b\x0d\x66\x4d\x9c\x67\x93\x89\x63\xd6\xc5\x71\x52\xc8\x09\x49\xb8\x7c\x97\x52\xf0\x85\x77\xa0\xc1\x3f\xb3\xdf\x00\xcb\x95\xe9\x6f\x99\x32\x9d\x2f\x49\xa1\x4c\xff\xf2\x9e\x28\xf7\x33\x1f\x2e\xe1\x97\xfc\x1c\xbd\x9c\xce\x57\xac\xcf\x79\x6a\x76\x41\x42\x69\x36\x16\x9b\x94\xad\x71\xcb\x09\x78\x30\x43\x1c\xac\xda\xff\xbe\x58\xde\xd7\x56\x51\x6c\x18\xc3\x53\x6f\x7d\x00\x39\x48\x34\x4c\x44\xc5\x30\xb1\x3e\xd9\xc0\x43\x96\xcb\x33\xfb\x06\xcf\x50\xe9\x72\x3a\xab\x8a\x21\xf8\xe7\x0a\xe5\x4c\xd8\x60\x5d\x9b\xf5\xb5\xcd\x17\x87\xf8\xe2\x85\x57\xfe\x0e\x22\xf3\xe7\x25\xde\x7b\xe7\x3b\x10\xb2\xa4\xe7\xfc\xaf\x47\x99\x6b\x7c\xd8\x12\x16\xe5\x57\xad\xc6\xfb\x6c\x20\x13\xcf\x07\xfe\xce\x33\xd4\xe8\x23\x2d\x06\xf0\x10\x04\x1e\xe1\x56\xa3\x88\x02\x68\xcd\xa4\xe2\x06\x3c\x05\x1f\xaf\xfe\xa1\x66\xf1\x67\x0c\x21\x7e\x4c\x23\xa5\xf8\x5d\xf2\x05\x7a\x99\xb2\x19\xb9\x35\xdb\x32\xa0\x70\xc3\x66\xe4\x6d\x84\x5f\xcf\x5c\x44\x28\xc2\x4b\x7b\x13\xef\x4d\x04\xfc\xa5\x77\x63\x90\x9b\x56\x3c\x2a\x9f\x33\xb2\x79\x1d\xc1\x73\x4c\xdd\xf4\x23\xb2\x9e\x2d\x28\xcb\xbe\xda\xb2\x2f\x48\x40\xa7\x4d\x84\xad\xec\xba\x2a\xbb\xae\xa1\x5d\x57\x0d\x0f\x5c\x14\x09\x9b\xec\x7a\x2e\x92\x5b\x6b\xc3\x71\x53\xc3\x27\x5e\x7d\x70\xbe\xb4\xa9\x3a\x17\xc9\x70\xc2\xee\xc8\x2c\x86\xd0\x26\x02\x35\xaa\xda\x98\x4d\x4a\x61\x99\x4f\xcd\x4b\xef\x86\x4d\x5c\x0e\xbe\xf4\xec\x86\xce\x07\xfc\xd1\x0e\x78\x5c\x3f\xc9\xeb\xb0\x3b\xf2\xbe\x84\x1a\xd0\xe1\x98\x75\x96\xa1\xbe\xf3\xa6\xac\x83\x58\x95\x00\xdf\x2f\x00\xb4\xb6\xd8\x39\xbb\x23\x9f\x4a\x80\x46\xb0\xb0\xf3\x65\x80\x3b\xde\xf9\x02\xb8\xaf\x25\xb8\xa5\x0d\x92\xaf\x7a\x31\x31\x18\xac\xd1\xa4\xc9\x55\xbe\x87\xf6\x57\xab\x98\xea\x78\xbb\xd5\xa8\x0f\x19\xb2\x0b\x09\x2a\x6c\xbc\xd5\x27\xc9\xaa\xa0\xd2\x5b\xb2\x2f\xf3\x53\x34\xbb\x35\x1f\xac\x09\x02\x1a\x81\x8a\x46\xa0\x2a\x24\xf6\xbc\x0d\x3d\x20\xa0\x43\xfc\x8a\xb3\x3d\x16\xc3\x70\xaf\xec\x9d\x9f\x1d\x95\x45\xd3\x43\x71\x26\xee\x1c\x90\xe6\x2d\xff\x98\xa5\xa1\x4e\xc2\xd6\x7b\xd3\x19\xd6\x44\x33\xd9\x1a\x0f\x8b\x1f\xda\x24\x07\x92\xe0\x4d\x42\x0a\xca\x48\xab\x93\x53\x23\xe9\x8a\x23\x7b\xde\xda\x45\x18\x10\xf9\x08\x47\x1c\x34\x8e\x51\xa6\x10\x87\xff\xe0\x93\x50\x3d\xb9\x98\x97\xc6\x66\x3a\x10\xae\x1f\x61\xfe\xbc\xb2\xa6\xb0\x79\xc1\x40\x31\x05\xda\x86\x48\x87\xcb\x78\x96\x29\xc7\x8a\xb5\x8a\x43\x5c\xab\x19\xe1\x21\x04\xa1\x51\xd0\x77\xc5\x76\xf6\x5d\x36\x3f\x6c\xbc\x8b\xcc\x43\x90\x30\xd8\xde\xee\xd3\xde\xe3\xc1\xd3\xed\xdd\x27\xa0\x19\x51\x7b\xfd\x91\xda\x18\x6c\xef\xf6\x9f\xee\x7a\x8a\x3e\xc2\xa7\xc7\xf3\xbe\x31\x60\xed\xeb\xc7\xbf\x69\x48\x18\x11\x1b\x44\x60\x29\xde\x0d\x13\x8f\xb6\x76\x77\x36\xed\x8d\x31\xfb\xfa\xe9\xee\xbc\x4f\xa9\x79\x3d\xef\x03\x67\x62\x83\x6c\xed\xee\xfc\x96\xf4\x48\x92\x5d\x2c\x4b\xb2\x8b\x65\x68\x1d\xee\xfc\xc6\x7b\x9b\xf4\xd1\x60\x67\x6b\xde\x87\x88\x05\x3d\x12\xec\x0d\xfa\xa3\x2d\x6f\xe3\x69\xce\x21\x1f\xf8\xcc\xe3\x1b\x84\x0c\x76\xb6\x7e\x0b\x4c\xe5\x1d\xd3\xf3\x00\xf8\x67\x2f\x02\xff\xc6\x4b\x7a\xdb\xfd\xfe\x6f\xba\x47\x36\xf7\xa2\x51\xdf\x1b\xd0\x34\x85\x69\xeb\x1a\xfb\x21\x99\x91\x30\xb4\x96\x81\xcb\x67\x29\x85\x9b\xd6\xca\x78\x73\x6e\x73\xdb\xce\x6e\xd1\x0c\x76\xfb\x36\xa8\x66\x75\xbb\x81\xd8\xb2\x2b\x82\x97\xfa\x57\xd7\xdd\xed\x97\xe0\xf1\x03\x54\xcb\xd5\x33\xe1\xb6\x80\xff\xe7\xc5\x2b\x6e\xfd\x05\x05\x6a\xb0\xa0\xce\x6f\x2e\x5e\x4e\x5b\x90\x11\xdb\x0b\xac\x7f\x67\xe1\x82\xd9\xee\x02\x87\x7f\xbc\x70\x6d\xec\xc9\xe2\x0d\xb1\xa7\x8b\x97\xc1\x06\xfd\x45\x66\x38\x18\x18\x7a\x3f\xff\x85\x29\x2a\x88\x7c\x20\xb6\xec\x41\xc1\x2f\x2e\xb4\x7f\x93\x52\x38\x6b\xab\xbc\x14\xd2\x1f\x1a\x05\x3f\x84\x3e\x74\x28\xcc\x9a\xb6\x7c\x3e\xdb\x7b\x72\x74\x4b\x66\x21\xc8\x7f\xff\x7b\x00\x6f\x88\x32\xe4\x31\xe8\xca\x91\xb1\xe3\x15\xf5\x34\xf5\x30\x4a\xa8\x15\x4b\xdb\x18\x14\x7e\x59\x86\xc2\xdd\x8a\xbe\xde\x90\x19\xb9\x0d\x41\x6e\x7c\xc1\x2f\x25\xdb\x8f\x08\xd8\x8d\x7e\xb9\x02\xfe\x9d\x81\xef\xf4\x1d\x38\xe6\x19\x2d\x3e\x6b\x64\x6e\x33\x72\x19\x82\x21\xf5\xab\x10\xae\x43\x7b\xc2\xbc\xe1\xf4\xf0\xf5\x66\x53\x5a\xd4\xa5\x54\x94\x83\x85\x33\xe0\xcd\x05\x52\xdc\x5a\x20\xc5\xed\x05\x52\xdc\x59\x20\xc5\xdd\x05\x52\x7c\xbc\x40\x8a\x4f\x16\x48\xf1\xe9\x02\x29\x0e\xfa\x8b\xb4\x38\x58\xca\x8e\x39\xd8\x4c\x53\x32\x23\x9d\x7c\xcc\xb5\x41\xcf\xc8\xb4\x9c\x8b\xe3\xca\xeb\x9b\xf2\xb5\x57\x79\x3d\x6e\x7e\x7d\x5e\xbe\x76\xb3\xd7\x5b\x46\x9d\x2a\x5f\xff\xe5\xa4\xf0\xc2\xd0\xdc\x4d\x04\x3a\x84\x67\x21\x85\xc3\x90\xbd\x94\xf0\x6a\xb5\xac\xcd\xce\xcd\xa6\x0e\xd8\x68\xa7\x43\x98\x91\x24\x04\x11\xa2\x69\x67\xc4\x6c\x19\x27\xfb\x02\x25\xf2\xcc\xbe\x16\x72\x5c\xbe\xe4\xf7\xf6\x65\xa0\x04\xcf\x02\x6e\x51\x54\xf3\xbb\xec\x7d\x7c\x75\x25\xa4\xce\xdf\xde\x64\x02\x7c\xec\xd8\x24\x16\x87\xa1\x8d\x79\xd0\x46\x12\xf9\x03\xfc\x68\x1a\xcd\x2f\xd3\x1f\x99\x51\xe5\xb1\xbd\x36\x12\x67\xff\x65\x16\xcc\x0b\x17\x2b\xa8\xdd\xc6\x53\x7e\xfc\x70\x94\x05\x54\x66\xc7\xb5\x07\x2b\xb6\x70\xed\xb2\xcd\x7e\x8b\xf4\xc4\xcb\x48\x65\x70\x8d\x84\x32\xbd\xe3\x29\xde\xc6\x22\x9a\xbd\x42\x16\x33\x23\x07\x21\x38\xfc\xfa\x7a\x12\xd9\xcf\x8a\x3f\xc2\x78\x77\xc0\x58\xf5\xbe\x0d\x03\x2c\xad\xfe\x5b\x72\x81\xdf\x6d\x87\x23\x9b\xca\xee\x65\xc8\x64\x4c\x5e\x6b\x0a\xef\x56\x8c\x72\x46\x5e\x86\xd6\x31\x20\x8b\xaf\xa9\x1e\x87\x2c\x68\xc9\x09\x51\x7e\x74\xff\x81\xdf\x18\x8b\xf3\xce\x13\xc0\xef\x3d\x0d\xfe\xc0\xe3\xc0\x0f\x3d\x09\xc1\xcc\x53\xe0\x5f\x7a\x01\xf8\xd7\x1e\x7e\x0a\xe1\xbe\x1d\x81\x07\xfe\xd1\xd3\x80\x2e\x0e\x5f\xd9\x89\xfb\x1e\x1a\xdb\x7e\x2b\x85\x0f\x21\xbb\x25\xef\x42\x28\x55\xb5\xef\x21\xd8\x37\x99\x42\x77\x1f\x64\xbf\xad\xce\x77\x1f\xc0\xf7\x80\xdc\x87\xe8\x86\xf9\x11\xb2\xb7\x01\xf9\x10\x52\x78\x9e\xc3\x99\x6a\xae\x85\x03\x4b\x11\xf8\x75\x7e\xe2\x88\xbb\xeb\x48\x89\xb1\x93\x6f\xd1\xef\x41\x7e\x55\xdb\xe1\x81\x8e\x6e\x44\xb5\x64\x90\x95\x5c\x0b\x39\x8e\xe4\x59\xb5\x68\x73\x49\xe9\x3e\x0e\x88\xf3\x59\x5e\xca\xf8\x56\xae\xe9\xd9\xb5\xc0\x28\x3d\xfc\xdc\x4e\x80\xd1\xf1\x0d\xaa\xb7\x7f\x91\xb9\x3c\xde\x84\x6d\x57\x07\xfe\x6c\xba\x3a\x50\xde\xdf\xd7\x59\x37\xf5\x9b\x02\xaf\xf3\x49\x49\xae\x4d\x95\xb1\xd9\x8c\x6f\xf2\xe9\xcd\x83\xe0\x9f\xe7\x2f\xcc\x5e\x2b\x26\xbb\xd8\x8e\xe5\x9b\x72\xe3\x16\xef\xf2\x1d\x5e\x05\x9a\x71\x82\xe2\x55\xc9\x3e\x7e\x84\x66\xfc\xc7\x21\xcd\xff\x0f\x3e\x36\x11\x4d\x1e\x93\xd1\xb4\x7f\x1c\x50\x95\xa8\x34\xb4\x81\x34\xe4\xee\x30\x01\xaf\x43\xeb\xcb\x78\xdf\xc4\xd1\xcc\xe6\x7d\x9a\x47\x8d\x85\xec\xe1\x1b\xda\xc2\x01\xfe\x3b\xc6\x7f\xd1\xa3\x13\xbc\xc0\x30\x86\xb7\x2d\xf2\xeb\x33\x66\xf6\xfd\x38\x72\xd8\x7f\x39\x9e\xc3\x2c\x7e\x6e\x70\x8e\x1f\x74\xb4\x1f\xb9\x69\x6f\xe9\x40\x16\x5d\xf5\x36\xb4\xc6\xce\x97\x30\x8b\xf9\xfe\xd6\x82\x71\x1e\x06\xf7\x69\xc5\xf6\xb2\x49\x6f\x6a\xdf\x66\xfb\x33\xcc\xe2\xe9\x7f\x6f\x81\x9b\x4f\xc4\x1f\x2d\xe5\x4f\x72\x5b\xb0\x55\xe8\x3f\xe7\x04\xb5\xa4\xde\x3b\x7b\xef\x98\x82\xf4\xb3\x0f\xe1\xdd\x3a\xb0\xdb\xdf\x7e\x22\x76\x90\x87\x8f\x1d\xc0\x4c\x0b\xf8\xe3\xdc\x81\xad\xdd\xec\xf9\xca\xb1\x66\x84\x91\x20\x0e\x2a\x5b\xa7\x14\x94\xdf\xf2\xc1\x63\x15\x5d\x11\x63\x1e\x36\x97\xef\xf5\x33\x67\x91\xf2\x9b\xed\xce\xdc\xaa\xe1\x18\xe7\x69\xf3\x9c\x71\xcc\x73\x56\x31\xb1\xf9\x23\x31\xef\x8f\x92\x1e\x39\xe6\xf6\x99\xf6\x88\xee\x39\x6b\x0e\xa5\x5e\x02\xa8\x21\x0a\xeb\x83\x31\x48\x3b\x60\x87\x0e\xd2\xa7\x36\x63\x8a\xf0\xd9\xb3\x10\x12\x3f\x5b\x54\xde\x84\xeb\xc3\x17\x2f\xf1\x0d\x23\x34\xd3\xfb\xff\xe7\xee\x4d\x94\xdb\xd6\x91\x7f\xe1\x57\x51\x38\xfa\x66\xc0\x4a\x8b\x91\xb3\x9d\x13\x66\x58\xae\xc4\x76\x62\x67\x71\x12\x3b\xab\xe7\xcb\x4d\x01\x5c\x24\xc6\x14\x29\x83\x20\x25\x39\xe1\x73\xdc\x07\xba\x2f\x76\x0b\x0d\x70\x13\x49\xc5\x99\xff\xf9\x2f\x75\xeb\x9c\x72\x44\x12\x04\x40\xa0\xd1\xe8\x6e\x74\xff\xda\x65\x8e\x64\xb2\x94\x11\xc3\x30\x25\xa7\xd5\xbf\x36\xd5\xad\xeb\xf2\x17\xdb\x43\x1a\x3d\xb3\xc7\x92\xfb\xaa\x9b\x05\x84\xb2\x82\xb7\xf6\xad\x3d\xc9\x5f\xcb\x92\xbc\x7a\x9c\xb0\x7e\xb7\xc2\x47\xca\xe9\xf5\x8b\x1a\x0c\x5e\x2f\xa8\xc3\x5e\x6b\xd4\x8a\x5c\x07\xc0\x41\xe5\x1f\x6a\x38\xa2\x97\x26\xd8\x6d\x21\xed\xbb\x20\xb7\xf6\xb6\xad\xac\xf2\xe6\xb4\xc3\x2e\x11\x3c\x4b\x8e\x5d\x30\xd0\x55\xfe\xb8\xde\x45\xe4\xca\xd3\x1f\x8a\x8a\xbf\xfe\x54\x44\xa8\x67\x6c\x78\x07\xbc\x22\x2e\x83\x1f\x6a\x78\x63\x3d\xba\xa5\x2b\xa5\x60\x04\xe1\x24\xcc\x72\xb0\x7d\xf9\xec\x22\x00\x79\x57\x65\x4f\xa0\x67\xf6\x3a\x21\x1c\x53\xa5\x86\x0c\xc1\xd4\xbe\xe9\xa3\x83\x84\xc1\xa1\x20\x01\x43\x43\xb7\x9e\x18\x9f\xa9\x80\x88\xc2\x84\x94\x0d\x2d\x1f\x5c\x3b\x13\x37\x50\x01\xf5\x39\x2e\x1d\x1c\x66\xc3\x90\xff\xdf\xc2\x5c\x91\x91\x22\x0f\xc3\x90\xa4\x21\xff\x5e\xdb\x4f\x29\x99\x36\x88\x21\x67\xb2\x51\xbc\x59\x80\xd7\xbb\x36\x9e\xf9\x72\x51\xc4\xa6\xb9\x03\x5b\xe0\x30\x43\xc7\xed\x71\xdf\x18\x76\x93\x6e\xe8\x58\xa1\xc7\xb5\x2f\x45\x29\xe8\x2a\x04\x5d\xd9\x90\xd0\xc1\x44\x1b\x12\x83\xaf\x30\xcc\xa4\xfa\xd5\x9d\x64\x24\xc4\xb7\xa0\x42\x70\x3b\xf4\x38\x66\xb0\x16\xb0\x92\xff\x0e\x2a\x1f\xd7\x41\x2d\xba\x79\x4c\x61\xb3\xc1\x21\x82\xae\xe1\xe1\x39\x2c\xba\xb3\xa0\x5a\xbe\x26\x18\x92\x07\xcf\x51\x6b\x51\xee\x76\x54\xa1\x03\xb2\xfa\x73\x85\x0e\x20\xd5\x88\x77\xb5\xcf\xf5\x89\xe4\x80\x78\xb0\x60\x4a\x8d\xd1\xd7\x43\x7c\x40\xe3\x7f\xe0\xe8\xea\x08\xce\x25\x4d\x85\x1a\x63\xf4\x4d\x9c\xb1\x41\x97\xd2\xdd\x43\x8d\xd6\xe9\x0a\x84\xa0\x55\x46\x94\x65\x42\xb4\xb9\x57\x8e\x21\xcd\x32\x7e\x59\x26\x41\xb7\xc6\x2e\x5a\xdf\x49\x46\xb2\xb2\x4c\xd0\x74\xc4\xd4\x40\x99\xf2\xe3\xa8\x9e\xd6\x4b\x12\x97\xa0\xca\x40\xf5\xe4\x2e\xbb\x93\x8b\x59\x72\xf7\x70\x72\x69\xae\x78\xce\x19\xce\x31\x5d\xa3\xa3\xbd\xbb\x41\x58\x52\x7a\x5d\x09\xb9\x19\xc9\xc9\x8c\xc1\xce\x38\xad\x2b\x12\xc9\xe5\x9c\xdb\xb1\x5c\x17\x42\x2e\x8b\xac\x12\x4e\xb9\x5c\x10\x7e\xd1\x22\x06\x74\xd7\x9e\x33\x49\x14\x18\x5b\x23\x9f\x20\x75\xc8\x99\xcf\xf0\xc7\x86\x2c\x18\xc8\x9f\xe0\x96\x64\xb3\x41\x3e\xfe\xa0\x80\x15\x73\x82\x18\xd6\xcc\x61\x31\x5c\x0e\xad\x68\xcc\x13\x60\xd1\xec\x36\x89\x27\x98\x31\xcd\xb5\x39\xa6\xab\xe0\x2a\x03\x28\x30\x66\x73\x95\xc6\x93\x5b\x2a\xd6\x9d\x39\x49\x0c\x07\xcc\x71\x63\x38\xeb\x56\x1b\x06\x64\x45\x0e\x18\xec\x4d\xf7\x50\x70\xff\xf9\x13\x2f\x1f\x3e\x52\xd6\x86\x72\xf1\x60\x82\x0b\x7c\x72\xff\x1e\xe6\x05\xd0\xe5\xee\x3f\xc0\xab\x7d\x71\x7b\xcf\x16\xe8\x50\xf1\x84\xa9\x44\x00\x7a\x14\x8f\x88\x1c\xd3\xfd\x49\x66\x67\x35\x7a\xae\x09\x47\x83\x2c\x4b\x55\xfb\x10\x9b\xdf\xdf\x90\x33\x06\x58\x27\xba\xd5\x48\xf6\x67\xe3\x3d\xed\x06\x73\xce\x76\xa6\x6c\xf1\xd1\x5f\x41\x27\x95\xef\xcb\xe9\x73\x6b\xaa\x60\xd3\x32\x05\x59\xa9\x89\xbb\xc1\x6b\x8e\x88\x80\x32\xad\x97\x4a\x16\x22\xcc\x7f\x56\x2f\xc5\x8d\xc4\x4a\x21\xc1\xe8\xcd\x4b\x06\x14\x71\xc9\x4d\xf8\xce\x76\xe5\xb8\x69\xe7\x95\x6d\x78\x39\x9f\x0e\xaf\xdc\x12\xeb\x9c\xa2\xe7\xc9\x11\x03\x17\x97\x05\xa6\xc6\x6f\x22\x5d\xa8\x2f\x5b\x93\xef\x0c\x28\x12\x83\x45\xb3\x09\x09\x6f\x63\xde\xcf\x18\xa8\xe5\x9a\x65\x2e\x13\x8b\x41\xd8\x9f\xd6\x8a\x02\x2f\x4b\xb9\x8d\x32\x97\xe4\x5c\x0e\xbf\x02\x15\x96\xbd\x6a\xf2\x81\x1f\x7d\x83\x4b\x51\x0a\xad\x78\x02\x04\xce\x35\x25\xe8\x05\x8f\xad\xab\x95\xdd\xe4\x02\x01\x02\x9b\x6e\xd7\x50\x8d\x74\x42\x02\xc9\x0b\x71\xac\x43\x2d\x28\x9d\xb0\xed\x64\xdb\x0d\x54\x19\xe7\x07\x8d\x6d\xc9\xe3\x4c\xa0\x4f\xe5\x72\x3e\x92\xcc\xe5\x5a\x98\x40\x5f\x97\xf7\xdf\x60\x24\xa5\x6b\x02\x7b\x68\x73\xa0\x9f\xd4\xfd\x62\x1b\x79\x4d\x51\xe7\x9f\x55\x6e\xb0\x86\x08\x81\x99\x60\xf8\xed\xbd\xc7\x4d\x42\xde\xbb\x3b\xc5\x2c\x2e\xd4\xdc\xc7\x81\xf3\x2d\xf6\x10\x7c\x8b\xbe\xc6\xb3\xed\x35\xd3\x79\xe3\x20\x96\x9f\x27\xcb\xef\xed\xf5\x96\xff\x04\x72\x7f\x5a\x31\xf8\x73\xfb\x8d\x47\x7f\xf6\xbe\x10\x97\x2f\xdc\x6d\xbc\x90\x93\xd3\xba\xc4\x53\xf9\xe7\x8d\xfc\x73\x04\xd7\x84\xc3\x54\x16\x29\xd7\xe8\x60\x49\xac\x73\x6f\x5a\x0d\x00\x82\xa4\xe0\xbe\x55\x98\xb0\x61\xb0\x61\x26\x1c\x32\xa7\x05\xa3\x74\x48\xe5\x04\xfd\x3b\x39\xc7\x4e\x95\xa1\x4f\xca\xbe\xa6\x09\xaf\x58\x37\x87\x8d\xfe\xe3\x66\x30\xed\x8b\xd1\x6c\x40\x45\xbd\xe9\x4b\x22\x3a\x5a\x20\xd4\x1a\xc6\x58\xca\x9a\x0e\x19\x9c\x67\xa6\xa9\x93\x9c\xf2\x32\x35\xd4\x79\xa6\x13\xc5\xbc\x67\x55\xaa\x90\x57\xcc\x84\x23\x4a\x6a\xac\x24\x2f\xe3\x68\x5c\xa9\xc0\x92\x4c\x13\xae\x99\x8e\x50\xfa\x36\xc8\xf0\xf0\xf4\xec\xa3\x4d\x84\x13\xeb\x8d\x44\x0a\x37\x3a\xb8\x48\x58\xb4\xb0\xaf\x99\x59\xd4\x87\x3e\x6f\x7e\x43\x84\xdd\x90\x6f\x0c\x3c\x44\x8f\x57\x72\x2c\x2f\x0a\xb8\x1a\xa8\x60\x4f\x6d\x9d\x6b\x15\xa3\xb6\xc1\xad\x93\x5e\x23\x0a\x9e\xde\x40\xcf\x1e\xd7\x26\x9b\xba\x6a\x9a\xa3\x52\x51\xde\x90\x33\xa3\x2e\xde\x33\xa0\x28\xef\xe2\xd5\xa2\xdc\x0d\x33\x94\x2c\xb9\x72\xe6\xfe\x28\xe0\x0d\x03\x17\xa5\x5a\x2c\xf6\x9c\x62\x8e\x52\x78\xca\x1c\xf2\x24\x74\x44\x00\x3e\x27\x97\xa1\x63\x2c\x7d\x9e\x86\xa9\x38\x54\x92\xfd\x01\xf7\xa9\x48\xb8\x61\xc2\xbb\xf8\x5f\x97\xe1\x57\xe7\x87\x6f\x67\x1c\xb8\xfd\x24\x04\x6a\x53\x5e\xc0\xcb\x98\x5c\x86\xa6\x09\xc7\xbf\x1a\xf9\x52\x51\x42\x37\x2d\xd6\x8e\x03\xf6\x5b\xbe\xf5\x07\x83\x8e\xc8\xe8\xe9\x68\xee\x4b\x92\xc1\x58\x2c\x94\xb7\xdf\x6e\xb5\x2c\x76\x85\x1d\x95\xb1\x07\xc7\x18\x97\x00\x5a\x09\x90\x13\xdf\x38\xbe\xf5\x9d\xe7\x94\x60\xb2\x61\x13\x32\xf9\x5b\x58\xf4\x1a\x07\x95\x77\x41\x52\x94\x3c\xcb\x54\xd6\x0d\x84\x2a\x6e\x08\x9b\x1b\x49\x30\x6a\xea\x05\x23\xcd\x74\x82\xdc\x1a\xef\xab\xe7\x28\x42\x90\xea\x01\xf6\x50\xce\xd2\x31\x93\x9b\x92\xb5\xd1\x93\x76\x2c\xb7\x3c\x61\xb9\x9b\xaa\xb3\xa5\x67\x86\x5c\xd6\xbe\xea\xa6\xbb\x51\x73\x8f\x1f\xf0\xdf\xd5\x5d\x24\x45\xdd\x5d\x7a\x5d\x75\xf7\xbe\x4d\xb5\xce\xde\xe8\xaa\x16\x86\xdf\x33\xd9\xdd\xd0\x21\x91\xea\xe0\x45\x00\xae\xdc\xa8\xb1\x55\x1c\x7b\xdb\x67\x24\x6a\x74\xa8\xd9\x2e\x6d\xb7\x1b\xb6\xdb\x7d\x60\x6f\xbf\xa2\x16\x4d\xfd\x8e\x5a\x36\xd5\xe8\xe1\xdb\xcd\x95\xd2\x1a\xf5\x87\x6d\x52\x5a\xab\x36\x11\x47\xc7\xa2\xeb\xaa\xd8\x1f\xdd\x62\x7a\xe1\x36\x4b\xfd\xd9\x2e\x95\xb7\x2a\xcb\xab\x62\x8f\xba\xc5\xaa\xca\xea\x52\x7b\x5d\x22\x47\x47\xa2\xd4\xd1\x15\x9e\x99\xca\x19\x39\x95\x9b\x68\x19\x96\x53\x9e\x78\x94\xb0\x38\x0c\x02\x67\x45\x9e\x31\xfd\x5a\x0f\x33\x47\xcc\x68\x64\x7b\xc7\x0c\x12\xc5\xf5\x0a\xb3\x50\x55\x3e\xde\xea\x43\x50\xd4\xe0\x8e\x37\xaf\xb8\xc1\x4f\x6f\x50\xf3\xdd\xca\x6b\x87\x3d\xbe\x51\x1b\x8c\xab\xce\x63\xd6\x37\x7e\x93\x26\xee\xdd\xac\xf3\x92\xc3\x59\x8c\xef\xac\xb0\x09\xa2\x93\x42\x7e\xf3\x5e\xd3\xb7\x76\xbe\xab\x66\x14\xfe\xa2\xc2\x84\xd7\xcc\x21\x07\xa1\xf3\x94\xc2\x75\xdc\xda\x8d\x63\xf2\x2a\x26\x07\x21\x39\xa4\xc2\xb7\xe2\x64\x45\x94\xbf\x98\x09\x9f\xfa\x85\xe8\x9e\x88\x7b\xe5\xd0\xb6\x94\xda\x18\x3d\xae\xd2\x34\x57\x56\x37\xe5\xa4\x72\x6c\x5f\xe9\x02\xe0\x66\x36\x0b\x9b\xc8\x38\x69\xc6\x16\xa1\xd0\x70\x48\x7c\x01\xa3\x73\x65\x0e\x1e\x85\x29\x3e\xdf\xf8\x62\x84\xa6\x70\xcb\x28\x5d\xd9\x3a\xd1\x84\xba\x1d\x37\xb3\x8f\xc3\x1e\x97\xa7\xe7\x01\xac\x50\x74\x3d\x09\x94\x8d\x0f\x9e\x32\xa9\xed\xae\x31\x59\x58\x08\xaf\x03\xf0\x42\x75\xa3\xe1\xf5\xf4\xc8\x56\xbc\xe8\x9e\xe3\x38\x24\x54\x58\x00\x52\x42\x2e\xbd\x98\xc4\x6d\xe3\x6f\x77\xca\xb3\x9f\x3b\xc6\xed\x50\xaa\xcf\xcb\xa4\xdb\x27\xd9\x25\xb7\xdf\x23\xea\x42\x9b\x9a\x36\xe4\x5d\x50\x05\x9e\x63\x67\x5f\x33\x73\x9b\x73\x5c\x93\x1f\x74\xae\x9d\xbc\x3e\x06\x40\x8f\xed\x15\x51\x19\xe9\xca\x5c\x35\x26\xb0\x47\x36\x76\xce\xcd\xec\x8f\x41\xd1\xf4\xd7\x45\x25\xeb\x71\xa3\xf5\x15\x79\x2b\x87\x03\xbf\x4c\xf5\xe2\x25\x8e\x53\xc7\x07\xeb\x1e\x06\x56\x51\x6b\xbc\x5f\xcf\x27\x09\x1c\xe4\xde\x16\x55\xc1\x1c\x7b\x98\x03\x86\xae\x31\x09\x8c\xbb\xc1\x2c\x30\xf4\x1a\x3c\xf9\xcf\x19\x68\x3b\x68\x50\x0a\x2d\x94\x91\xb4\x6b\xaa\xdb\x90\x94\xe9\x94\x2f\x0d\x7b\x5d\x64\xa2\xe0\xf2\x5d\x10\x66\x56\xc2\x4b\xc0\xc0\x6b\x98\xe4\x72\x6d\x92\xc3\x01\xbd\x16\x72\x36\x57\x94\x7c\xc6\xd3\x08\x5b\x7e\x6b\xc3\x2f\x54\xf1\xb5\x26\xc1\x26\x5d\x82\x8d\x14\x91\xd2\x58\x81\x37\x85\xe9\x32\xa2\x9b\x11\x0d\x02\x05\xe9\xf0\x04\xfd\x05\x77\x92\x2a\x34\x88\x5e\x93\x2d\x75\x92\x3e\x37\x42\x24\xd9\x9a\x58\xbf\x94\xc4\x7a\x15\x82\x80\x2b\xf2\x29\x28\x83\x27\x3f\x04\x92\x46\x91\x4b\x9b\xbd\xe1\x77\xaa\xbe\x78\x87\x47\xb7\x2c\x31\x6f\x94\xe8\x38\x95\xc9\xc7\xdc\xa2\xf3\x9a\xc6\x36\xe4\xad\xa2\x31\xb5\x7e\xbb\x04\x86\x6c\x26\x28\xf3\xf5\x80\x57\x98\xf0\x82\xe9\x23\xc0\x0f\xcc\xd9\x46\x66\xd2\x47\xb7\x1f\x07\xe5\x43\x75\x70\x7b\x78\xf4\xea\xe8\xfd\x51\x1b\x0b\xe7\x4b\x9f\x09\xf3\x17\x47\x4a\x16\xdb\x1b\x38\x55\xfa\x28\x85\x9e\x0f\x4c\x9d\x2a\xbd\x63\xce\x0b\x97\x3c\x0b\x4c\xf8\xfc\xbb\x8d\xf4\x40\x2a\x74\x0e\xaf\xde\xe9\x66\x9e\x77\xbf\xba\x93\x0a\xa1\x9a\xd2\x34\x2c\xa3\x51\xdb\xe9\x0b\x46\x1f\x83\xad\x0d\xfe\x38\xdc\x9e\x49\x16\xaa\xb3\xc2\xc2\x84\x97\xbd\x27\x15\x35\xca\xc2\xc5\xc0\xf3\x12\x65\x21\x4e\x07\x43\xfe\x09\x02\xa2\xb0\xef\x4a\xf0\xe6\x69\x9f\x89\xfa\x43\x48\xe2\x54\x61\xfe\x88\x6e\x4d\x65\x5c\x34\x4f\x11\xb9\xa7\xd4\x74\xd8\x2b\x1b\x43\x56\x80\x06\xb6\x00\xa6\x9d\xe7\xfd\xd4\x99\x91\x7f\xed\xc1\x5d\x98\x7e\x35\x21\x4b\x07\xac\x50\x9d\x5d\xea\xee\xf6\x12\x08\xec\x0d\x79\xce\xfa\x9d\xe7\x3f\x0a\x10\xb2\xbf\xe0\xa7\x52\x05\x56\xa0\x2b\xfd\x51\x0d\xca\xb5\x54\x3b\xe4\x72\x8b\x1e\x9a\xc0\x02\x64\xd0\x81\x5a\xd5\x2b\xf2\x99\x41\x06\x02\x2e\x58\x3d\x89\x95\xed\x74\x8b\x15\xb0\x40\x2e\x72\xe2\x6a\xd4\x99\x3d\xb3\xeb\x09\x8c\xcf\x1e\x0f\xbc\xdc\x68\x57\x6d\x80\x2b\xf2\x45\xb6\xee\xc2\xb9\x4f\x5e\x30\xc9\x53\x1b\xbb\x97\xdf\xdc\xbd\x0c\xb9\x71\xd5\x3b\x9f\xf2\x82\x0d\x95\x6f\x6d\xbb\xa0\xf6\x60\x55\x1f\xab\x02\x91\x3a\x03\x12\xd6\x4e\xac\x2f\x19\x24\x83\xbe\xab\x4d\xa7\x5e\x39\xbd\xb4\x8f\x7e\x1a\xe7\xa4\xee\xc0\xf3\x12\xc5\x2f\x4c\x6f\x26\xb4\x4c\xed\xee\x2e\x88\x7e\xbe\xe9\xcd\xb9\x6a\x87\xa4\xe6\xdb\x25\x1e\xd4\x88\x9a\xdd\xb9\xc2\xb8\x82\xc6\xe4\x0e\xee\xb4\xe8\xce\xcd\xe6\x76\x1a\x92\x4c\xed\xb7\x66\x39\xb6\x34\x6d\x6f\x12\xca\x05\xfb\xd6\xd4\x84\x6a\xbb\xc8\xea\xed\xc2\xae\x6b\xfc\x18\xc8\x1a\xb1\xba\xf6\x46\x51\xab\x8f\xdd\x0e\xef\x21\x39\xe3\x58\xe9\x91\x2a\x27\x75\xd7\x1b\x35\xbd\xb5\x65\x25\xaa\xd2\x19\x26\xa9\xb6\xd3\x04\xa9\xf6\x66\x48\x78\x38\x0b\x63\x1a\x95\xce\x20\x3d\x13\x4e\x2f\xb4\x47\x05\xeb\x9f\xef\xb2\x98\xb0\x63\xa0\x2b\xc9\x3e\xae\x6c\x1f\x98\x50\x3c\x24\x4d\x87\x0f\xdb\xd1\x8d\x85\x7e\x93\xaf\x5c\xaa\xd2\xf9\x10\xef\xfb\x41\x2f\x6d\x8e\x7e\x2f\xb2\x58\x54\x76\x9f\x7a\x1e\xf7\xd3\x74\xc0\xb3\x25\x4f\xa5\x64\xe3\x95\x85\x97\x3e\xba\x4e\xbc\x70\x49\x94\x9a\x5b\x9e\x1b\xbd\xef\xa7\x29\x8a\x46\xe3\xf4\x97\xb8\x25\x89\x2d\x80\x2e\xed\x0c\xa8\xfc\x76\xfa\xd2\xa6\xc0\xa8\xcd\x81\xa5\xaa\xc3\xf3\xb4\xf2\x1e\x11\xa1\x6c\xa0\x72\xe9\x70\x93\x38\x08\x67\x06\x04\x69\xe9\xaa\xe3\xf3\x34\x4c\xe2\x93\x38\x48\x0c\x7d\x6b\x96\x7c\x54\x37\x1b\xfd\x64\x59\x18\x79\x87\xe8\x9f\xd3\xbe\xf7\x21\xf5\x79\xf3\x1e\xa7\xb1\x3b\x6f\xdc\xe0\x7e\x1e\x6e\xd5\x95\x37\x6a\xff\xe6\x92\x71\x5a\xfa\x94\xe8\x2e\x46\x59\x8a\x58\x4a\x5e\x2a\x1f\x33\xf5\x18\x16\xc3\xbb\x4b\x7b\xdb\x2e\xe5\x10\x95\xf7\x08\x91\x8f\xe6\x69\x7b\xef\xe6\x72\xef\x56\x07\x03\xb3\x01\xae\x53\x82\x1c\x2d\xb7\x09\xaa\x89\xb5\xb5\xaf\xc4\xfc\x45\x0a\x1a\xc7\xf1\xee\x1d\x43\x89\x79\xb3\x14\x9e\xd0\xc6\xba\x64\x97\xf6\x0f\xa6\xd8\x8c\xe6\x88\x26\x6c\x7a\x37\x54\x14\x72\x5f\x86\x2d\x5d\x4e\x65\x1a\x8b\x85\x15\x25\xca\xd5\xcc\x89\xeb\xb4\x62\x21\xaf\x6e\x5b\xdc\x8f\x12\xea\x91\x5b\x7b\x72\xfd\x99\x05\xac\x86\x06\x8d\x5b\xec\x40\xc5\x1e\x5f\x77\xc3\x62\x4a\xde\x76\x49\x9e\x27\x70\x80\x49\xa6\xd6\xca\x56\x89\x61\xf6\x18\xb3\xda\xd9\xa1\xd6\x76\x26\xb5\x85\xcf\xb6\x0b\xee\x95\x9d\x0a\xe2\x22\x12\x4f\xdb\xe2\xe0\x42\xe8\x5c\x92\x2c\x85\x17\x98\xa1\x32\xd7\xb5\xca\x85\x8d\xdb\x8d\xdc\xfd\xba\x9b\x4e\x59\xa9\x27\x2b\x05\x37\xb7\x93\x92\x49\xae\x29\x54\xf2\x53\xed\x41\x5c\xea\x66\x57\xf6\x5c\xb4\xd5\x86\x27\x94\x24\x69\x2d\x5e\xff\x61\xab\x03\xd3\x18\xf5\x9c\x35\x09\x53\xd0\x92\x53\x50\xc8\xfe\xad\x54\xcf\x30\x92\xfd\x31\x6d\x46\xb2\xd7\x4d\x8c\x05\x09\x4c\x70\x57\x18\x8d\x83\x9d\xba\x6c\x74\x4a\x69\x99\x79\x0f\x0f\x75\xaf\xec\x48\x90\xbc\xd2\x6b\x90\x6c\x2e\x12\x29\x73\x9d\x2a\x1d\xd1\x0b\xa5\xe6\x53\xa9\x6b\x2a\x20\xa6\xb7\xa2\x5c\x90\xa8\xab\x20\xbd\x4c\x48\xd4\x1f\xad\x53\xbe\xf7\x22\x6b\xed\x53\x77\xfb\xe3\x79\xe2\x5a\x46\xdd\xbb\xd7\x2a\x92\x92\xe6\xb3\x81\x38\x22\xd1\x08\xc1\xaa\xca\x3e\xc4\xcf\xf1\x70\xe4\xc7\x8e\x0a\xd3\x65\xc4\x2b\x71\x31\xbc\xed\xf0\x27\xf6\xd9\xbe\x92\x43\xf3\x19\xb5\xa5\x71\xd1\x96\x9e\xee\x37\x5b\xee\xaa\x46\x2b\xb2\x4c\x95\x5c\x03\x7e\x4b\x4e\x9b\x2b\x12\x57\x22\x0f\x5b\x03\x36\x80\x48\x12\xb4\x27\x80\x87\xad\x75\x00\x0f\x6d\x59\x64\x17\x8a\xa2\x55\x25\x6e\xae\x2a\x91\x74\xf3\x98\x3a\x8b\x2e\xc5\xe4\x76\xe2\x2c\x6a\x11\xaa\x45\xc1\x58\xdf\x4c\x11\xa2\xae\x6f\x55\x56\x35\xeb\x56\xb5\xb2\x53\x67\x56\x57\xd5\xa4\x3b\xa5\x08\x2f\x9d\x35\xf9\x54\xaa\x77\xae\x28\xab\x5a\x76\xab\x12\xf6\xb2\xf5\x69\x7b\x7f\x6c\x4b\x73\x47\xdb\x12\xd0\x5e\x27\x8a\xeb\x62\x97\xea\xa9\x8a\x9c\xb6\x65\xc2\x75\x1f\x0b\xfc\x25\x5a\xee\x5d\xa3\x80\xcb\x5e\xbe\x4d\x17\x18\xa3\xf8\x48\x6e\xf4\xef\xd0\xed\xe6\xcc\x1e\x17\x05\x3c\xe9\x2f\x1d\x36\xcc\x2d\x87\xf6\x25\xea\x05\xf4\x15\x9e\x1a\x81\xae\x4b\x45\x96\xb2\x4f\xf6\x18\xe8\x33\x5d\xb9\x00\xd7\xb5\x03\x0c\xe8\x1c\xab\x78\x62\xc0\xe0\xc8\xc2\xd4\x4d\x3f\xb0\x31\x3c\x57\x87\xa5\x4a\x9d\x5a\x97\x7d\x28\xff\xa8\x38\xca\x2a\x06\x15\x5f\x8b\xed\x69\x51\x87\xda\x1e\xa4\x8e\xdc\x2d\xa4\x06\x7e\x36\xa8\x9e\x71\x6b\xbc\x1f\xa3\x79\xde\x84\xa3\xd4\x59\xc5\x70\xde\x27\xfc\x68\x88\x1a\xe5\x1e\xec\xcc\x29\xe1\x92\xd5\x6e\xc8\x59\xaa\x0e\xa5\x8f\x52\x1d\x79\xbc\xe4\x89\x97\xe1\xab\x06\x7c\x0b\x4c\x88\x4d\x84\x53\xd8\xe7\x16\xa5\xb6\x9c\x0d\xe6\x74\xfd\xc7\xc2\x86\xd8\xdd\x5e\x74\x61\x07\x02\x73\xf4\x29\x28\x0a\x22\xd9\x29\xb6\x8e\x58\x78\x55\xeb\x5e\xfb\x04\x0a\x8d\x08\xb2\x07\xb9\xb3\x4e\x49\xd9\x09\x8d\x73\x25\xb7\xbb\x68\x9e\xa4\xc2\x7e\x34\x7d\x74\xef\x8e\xd1\xd8\xdc\x57\x29\x6c\xf0\x13\x09\x75\x7e\xa8\x39\x75\x1d\x81\xf3\xe2\xd6\xda\x9b\x14\x91\x63\x29\x98\x66\x4e\xcb\xe6\x86\x73\x8b\xc2\xad\x14\xa1\xe5\xf0\xfb\xce\xb6\x51\xce\x65\x9a\x04\x94\x85\x44\x72\x85\x27\xa9\xd4\x65\xd9\xb5\x9d\x03\x3b\x90\x33\x42\x81\x1d\xa1\x64\x7f\x6a\xa7\x72\x4b\x64\xc0\x2e\xf0\x1a\x5f\x64\x76\x20\x77\xb3\x10\x5c\x61\xfb\x72\x3b\xa3\x72\xfb\xc8\xa4\x54\x7a\x90\x16\xca\xcb\x21\x75\x18\x27\x86\x17\xe6\x86\x09\xa7\xea\x22\x5d\xd2\xd8\x30\xe1\x24\x75\x02\x0e\x87\x72\x10\xbf\xa7\x30\x06\x34\x85\x9e\xea\x5f\x27\x29\x31\x5e\x25\xd4\x0b\xe3\x99\x65\x59\x86\xf9\x15\x2d\x9e\xf0\xaa\x57\xd2\x78\x43\x62\x4b\x24\x1f\x96\x4b\x9f\x1f\xd0\xd4\x47\x57\xbe\xf7\x69\xcf\x31\xe6\x91\xab\x93\x0a\x6f\x79\x7b\xc4\xad\xd4\xbd\xa2\x89\xf3\xe2\xf9\xf0\x2a\x45\xdf\x26\xc4\xea\xbd\x1e\xa4\xe2\x0d\x99\x71\x88\x41\x94\x81\x50\xdf\x52\xe7\x3a\x25\x86\x1b\xd1\x34\x3d\x95\xc2\xb1\x09\x6f\x06\xe4\xa4\xef\xa9\xfc\xe4\x6f\x29\x51\xd0\x4a\x23\xfc\x3b\x59\x51\x1e\x87\xf1\x4c\x7e\xbb\x1e\x91\xf7\x68\x9f\x40\x07\xdf\x2b\x35\x94\x2c\x13\x22\x91\x83\xf9\x54\x5d\x47\xa1\x61\xc2\x71\xea\x2c\x38\x3c\x4b\x9d\x39\x87\xb7\x3b\xfa\xfb\x2c\x55\xf9\x0e\x31\x8f\x25\x6e\x44\xaf\x07\x3a\xf8\x36\x95\xd2\x6c\xe8\x5e\x1a\x52\x90\x55\x09\xda\x76\x29\x35\xa3\x0d\x79\x5a\x7d\x53\x4c\xf3\x49\x28\xfc\x45\xf9\x21\x1a\xc1\x02\xe7\xba\x51\x24\x0a\xe3\xcb\x91\xf6\x7b\x97\x25\x7d\xd3\xde\x90\xab\x54\x91\xc5\x71\x0a\x06\xa3\xee\xe5\x8c\x27\x59\xec\x19\x60\x08\x4e\xe3\x74\x49\xb9\x1f\x0b\x43\xee\x1a\xb2\x40\x90\xc4\x42\x01\xaa\xfb\x3c\xac\x6f\xbb\x19\x4f\xe5\x42\x34\x96\x49\x18\x4b\x79\xbc\x7c\x90\x64\x22\x0a\x63\xdf\x00\x23\x4e\x62\x39\x3f\xcd\xae\x18\x72\x34\x54\x74\x25\x76\x46\x9d\xf4\xbf\x18\x10\xb2\x4b\x57\xe5\x0f\x03\xcf\x1f\xea\xe7\x1f\x07\x9e\x97\x61\xaf\x5f\xd2\x7f\x07\xed\x13\xb3\xd7\x0a\xf4\x2a\x45\x7c\x18\x41\xd6\xd8\xf1\x0a\xed\x5e\xe5\xdf\x35\xe1\x3b\xa2\x05\x22\x58\x62\xa6\x6c\x61\xef\x06\x15\xc7\xad\x48\xb1\xcf\xbd\xa4\xf1\x34\x24\x6f\x43\xb2\x21\xef\x90\x07\xff\x90\x9b\x86\x45\x81\x7e\xb1\xa7\xa0\x8e\x94\x0a\xf4\x62\x7b\xae\xd6\x82\x08\x45\x24\xc7\xf9\x65\xdf\xda\xac\x32\x7a\x3c\xee\x59\x17\x4c\xc4\x13\xc4\x06\x1b\x2d\xf8\xe4\xee\x68\xc1\x26\x77\x4b\x72\x6a\xd2\x11\x13\xf1\x48\x16\x4d\x17\x23\x96\x70\xcf\xe7\x13\x1e\xce\xe6\x62\x32\x1d\x09\x7f\x2d\x26\x8b\x4c\xf8\x5e\x35\xfd\x59\xea\xf3\x49\xea\x47\xbe\xab\xa8\x26\x14\x21\x8d\xaa\xa7\x93\x45\x72\x3d\xf9\x45\x91\x95\xcf\x2e\x43\xf1\x8b\x52\xba\x23\x6e\x12\x21\x11\xfe\xcd\x75\xdd\xc6\x92\xe6\xb7\xff\xe1\x18\xff\xb8\x2d\x10\x24\xf5\xab\x42\xfd\xef\xfd\x9c\xd9\x24\xa0\x9e\xef\xe1\xb5\x26\xdc\x49\xea\xbb\x49\xec\x51\xbe\x51\xc4\xfa\x39\x25\x0a\xc8\xcb\x34\xe1\x79\x4a\x8c\x67\x88\x3b\x38\x62\x9b\x91\x98\x87\xe9\x08\xb3\x18\x34\x9a\x36\x6e\x97\x6c\xb5\x80\x8b\xbe\xd9\x6d\x9a\x42\x62\x7f\xb5\xaf\x70\x0c\x1d\xe3\xf6\xab\x90\xbc\x0b\xbb\xce\x3a\x15\x35\x86\xca\x4e\x35\xd5\xf0\xc4\x07\x2a\x46\xd9\x2c\x20\xce\x7f\x37\xf1\x8f\x82\x4e\x68\xc6\x68\x2b\xca\x05\x9e\x23\xc3\xa3\x86\x09\x42\xfd\x94\xac\xcf\xef\x6d\x60\x43\xae\x53\x30\xe6\xdc\x0f\x0c\xb8\xf3\xbf\xbe\xd3\x9c\xa6\x2e\x0f\x97\xc2\xbe\x13\xaa\x64\xac\x52\xc8\x31\x2d\xee\x2f\x23\xea\xfa\xe4\xce\xff\x9f\xde\x99\x81\x61\x98\xe6\xbe\x61\xd8\xbc\x0a\xf1\xca\x72\xe5\xdd\x33\xc8\x50\x45\x52\x26\xbc\x18\x2c\xb2\x28\x8b\xc8\x35\x59\xc3\x5d\xd6\xa0\x96\x98\xe5\x8d\xe6\xbb\x81\xea\x6e\xc5\x8d\xe0\xeb\xc7\x5b\x61\x05\x78\xb6\x99\x13\x61\xd6\x80\x73\xd5\x8e\x47\xcb\x74\xeb\x18\x7a\x50\x05\x1f\xa8\x04\x48\x88\xe9\x71\x98\x11\x74\x9e\x5a\x0b\x38\xc9\x48\x86\x81\x07\x4a\x1a\xaf\x21\xe9\x6e\xf8\x32\xbe\xca\xdb\xaf\x76\x0a\x73\x05\xff\x34\xea\xef\x6a\xa7\x85\x93\x8c\x10\xdd\xbc\x82\x3a\x17\x4a\xd4\xbf\x41\xe7\x54\x8f\x6e\x37\xda\x6c\x3f\x54\x0f\x0a\xa9\x97\xf7\x11\xd1\x8c\x94\x01\x20\x56\xba\x8c\x42\x21\xc9\xe4\xf6\x9d\x99\x24\xeb\x30\x57\xec\x8d\xf2\x99\x2f\xf7\x9d\x64\x80\x0a\xb7\xd6\x4b\xdb\x8b\xe5\x44\xe9\xa0\x7d\xf0\x8f\x3c\x97\x4b\xd6\xcf\xa5\x38\x18\xe6\xc4\xf8\xc6\x22\x2a\x77\xa8\x9a\x8b\xe8\x64\x27\x82\x6c\x08\xcd\xc1\xcd\x11\x73\x1c\x97\x5c\xa0\x16\x87\x90\x7c\x8f\xe9\xdf\x73\xc3\x84\x54\xff\x96\xdb\x61\x9e\xdf\x8c\x1f\xa7\x79\x29\xa6\xb1\xbc\xe4\x51\xc8\x58\xe3\x64\xc5\xe9\xb2\xc5\xd6\x0c\xdb\xd0\xfc\x2c\xa8\xca\xae\x26\x7b\xd3\x29\x96\x4a\x90\x3e\xb1\xd3\x51\x97\xd6\xab\x63\x1b\x44\x97\xe5\x18\x6b\xb9\x5f\x32\xc6\xd7\x29\xe6\x52\x69\xf2\xc7\x92\x1f\x86\x71\x90\x94\x8c\x7f\xda\x94\x25\xb0\xcf\xa2\xea\x47\x40\x47\x01\x9d\x2c\xc2\x38\x4b\x71\x3f\xc1\x32\x63\x29\x91\x12\x03\xed\x87\xb2\x67\x76\x1f\x27\xee\x6d\x49\x71\xdf\xaa\xa7\x43\xed\x2d\xa3\x5d\xcd\x15\x26\x78\x03\x64\xc3\xf3\x9b\x76\xc3\x97\x13\x3f\xd4\x3e\xbe\xe1\xce\x29\x17\x9d\x5e\x9c\x27\x19\x77\x7d\xd5\x0f\x18\xf7\x76\x23\xfe\xe7\xde\x74\xdf\x98\xea\x0c\xbd\x36\xfe\x2d\x60\xde\x5b\x76\x9c\x93\x32\x74\x58\x32\x56\x15\x25\x8c\x37\x55\xe0\x30\x6f\xde\x9a\xd7\xb7\x40\xa5\x97\xda\x8e\xcc\x1e\xe7\xbd\xe9\x14\xfe\xdf\x8d\xca\xc6\x71\x69\x44\x64\x8f\xc8\x87\xf7\x07\xa6\x51\xee\x43\x8b\xfe\xe5\xea\x6e\xd4\x7a\xfd\x63\xff\x5a\x2f\x4b\x25\xef\x80\x31\x22\x15\xee\xbf\x69\x60\x3e\x7d\x43\x6e\x6f\xdb\xaa\xce\x69\x43\x0d\x09\x67\xb1\x14\x69\x82\x89\xeb\x4b\x99\x59\x89\x5d\xc6\x6d\xa9\x07\x55\x8b\xfc\x98\xcc\x91\x25\xf9\x7a\x25\xcf\x5a\x2b\x59\x6e\xd3\xba\x6f\x37\x04\x8d\xcc\x48\x6c\xee\x5f\x13\x0d\x5b\x2f\x50\x05\xb8\x26\x02\xf4\x0d\xbf\x09\x2c\x8b\xe2\x30\x87\x6b\x32\x96\x34\xac\x70\x8b\x73\x27\xe7\xb0\xd1\x7c\x8d\x32\x14\x35\x57\xf9\x0e\xb0\xdb\x63\x42\x7c\xb9\xa5\xe7\x4a\x50\x0e\x5d\xe0\x3e\x69\xc0\xdb\x9a\x4d\x80\xb6\x61\xb5\xaf\xda\xd2\x63\x13\x51\xda\x84\xe5\x52\xd3\x34\xe5\xe7\x59\xac\xa1\xd2\x3f\x6d\x28\x33\xcb\x24\x0d\x95\x85\x02\xed\xfc\xa1\xab\xd5\x0f\x35\xf2\x52\x5d\x4a\x27\x18\xc8\x3a\x8a\xc2\x54\x28\xd9\x17\x6f\xd7\xfc\x6d\x39\x99\x4a\x41\xf8\x7e\xcd\xe1\x6a\x79\x19\x39\x2d\x8a\xc9\x23\x6f\x12\x44\xfe\x7a\xd4\xa9\xb8\x7c\x6d\x21\x59\x31\x28\xe8\x45\x8b\x6d\x30\x9a\x21\xef\x93\xeb\x9e\x86\xa4\x0c\xf3\x2c\xcc\x02\x36\x24\xca\x71\x38\x4d\x5b\xb2\x10\x43\xf2\x2f\x59\xc3\x37\xb3\xd7\x83\xdb\xcd\x1e\xe3\x16\xdf\x88\xb0\xf8\x2d\xbe\x76\x91\x92\x38\x27\xb1\x1a\xda\x21\x16\xc7\xfc\x28\x9a\xa4\x11\x4d\xe7\x93\xa4\xcb\xe4\xb4\xaf\x45\x15\xb5\x2f\x9a\xa1\x1c\xbb\xba\xe3\xd1\x78\x26\x05\xe9\x56\x87\xda\x07\x85\xe2\x06\x7d\x1a\xea\x91\xa7\x18\x2f\xc1\x94\x65\x70\x44\xb8\xdc\xf5\x44\xb9\xeb\x6d\xea\xad\x56\xd2\xf4\xa8\x9a\xda\x3d\xac\x0a\xa5\x8a\x3c\x07\x9c\xbb\x6a\x2a\xb4\x49\x05\x1f\xbe\x4c\x21\x2b\x3d\xd5\xd7\x6a\x75\x64\x52\x3d\xb9\xcc\x77\x6b\xf0\xb5\x51\x06\x7f\x71\x8b\xed\x0f\xfb\xe7\xdf\x50\x75\xdb\x93\x1d\xbf\x37\xa4\xba\xfd\xcf\x51\xd2\x1e\x30\x77\xea\xf9\xbf\xab\xa7\x35\xc9\xf7\x3f\xac\x92\x71\xd3\x1e\xd2\x6e\x4b\xb5\xaf\x3b\xa2\xb2\x8e\xd3\x44\x8c\x70\xc0\x35\x61\xa9\xde\xae\x2b\x32\xaa\x19\x4a\xcd\x3e\x34\xb8\xec\x2a\x47\x56\x56\x72\x74\x13\x9e\xb4\x68\x44\x52\x08\xa6\xbe\x42\x0d\x02\x28\x1e\x7a\xb1\x4f\x18\x6e\xf4\x25\xdd\x85\xf6\x47\x0b\xf8\x10\xf6\x05\x58\x28\x8c\x4b\x04\x2f\x2b\x4c\xd9\xf0\xe3\x36\xfd\x91\x6c\x47\x12\x9c\x43\x01\x2b\x72\x89\x7d\xc6\xb8\x02\xf2\x46\xf6\x2f\x94\xa3\x77\x4c\x10\xe0\x6e\x96\xc3\x39\x26\xfb\x3b\x13\x24\x54\x3c\x99\x22\xca\xf1\x3a\x21\x19\xc6\xd2\xbe\xc1\x11\x53\x26\xb7\x74\x14\xa0\x79\xc9\xfc\x6a\xda\x2a\x48\xeb\x40\xab\x96\xf1\x32\x93\x82\xfd\x99\xba\xd4\xd3\x06\x47\x83\xa2\xab\x36\x06\xc6\xa5\x31\xf0\x3c\x77\x8e\x72\x62\xb8\x73\xdf\xbd\x44\xea\xfe\xae\x55\x86\xcd\x52\xee\x52\xa7\x79\xed\x7e\xa6\xb5\x08\xa8\x0a\x7f\x35\xd1\x8a\x7d\x32\x20\x1d\xa2\x6d\x6e\x2e\x39\x94\x4e\xeb\x17\xc3\x69\x2e\x87\xe0\xb0\x6f\xeb\xbb\x81\x7d\x6e\x43\xce\x2a\x5a\x59\x08\x49\x60\xd1\x64\x6f\xe4\x66\xa9\x48\x16\x13\xa9\x68\xf1\x24\xaa\x2e\x65\x1f\x59\xb2\xae\xdf\x3d\xc0\x77\xbf\x97\x1f\x8b\xcf\x70\x67\x6b\x57\x30\x29\x87\xf4\x3c\xaf\x72\x10\x71\x53\x7e\xa5\x4a\xd0\x24\xe0\x69\x68\x6a\x56\xd9\x5c\x03\x9d\x5a\xbc\xd0\x55\x91\x1e\xbf\x2c\xeb\xf9\x4a\xeb\x97\xbb\x6e\xbd\x5c\x62\xbd\x44\x14\xbd\xbf\xca\x9d\x4e\xe2\xf8\xf3\xac\x19\x4c\xb4\xc8\x1a\xe1\x3e\x79\x1d\xee\x93\xab\x2c\x77\xd7\xb9\xce\xb3\x78\xe9\x6f\x0e\x12\xcf\x37\x00\x31\x10\x4c\xf8\xb6\x63\xfa\x2e\xfd\x8d\x97\xac\xe2\x6a\xfe\xae\x71\xfe\xde\xec\x7e\x23\x5b\x6e\x95\xbf\x92\x4d\xbf\xd6\xa0\xa8\xdf\x05\x9c\xfb\x26\x48\x4d\xe9\xe9\x10\x95\x6e\x23\xc9\x1c\xf7\x35\xd8\x70\xb0\x7b\x36\xf0\xbc\xf4\x7b\x7a\x9b\x3b\xff\xf0\xe3\xdc\x69\x1e\xc0\xfc\x03\x5e\xe7\xce\x9f\xf0\x29\x77\xf6\xee\xc1\x8b\x81\x2f\xaa\x37\x0b\x57\x92\x56\x12\x4d\x68\x26\x92\x3e\xb9\x66\xa7\x1d\xf0\x26\x0c\x79\x43\x9e\xe6\x70\x6b\x0a\xb1\x59\x93\xc0\x97\x50\x9b\xd5\x77\x32\x75\x25\x04\x34\x6b\xd9\x6b\xd5\x62\xfc\x9f\xff\x6d\x34\x68\x09\x3e\x28\x5e\x91\x2e\x68\x24\x79\xc5\x47\xc5\x01\xbc\x30\x95\xbb\xb8\x64\x01\x5f\x14\x0b\x08\xe5\xef\x77\xea\xb7\x82\x9b\x31\xe1\x73\xef\x40\x5d\x93\x18\x6e\x4d\xcd\x02\x9e\xef\xe0\x3b\xa5\x51\x7f\xaf\x32\xea\xbf\xec\x63\x2e\xaa\x25\xed\xe3\x7a\x31\x30\x2f\xcf\x73\xd0\xac\x4f\x51\xda\xe7\xbc\xa4\xb8\x97\xb9\xb2\xe7\x45\xfd\x86\x83\x33\x15\x2b\xf6\x4e\x85\x59\x2f\x20\x73\xde\xa3\x94\x49\x1d\x1c\xbc\x2b\x01\x9f\x43\x85\xa5\xf4\x2e\x45\x4f\x30\x4c\x06\xe1\x3a\x57\xca\xc4\xe1\x1c\x91\x0c\x49\x37\x51\x07\xea\x62\xdf\x30\xec\xcc\x1a\xef\x1b\x73\x9a\x96\x13\x61\xe3\x45\x9a\xb9\xae\x9f\xa6\x46\x9f\xe4\xc1\x93\xd5\x28\x4e\x26\xb3\x4c\x08\x9f\xa7\x03\x12\xf0\xb1\xb2\x63\xbe\xc8\x81\x77\xa8\x4d\x52\xa3\x71\x3b\x29\x85\x84\x45\x18\x4f\x56\xa1\x27\xe6\x06\x18\x77\xa7\xd3\xe5\xba\x8f\x42\x71\xbc\x14\x8d\x6e\x33\xc5\x2f\x79\x7f\x2e\x18\x64\x8f\x41\xc2\x2b\x56\x85\x04\x21\xc7\xeb\x5b\x5b\xf3\xd5\xd8\xe2\x9f\xf2\x46\x48\x6e\xef\x58\x96\x28\xe4\xaf\x73\xb3\x06\x2b\x17\xe5\x04\x5d\x13\x1f\xdc\x46\x84\x14\xfd\xf9\x93\x5b\xcc\x1a\xef\x7f\x0e\xed\x72\x7d\xc8\x1b\xb4\x8a\xf7\x3c\xce\x65\xcd\xe5\xd5\xe7\xb0\x30\xe1\x4d\xde\xb7\x9d\xeb\x46\xf7\xe5\x0b\x7b\xa6\x8d\x25\x2f\x72\xf2\x2c\xef\x61\xcf\x8d\x91\x9a\x30\x11\xef\x5a\xc7\x4b\x1e\x2e\x94\x99\xfb\x63\x4e\x42\x13\x68\x8f\xc4\xa4\xd6\xef\x87\x5a\xfa\x96\x03\x2a\x25\xca\x96\x58\x59\xbf\x78\x80\xbb\xc3\x48\xcf\x02\x8c\x7c\x6b\x66\x19\xfd\x2c\x00\x8f\xa6\xb4\x21\x5e\x51\x11\xa3\xa9\x8f\x67\x47\xc8\x0e\x9e\xe5\xe4\x6d\xde\x60\x05\x6f\xf3\xba\x4f\x98\xc0\x04\x78\xb4\xfb\xdc\x47\x44\x37\x3c\x86\xf1\xbb\x05\x95\x2a\x53\x1a\xcb\x4c\x73\xbf\x42\x8f\x32\x1a\xcb\xa2\xfe\x2a\x8f\x27\x4b\xb9\xdd\x28\x75\x12\x0d\xa2\xb8\x2a\x45\x84\x13\x6f\x6e\x9b\x15\x4d\xc8\xfa\x7a\xaf\x77\xa2\x45\x92\xa5\x3e\xda\x08\xea\xb3\x41\xfa\xab\xf2\x91\x4f\x73\xbf\x2e\xef\x0e\x8c\x4e\x79\x6a\x16\x46\xce\x9f\x90\x44\xce\xfd\x29\x04\x91\xdc\x48\x58\xe4\xdc\xfb\x13\xd2\xee\x58\xf4\xe7\x4e\xaa\x13\x5b\xf1\x32\x21\x01\xa6\x87\xa8\x96\xd1\x89\x20\xc2\x6c\xa6\x50\xca\x77\xcc\x47\x6b\xcf\x8c\x06\xba\x5e\x3a\xad\x7b\x03\xcf\xcb\x3d\x73\x3c\xf0\xbc\xdc\x73\xe7\x3b\x86\x92\x45\x59\x63\xd0\x17\x51\xe7\xe8\x50\xb9\x61\x20\x0f\x56\x39\x25\xe9\x39\xc6\xeb\xd2\xf7\xb5\xe4\x8e\xfc\x39\x51\xf0\xeb\x57\xb9\x4a\x2c\x71\xb8\xc3\xda\x91\x46\xa5\xb5\xe3\x93\x40\xf8\x6e\x8a\xde\x15\x62\xff\x32\xb1\x4b\x1a\xf2\x4d\x60\xaa\xc6\x13\xf1\x3b\x35\x66\xea\xa4\xa1\x87\x95\xff\x82\xab\x6e\xa7\x0d\x1a\xe0\xa8\xfe\x10\x47\x4d\xa2\x8a\x14\xc6\x11\x61\x15\xff\x64\xad\xfb\x49\x75\x3f\xa8\xef\x8b\x7d\xfc\xd0\xcb\x44\x63\x03\x46\xc8\x83\xa9\xca\x56\xa6\x47\xa3\x7c\x2d\x8c\x1a\xec\xd8\xaf\xd9\xf1\x55\x4e\x5c\xb3\x81\x94\xcd\x15\x00\x8c\xd4\xb8\x71\x54\x73\xb5\x32\x95\x57\xb5\x2e\xe3\x45\x4d\x96\x7c\x99\xec\x64\xc9\x61\x64\xee\xcb\x17\xf6\x4c\x1b\x4b\x5e\xe4\xc4\x8d\x4c\x20\xdc\x89\x54\x7f\x15\x41\xa9\x7c\x69\x92\xa2\x10\x55\x71\x1e\x91\x08\x5f\xfa\x0b\x99\xb7\x62\x36\x41\x9f\xca\xab\x78\xcd\x6c\x80\xe0\xff\x4b\x65\x44\x35\xe0\x4d\xe9\x2e\xfe\x4d\xf9\x50\xd6\xb0\x5b\x3e\x5c\xf6\xc8\x4e\x35\x00\xa2\x5a\xb3\xa1\x5a\xa5\x89\x73\x6b\x43\xc6\x19\xb8\x10\x5b\xae\x8b\xb9\x1a\x67\x09\x82\x24\x42\xe0\x3c\xf3\x89\x8b\x07\x95\xc9\x7f\xa2\x78\x34\x8b\x64\x63\xbd\xe2\x51\x70\x03\xf1\x68\x11\x41\x02\x31\xfa\x32\xa1\x35\x35\x81\x86\x95\x55\x21\xa8\xdc\x7c\xe3\x7e\x25\xb5\xef\xd1\xa5\xbf\x19\x05\x09\x57\x96\x8e\x30\x9e\x8d\x4a\xc7\x4c\x75\x74\xf3\x17\x55\xf7\x1f\x12\x0b\xdc\xa8\x6d\x4c\xae\xdb\x6c\xdc\xd5\x22\x42\x99\x06\x83\x4b\xe6\x8c\x78\x56\xe7\x90\x39\xb7\xb8\x45\x9f\xfd\xfd\xef\xf2\x9f\x47\x3f\x7f\xaa\x64\x6c\x86\x61\x1b\xe9\x3c\x59\x19\xd0\x72\x1c\xca\x44\xe2\x26\x8b\x65\xe4\x0b\x7f\xb2\xf0\xe3\x6c\x64\xdc\xce\xe4\xce\x4d\x38\xae\x70\x13\xa8\xfa\xd9\x38\xa0\xfa\xde\x15\x09\xe4\x9b\xb5\x41\xc8\x8f\x88\x28\x8d\x41\xb5\x2c\xb3\x89\x1c\xb9\x37\x17\xb0\xfa\xc5\xde\xb6\xfe\x85\xd0\x73\xf9\x8b\xbd\xf3\xc9\xc0\xf3\x32\x8e\xe6\xe0\x06\xb2\x50\xaf\xcc\x53\x9f\x0c\xda\x7d\xcf\x77\x79\x0e\xbd\x4e\xc9\x2a\x22\xdc\x72\x71\x69\xb7\x96\x95\x28\xa5\x26\xcb\x9d\x6b\x66\x76\x16\x69\x08\xc4\xa3\x81\xae\xa2\x67\xff\x95\x80\x58\x65\xd1\xfd\xb8\x33\xa5\xc9\xbc\x80\xef\xe2\x17\x39\x63\x62\xcb\x8d\x8b\xca\x04\xc0\x7d\x8d\x0e\x6f\x9a\x66\xe7\x20\xa2\x69\xfb\x19\x2d\x4a\x7e\x0a\x44\x38\x7b\xb0\x21\x4b\x0e\x86\xa0\xec\x24\xf6\xfc\x35\x42\x2a\x0b\x95\xaf\x6f\xeb\xf0\x82\xfb\x11\x55\x83\x39\xe0\x54\xd5\x26\xb6\xd7\x29\x39\x8b\xd4\xf6\xac\x4c\x4b\x7c\x72\x7f\xc7\x70\xd7\x2b\xe6\x4c\xe7\x32\xb1\x47\xc6\x6d\x15\x8a\x8b\x79\x47\xfc\xc6\xce\x71\x3e\x24\xb3\x8d\xb8\xc5\x66\x72\x3b\xa5\x8f\xf6\x09\xe2\xde\x72\x53\x72\x57\xea\x08\x8b\xf9\xe0\x56\xc2\x0f\xe2\xd7\x9f\xff\x96\x04\xe4\x6b\x09\x28\xac\xe4\x1d\xff\xe6\xef\xfb\xea\xdd\x5d\x13\x82\x23\x34\xea\xae\x6e\xe4\x00\xb8\xbe\xd7\xf5\xfa\x5e\xab\xf5\xfd\x1f\x98\xa5\x5a\xa4\xda\x4e\x1e\x23\xe5\xa7\x0c\x65\x82\x4d\x84\x02\xc4\x93\xa8\x23\x4d\x35\x24\x8e\x24\x32\xf7\x2f\x23\x12\x9a\xb6\x96\xa3\xe4\x95\xab\xae\x82\xc8\xdc\x5f\x45\xca\x0e\x90\xc1\x10\xde\xa3\xa2\x64\x0c\x3d\xf9\x92\x14\x9a\x66\x9a\xe4\xa2\xa3\x9d\x0d\x29\x08\x27\xee\x65\x75\xbf\xdc\x83\xf6\xa6\xd3\xff\xaf\x36\x0b\x0e\x30\xbb\x51\xeb\x4a\xb9\x8b\xd5\x0c\xf0\x20\x22\xb4\x62\x80\xf6\x86\x1c\x45\x10\x4b\x39\xec\xa1\x59\xe6\x8a\x2b\xfd\x91\x0b\x13\xbe\x0f\xb1\xa3\xd8\xa2\x91\x92\xc2\x5f\x29\x29\xfc\x50\x49\xe1\x0f\x94\x14\x1e\x2b\x29\x3c\x7c\xdc\x7f\xf2\x52\x6e\xb6\x94\x7b\x52\x96\x79\xd0\x27\xf2\xc8\x87\x93\xb9\x4f\xbd\x7a\xd1\x34\x2d\xfe\x31\xcd\x47\x92\xb0\x04\x65\xe9\xa8\x51\x16\x6f\x94\x2f\xac\xc9\xa7\x14\xa6\xe0\x2a\xe6\xf1\x22\xc5\x84\x1e\x7a\xf5\xa9\x63\x0b\xe5\xd0\x81\xe5\xf6\xfa\xcb\x3d\x2f\x05\x74\x39\x7e\xcb\xbc\x95\x1b\x64\x43\xce\x23\x39\x76\x2e\xa8\x7c\x32\x87\x39\xd4\x07\x60\xf2\x81\x0f\x1f\xd3\xf2\xc1\x49\x9d\xa7\x9e\x5b\xd4\x83\x0f\x69\xad\xe2\x6f\x7d\xb6\x9e\x7c\xf5\x11\xee\x7e\xdd\xae\x4e\x71\xb2\x8c\xe4\x22\xb5\xeb\xfb\x3a\x97\x4a\x1c\xe9\xe4\x31\xb2\xd6\xae\x3f\xb8\xe8\xc6\x39\xaf\xc9\x93\x1c\x42\xc4\x20\x45\xac\x43\xed\x6e\xd0\xf6\x42\x38\x4c\xb7\xcf\xf8\xdf\x28\xf7\xe1\xa2\x20\x9a\x51\x9d\x46\x68\x19\x9c\xef\x19\x26\x9c\x44\x6d\xf7\xe7\xa8\x76\x7f\x8e\x13\x51\x9f\x47\x60\x2f\x0f\xd5\x8b\xa9\xe0\x49\x3c\x33\x4c\x78\x15\xfd\x02\x0b\x8e\x5a\x1f\xcb\xa0\x28\xb7\x81\x85\xd1\x23\x0c\xea\x53\x62\xf9\x67\xe2\x26\x51\xb6\x50\x38\x55\x5a\x90\x6e\x88\x92\xa3\xe6\x59\xe7\x59\xe5\x10\x74\x58\x77\x9c\xd7\x53\x15\xcb\x5b\xef\x72\x42\x11\x9f\xe6\x02\x35\xb0\xb9\x1c\xf7\x8e\x82\x36\x6a\x5e\x54\x62\xab\x5a\xbd\x5f\x3b\x81\xe5\x37\xef\xf9\x7f\x4e\x6f\x1b\x1d\x6b\xa2\xa2\x84\x8e\xdb\x3c\x50\xfe\x9d\xd1\xd5\x47\xcc\xff\x15\x83\x5b\x2a\x2a\x5d\xce\xd8\x2a\x16\xf8\xbe\xc7\xa8\xdb\x74\x33\x0b\xcb\xcd\xb6\x30\xe1\xfd\x80\x70\x56\x7a\x42\x5f\xff\xc2\xa6\xf3\x6d\xe0\x79\x19\xae\xf8\x06\x45\xa7\x47\x05\x5c\x45\x3a\x05\xdb\xd3\x2e\x7f\xed\x66\x53\x1e\xf2\x06\x6e\xba\xcf\xb6\xce\x4f\x4b\x05\xb1\xf7\xbc\x59\x6a\x0c\xbb\x0e\x9b\xdb\xcf\x7b\x4f\x9a\x55\x91\xb6\x49\xad\xf6\xd8\xec\xb3\xcf\xfd\x5e\xb7\x5f\xa7\x44\xf4\x1c\xa7\xf7\xea\x3a\xbc\x16\x96\x8e\x77\x09\xa4\xfd\x7e\xbd\x2a\x3c\xb5\x44\x1b\x47\x8f\xdc\xaf\xfa\xa8\x55\xfc\xc2\x8b\x86\xa3\xdb\x06\x82\x39\xb1\xae\x81\x67\xb7\x47\xcc\xbf\xe7\xef\xd2\xf0\x6e\xe1\xda\xbb\x85\x6b\xef\x96\x28\x47\x7c\xd0\x86\xd7\x0a\xb7\xd8\x37\xed\x7b\xd1\xf6\x38\xbc\xa1\xef\x05\x1f\xf4\xbd\x78\x1a\xa1\xb3\x62\x75\x9e\xfe\x6c\x50\x46\x6d\x7e\xcd\x92\x4e\x47\xb5\xaf\x24\x56\x74\x1c\x91\xd8\x2c\x73\x7c\xaa\x6d\x60\x29\x67\xbf\x5b\x5f\x0f\x4e\x47\xc7\xd9\x65\x9d\x10\x21\xbf\x6f\x6b\x00\xeb\x91\x7d\x1b\xf5\xf0\x1e\x3c\x27\x2f\xa1\x65\x1a\xea\xb6\xfa\xdf\xfe\xed\xea\x9e\xb4\xeb\xb2\x95\xf7\x9f\x4a\x01\x5b\xb3\xb9\x67\x11\x9e\xee\x77\x37\x01\x35\xdc\x5b\x4e\x7f\x8d\xed\xb7\x83\x0c\x7d\xf3\x40\x1b\xbf\xe4\x72\x9f\x7e\xa1\xa2\xbe\x88\x7a\xce\xd8\x87\x91\x52\x9a\x5d\x6e\x6c\x66\xcb\x1c\x3e\x45\xb0\x21\xaf\xd5\xa7\x6e\x43\x37\xbc\x49\x15\xfe\xf2\x96\x5c\x71\x98\x62\xa2\xce\xc8\x91\xaa\xd4\x03\x03\x3e\xf6\xf5\xa5\xcb\x5f\xe2\x2d\x9e\xb1\xed\xaf\x74\x6f\x64\xdc\xe6\xd5\xfe\x56\x98\xf0\x25\xd2\x50\xf2\xef\x76\x36\x50\x3b\x0d\x04\x0f\x47\x5e\xc8\x46\x0b\x76\x77\xb4\xe0\xbd\x0e\x68\xca\xa9\xf0\x17\x4e\x03\xe7\xb8\x74\x4f\x72\xd5\xd7\x2d\xfb\xe3\x32\xaa\xad\x7a\x72\x54\x31\xf3\x44\xc5\xdd\x3e\xef\x32\xdf\xb7\xce\x53\x9e\xef\x2a\x79\xbf\x59\xf2\xe5\xae\x92\x77\x9b\x25\x2f\xfa\xc6\xa9\x11\xbd\xe8\x08\xcb\x9d\x43\x28\xb5\x4f\x0e\x89\xd4\x39\xdf\x3e\x6e\xd2\xc2\xb7\x08\xb6\xec\x74\xbd\x32\x7f\x12\xd5\xca\x40\x4e\x5e\x45\x70\x90\x6b\xe0\xf6\xcf\x91\x0e\x1c\xe4\x78\x12\xbc\x07\xd4\xa6\x88\xed\xd5\x11\xa0\x87\xeb\x78\xa9\xea\xc8\x74\x1d\xf7\x80\xda\x59\x61\x42\xd8\x5b\xc7\x0d\x26\x79\x45\xde\x45\x60\xe8\xfc\x2a\x09\x3c\x8f\x30\xa9\x53\xbc\xbf\x22\x1f\x23\xe8\x73\x6d\xd2\x06\x09\x30\x02\x3a\x11\x1c\x5d\xfa\x0c\x20\xbe\xee\x0f\x50\xdb\x2f\x2a\x9e\x5b\xda\xa6\x4c\x88\x3d\x8d\xd4\xc1\x3d\x67\x97\xb5\xb6\x92\x30\xd1\x4b\xab\x69\x8f\x7e\xcb\xfd\x3c\xf4\x57\x1a\x3b\x4b\x29\x33\xc2\xdb\x45\xf9\xf5\x58\xc8\xed\x69\x64\xdc\xfe\x10\xe9\xfa\xb8\x27\x7b\x1c\x43\xe6\xf8\xd6\x78\xdf\xc0\x98\x50\xdf\xb0\x8d\x0f\x98\x0b\xc5\x68\x59\x15\x17\x72\x18\xbb\x36\xf3\xd7\x29\x89\xbd\xba\x7b\x99\xb2\x16\x0e\xbe\xd8\xb4\x42\x8b\x96\xfd\x24\xf5\x45\x39\x50\x8f\x35\x31\x16\x26\xf8\xde\x6e\x06\x97\x0d\x3c\x2f\x6d\x7c\x74\xe0\x79\x79\x7e\xe5\x7a\x1a\xbf\x3c\xbc\xe1\x10\xf2\x64\xd5\x1c\xc1\x8a\x28\xcf\xd1\x24\x0d\x9a\x64\x95\xa8\x41\x3d\xf8\x16\x99\xf0\x2d\x22\xae\x67\x42\x6c\x42\x55\xfa\x50\x83\xed\xea\x17\xee\xea\x17\xfc\xd6\x0b\xa2\xf1\xc2\x11\x46\x15\x36\x2b\xcf\x5a\x65\xcb\xa3\xd0\xc4\x53\xee\xc5\xfe\x5a\x50\xee\x53\xc3\x84\xc0\xeb\x75\xa3\xd4\x2e\x72\x8e\x6f\xd1\x63\x44\x19\x77\x33\x4c\x8b\x4e\x23\x40\x9c\xeb\x39\x04\x8e\x02\xde\x30\x4e\xfd\x55\x89\xd0\x26\xdb\xbe\x48\x10\x34\x1d\xfd\xb4\x8f\xbc\x50\xd4\xcf\x5e\x26\x0a\xa6\x40\x41\xd9\xf5\xd9\x0b\x1a\xfa\x63\x80\xae\xda\x52\xa1\x0e\x3d\xa0\x96\xbb\x01\x8a\x78\xbd\xd6\x06\x97\x35\x55\x49\xb4\xaa\x81\xaf\x46\xbc\x59\x5d\xaf\x0a\x62\xbc\xd6\xd9\x74\x46\xa5\xa6\x5f\xb3\xe5\x26\x4b\x56\x0b\xa8\x96\x18\x4a\xa7\x47\xed\x35\x6b\x19\x7d\x2a\x7d\x8b\xd9\xd5\x5b\x4a\x8b\x51\xa1\x28\x52\x1a\xcf\x61\x67\xb1\x8f\xca\xa1\xa6\xe9\x21\xa0\x85\xb3\x03\x17\x2e\x22\xb2\x27\x05\xc3\xcc\x44\xa7\x09\x18\x60\x45\x8a\x05\x2d\x23\x3c\x1a\x8b\xc8\x97\x48\x5b\xec\x2b\xda\xa9\x42\xbd\x3f\x44\x8a\x74\xae\xa3\x92\x74\xae\x22\x13\x14\x80\x23\x96\x4e\x3c\x30\x0e\xca\xac\x46\x65\xe9\xf7\x55\xe9\x37\xaa\x74\x6e\xf6\x4e\xcc\x8a\xbc\x88\x40\x1f\xfb\xac\x88\xf0\x20\x06\x0a\xac\xde\xf4\x98\x22\xcd\xf9\x03\xc3\x84\xb4\xbd\x2c\xfb\xf4\xa4\xa6\xec\xed\x46\xe1\x12\xcd\x84\xae\x20\x53\xc0\xff\x4c\xa3\xc7\x8e\x18\x84\xeb\x5a\xa1\x68\x31\xbe\xc4\xa3\xd1\x48\xea\x2a\x7d\x7a\x25\x3e\x9d\x48\x65\xd2\xe3\xc9\xb2\x59\xac\x4a\xa0\xa6\x30\xa3\x3e\x2b\xbf\x21\x8b\x1d\x2a\x7b\x99\x45\x9f\x2b\x8b\x99\xe5\x1e\xed\x36\x8f\xd5\x1d\x28\x4d\xa3\x03\x46\xc2\x81\xbe\x4f\xbc\x90\x46\xc9\x6c\xd4\xbc\xd0\x3b\xd8\x8e\x2f\x46\x65\x19\x43\x90\x87\x0a\x6c\x1b\xe5\x98\xd7\x7e\xae\x43\x62\xdb\xfc\xbd\xc5\xde\xdd\x28\x49\xf5\x81\x12\xef\x3d\x4d\xec\x1b\xea\xc4\xdb\x94\x95\x8a\xfe\x22\x41\x92\x34\x76\x67\xbf\xe9\xaf\xf2\xab\xb9\xd3\x23\x5c\x89\x88\x90\x7b\x37\xf5\x96\x18\x2c\xc8\x0e\x71\x2b\x7f\xc2\xfd\xd1\x26\xc9\x46\x69\xa6\x7f\xac\x68\x2c\x46\x22\x19\xa9\x5c\x69\x2d\x06\xb2\x6f\x98\x40\x9f\xf7\x86\x69\xb5\xb6\xcf\x35\x25\x1b\x92\x7b\x2a\x63\x45\xd3\x01\x28\x89\x83\x90\x2f\x14\x17\xa1\x9f\xed\x35\x25\x2f\x98\x09\xee\x91\x6d\x1c\xa9\xd6\x4a\xc6\x2b\xbb\xee\x0d\x75\x7d\xd4\xaf\x76\x8f\xfa\x63\x68\x9a\x9e\xa7\x18\xbf\x88\x21\x34\x7a\x05\x8f\x77\x8c\x63\x4b\x6a\x9d\x77\x0b\x56\xd8\x47\x08\x74\xb8\x1d\x1b\xd5\xab\x2b\xfd\xfa\x34\x7b\x2b\xc4\x0d\x47\x72\xdc\x1d\x49\x35\x5c\x46\xcb\x1e\xf6\x57\xb7\x71\xe8\x47\xbe\xd0\x21\x6a\x85\x09\x0b\xaf\x37\xe3\x6f\xbf\xe5\xe2\x9a\x54\xd9\xd1\x14\x54\xe2\x99\x09\x6d\xb8\xad\x16\x74\x20\x82\xdd\x1b\xbe\x17\x8a\x0a\x7c\xeb\xb7\x42\x55\x9a\x72\x97\xdc\xc0\x8d\x26\xe4\xa6\x9e\xa0\x7d\xdf\xfe\xb7\x02\x60\xda\x83\x72\xe6\xab\x8c\x78\x3a\x72\x6f\xd6\x37\x28\x6b\x4a\x5e\xb2\xad\x10\x7d\x77\x0e\xf4\x0b\xa6\x01\xd8\xbf\x5b\x85\xea\xf3\xa2\x7d\x48\x18\xa9\x33\x54\x78\x11\x28\x07\xa3\xe5\x8e\x15\xf0\x3f\x33\xb4\xa9\x6b\xd5\xe7\xad\xe5\xd1\x58\x09\x9e\x87\x32\x60\x8a\xe7\x0d\xd7\xdb\x1a\xb8\x7a\x8e\x22\x28\x96\x70\x37\x3d\x84\x8e\x55\xe8\x94\x8e\xaa\x16\x04\x89\x21\xe8\x75\xb6\x07\xbf\x39\xdd\xfd\xe1\x45\x28\xd3\x84\x3e\x72\x5f\x53\xae\x02\x95\xbf\x73\xee\x01\x57\xe9\xba\xda\xcc\xbb\xb6\x1f\xcd\x3c\xd9\xa5\x33\x53\x8a\x06\x24\xde\xff\x2e\xc8\x86\x44\xfa\x2d\xd3\x3e\x15\xb5\x59\xb2\x30\x61\xd3\x27\xd4\x8f\x52\x4e\x36\x1c\x49\x41\x07\x10\xad\x5a\x22\xbd\x0a\xc2\xe8\x3b\x3e\xa9\x52\x83\x57\x81\x7e\xea\xb0\x74\xbc\xe3\xec\x8f\x06\x85\x3a\x12\xdf\x79\xd6\xcd\xe2\x42\x9f\x71\x83\x8f\xd8\x7a\x2a\xac\x43\xc7\x74\x94\xe3\x57\x9e\xa2\xd8\x1b\xb2\xa9\xb6\xdf\x9a\xf6\xea\x41\x1a\x60\x1d\x38\x79\x4b\xaf\x8c\xcc\x52\xb9\x5f\x55\xee\xc4\xac\xcf\x58\x23\xfa\x8d\x35\xa8\x11\x14\x26\xac\xbd\x26\x3a\xec\x65\x7b\xac\xb7\x82\x5b\x4b\x0a\x2d\x5d\x3a\xdb\x8d\x55\xc9\x40\xb7\x5a\xab\x32\x8b\x16\x05\x3c\x19\x50\xd0\x4a\x27\x8c\x83\x1d\x7a\x19\x1e\xf5\x09\x88\xd5\x0c\x3c\xf1\x60\x4d\x5b\x47\x65\x61\x40\x78\x99\x9f\xa1\xca\x97\x56\x41\xd5\x5c\x7a\xa5\xcf\x40\xc3\x24\x4f\xbd\x99\x3f\xc2\xbf\x93\x65\x18\x45\xc9\x4a\x5f\xe8\x0f\xd0\x6b\x19\xb7\x51\x91\x2c\x47\x8b\xb6\x99\x07\xa3\x8e\x95\x94\x52\x0c\x34\xf7\xd5\xc4\x54\x7e\x26\x9c\xb5\xd8\x15\x07\x25\x06\xdf\xd3\x62\xf0\x8f\x1e\x13\xfc\xc0\x81\x69\x3b\x48\xaa\x17\xbf\xe2\xc0\xc3\x2c\x3b\xec\x95\xfc\x13\x9b\x05\x08\xb3\xea\xe0\x0d\xeb\xdd\xa8\x4a\xa6\x92\x3e\xb0\xff\x47\x1e\x86\x04\xcc\xc5\x22\x7a\x86\x99\x4c\xce\x3d\xc7\xe3\xf0\xdd\x73\xc6\x1c\x4e\xff\x27\x0b\x52\x97\x94\x10\xa1\x52\xc6\xe8\x03\x1f\x51\x98\xfd\x82\x55\xc5\x72\x4e\x76\x88\x3e\x0f\x9a\xa2\xcf\xe1\x7f\x8f\xe8\x73\x29\xbf\xfd\xe4\x3f\x57\xf4\x19\x6a\x63\x4b\xf4\x79\xa5\xf4\x3c\x66\x98\xf0\x7e\xc7\x96\xbc\x75\xac\xa7\x8e\x1a\x77\xa8\xd7\x77\xd1\xa9\x12\xcb\xb6\xc2\x12\x37\xe4\x95\x57\xe9\xfe\x71\xef\x31\x7c\x12\x4d\xf6\xa6\xbf\x36\x01\xf2\x4a\x55\xbd\xde\x61\x33\x71\x86\xe2\x8f\x2f\x29\xa9\x0c\x4b\x18\x7f\x8c\xe6\x72\x6e\x6e\x87\x0c\x76\x0e\xd2\xab\xc0\xdf\x16\x2b\x5a\x44\x75\xd8\xe4\xc2\x53\xb8\x25\x87\x1e\x08\xbd\x8f\xaa\x8f\x7c\xef\x81\x71\x72\x68\xc0\x49\xaa\x03\x72\xf5\x3d\x25\x0a\x8c\xa8\xc0\x47\xf3\x1c\x93\xb0\x98\xd5\x63\x29\x49\xb4\x1e\xd2\xeb\xfa\xa1\x32\xfe\x79\xad\xe7\x6c\x59\x3f\x57\x56\x42\x6f\xc4\x36\xba\x5d\x4c\x4f\xae\x9f\x95\xc6\x03\xf5\x20\x6f\x76\x48\xf8\x78\x5b\xf2\x41\xbd\x12\xaa\xa7\xaf\xab\xfc\xc7\xcd\xc3\x29\xe5\xc0\x11\xe8\x43\x2a\x53\xa7\x56\x31\x21\x93\x32\x82\xaf\x64\x84\x53\x1c\x91\x69\x25\x23\x14\x26\x7c\xeb\x95\x0e\x50\x06\xec\xa8\xe5\x2d\x22\xea\xb1\x11\x9d\xd2\x85\x6f\x6b\x3b\x12\x02\xa0\x28\xd7\xb9\xae\x10\xb3\xa3\x8e\x27\x0a\xcb\xb8\x55\x0d\xbd\xac\xfc\x6c\xdf\x68\xb3\xc8\x5d\xc3\x84\xab\x1e\x01\x19\x4d\x0e\x65\xd6\xcf\x4b\x65\x6e\xf8\xd6\x02\x45\xd0\x5f\xf5\xa6\x5e\x06\xc6\x81\x82\xf6\x1d\x9d\x2b\x8c\xde\x4e\x9f\x87\x96\x5c\xfd\x05\x72\xd1\xa4\x8b\xf6\x21\x06\x8e\x46\xb7\x32\x5d\x74\x6f\xda\x28\x2b\xfa\x16\xe2\xbf\xd7\xaa\xfa\x86\x9b\xb4\x5b\x2e\x1f\xc2\x75\x92\x65\xdc\xbb\x0d\x49\x1f\x50\x5e\x55\x96\x75\x30\xb8\x4f\xbd\x8d\x72\x75\xaf\x1f\x97\x87\x6d\x60\xa4\xbe\x90\xcc\x70\xa6\x4a\x7c\x45\x25\x41\xe9\x64\x23\x9d\xa1\x3a\x74\x95\xb3\xe3\xc7\x50\x79\x30\x6e\x1d\xd0\xfd\x65\x23\xf0\xd6\xf7\x79\x3d\x00\xeb\xbc\x7f\x00\xb0\x4b\xdf\x3c\xc8\x6a\x1f\xee\xa7\x8a\xb6\xdc\xc4\x93\xdc\xe5\x58\x5d\x2d\xe5\x7e\x00\xcf\x06\x56\xc9\x00\x8b\xfa\x4b\xe9\xe8\x03\x82\x65\xdf\x90\x92\x7c\x26\x77\xce\xab\x6a\x38\xaf\x3c\xb9\x7e\x04\x2a\x2e\xb1\xc5\x04\x0c\xad\x01\x8d\xad\x3d\x3a\x89\x55\x46\x3b\x1d\x57\xfb\x57\x7c\xc0\x53\x04\xdf\xbe\xe9\x52\xb0\x68\xf2\xd7\xd1\xc2\xd3\x12\x1f\xfc\xe6\xad\x2f\xff\xe2\xd6\x3f\xa4\x3e\xbf\x79\xeb\x57\x7f\x5d\xeb\xcf\x4b\xbc\xf4\x9b\xb7\xfe\xf2\xaf\x6b\xfd\x4c\x03\xac\xdf\xb8\x71\x46\xff\xba\xc6\x7f\xf7\xc3\x59\x5a\x73\x20\xe5\xbc\x6f\xd1\x95\x45\x2f\xa0\xb9\xc2\x5b\x3b\x86\xc2\xab\xd7\xd5\x1f\x57\x9d\x59\x36\x3c\x5a\x5b\x08\x97\x7f\x0b\xfe\x08\xfe\x08\x1e\xb5\xd0\x2d\x27\x01\x5d\x84\xd1\xc6\x00\x63\x91\xc4\x49\xba\xa4\x6e\xc3\x77\xf7\xa9\xd7\xf1\x12\xd3\x7e\xfb\x35\x1e\xef\xdb\xde\x0d\xb0\x11\x74\xe2\x5e\x75\x1d\x06\x2b\x04\xa4\xbe\x58\x5f\x16\x3d\x1e\xf6\x77\x78\xe6\x29\xcf\x85\x26\xae\x6e\x9f\xab\x46\xdb\xd1\xa1\x28\x50\x96\xdf\x4e\x83\xd7\xdb\xfa\x1c\x9a\xfe\xb5\x73\xdc\xbe\x59\xd0\xd7\x25\x95\x34\xa2\xe9\x04\x43\xae\x3d\xf0\x41\x00\x85\x5b\xb7\xb2\x7f\xab\x93\xee\xaa\xc7\x33\x31\x92\x4a\xe0\x1a\xdc\xea\xc3\x2b\x84\x29\xe1\x20\xa1\xb8\xb9\x69\xd1\x43\x85\x7d\x14\x03\xe2\xd5\x05\x0a\xae\x2e\x80\x81\xd3\x8d\x96\x2d\xac\x01\xcf\xa0\x7c\xc0\x8e\xbc\xfe\xc0\xe2\xaf\xbd\x0e\xbc\xb5\x27\xec\x4b\x86\x1a\x7d\x1c\x69\x30\x36\x58\x91\x73\x0f\xce\x3c\x4c\x4f\x03\x6b\xf2\xdd\x83\x95\x07\x14\x2f\xbf\x76\x72\x8e\x60\x3d\x2b\x0a\x6b\x12\x78\x70\x2a\xe4\x07\xcb\x2f\x3f\x85\xd8\x72\xbb\x4e\x2c\xad\xd2\xdf\x05\x91\xc3\x03\x63\x30\x8c\x56\xf1\x3f\x86\xc7\xfd\x24\x2a\x0a\x78\xed\x39\x3f\x9e\xda\x35\x0c\x3b\xc8\x5d\x42\x9f\xd4\x17\xf0\xa9\x7c\x5a\xdb\x72\xe5\xf3\xf3\xf2\xaa\x80\x17\x55\x09\x9d\xbf\x02\x9f\xab\xdf\x05\x7c\x40\xcb\xcc\x6b\x0f\x3e\x79\xf0\xc2\x03\x59\xb2\xc4\x65\x5c\xf2\x64\xe1\x8b\xb9\x9f\xa5\x56\x98\xdc\xf1\x12\x37\x55\x5d\x08\xe3\x99\xfa\xb1\xa0\x31\x9d\xf9\xfc\x8e\xaa\xf2\xd8\x8f\x96\x46\xf1\xd5\x84\x8f\xaa\x41\x75\xd7\x28\xe0\xcb\xa0\xc6\x76\xd4\x0b\x72\xd6\x4d\x06\xf3\xda\xdb\xd2\x65\x3f\x7a\xe5\x50\xeb\xf9\xd1\x44\xd7\x5e\x3d\x9f\xbc\x2d\x38\xb3\x17\xde\xf6\x08\x7f\xf4\x24\x51\x9b\xc0\xcd\x7d\x63\x54\xc7\x10\x17\x26\xbc\xfb\xa5\xe9\xb7\x19\xbb\x60\xdc\xde\x90\x2f\x5a\x8d\x2d\x69\x96\x37\x6d\x20\x25\xc0\xae\x9f\x13\x6e\x3d\x45\x64\x1c\x1d\x34\x03\xed\x10\x1a\xed\xcd\xa3\x25\x78\x7d\x94\x06\xcf\xd5\x75\x4c\x73\xc3\x84\x97\x03\x72\xd6\x67\xaf\xd1\x20\xa3\x7c\xa4\xfe\x99\x88\x64\x36\x8b\x7c\xca\x22\x7f\xb2\xf0\xca\x9b\x51\x38\x9b\x8b\xda\xdb\x72\xc1\x26\x0f\x46\x4b\x31\xb9\x37\x5a\x22\xb6\x4e\x1b\x24\x88\x25\x42\x24\x0b\x03\x8c\xbd\xe5\x7a\x94\x26\x51\xe8\x8d\xf8\x8c\x51\x32\x85\x91\xfa\xdf\xda\xbb\xfb\xc0\xac\x97\xeb\xf3\xc6\xc6\x13\x0b\x1a\xc6\xcd\xf3\xc0\xd6\xb8\xc8\xae\x30\x4e\x63\xaf\x34\x01\x77\x8e\xd3\x35\x95\x75\x45\x55\xfd\x36\x8e\xc9\x57\x1d\x4d\x86\x02\xeb\x3b\x34\x11\x7f\xf0\xcc\x5e\x2f\xf7\x66\xee\xa9\x5e\x57\xb5\x8e\x4d\x63\x6b\xa3\x0d\xe3\x28\x8c\xfd\x3a\x7c\xa8\xfb\x5d\x03\x71\x96\x5b\x26\xee\xd8\x5f\xb5\x34\xa1\x86\x4b\x44\xe5\x74\x4c\x9a\xee\x2b\xbc\x80\x8b\xdd\xd6\x8f\x16\x17\xd5\x47\x13\xd4\xf3\x94\xf2\x71\x1f\xe3\x13\xcb\xc0\x23\x0d\xfb\xc4\xbb\xde\xb2\xf0\x52\x8a\xc3\xee\xd5\xb6\x4c\xa0\x27\x52\x12\x48\xc5\x99\xdf\x7a\xa4\xe1\x83\x16\x8f\x07\xa2\xd7\xfe\xd0\x96\x57\x3e\x54\xa0\x74\xa1\x16\x7d\x05\x46\xac\x32\xc3\x83\x3f\x76\x96\x9c\x18\x1c\xc1\x88\xb2\xf1\x70\xce\x7c\x31\x06\x03\xd7\x1c\x28\x1c\xd1\xd8\x04\x7f\x4c\x8c\x54\x6c\x22\x3f\x9d\xfb\xbe\x72\x62\x7e\x9b\x82\x11\x25\xd4\x53\x11\xc0\x24\x0d\x15\x6c\xaf\x7e\xe2\x73\x9e\x70\xfd\x88\x85\xc4\x78\x46\xc3\xc8\xf7\x46\x22\x19\xc9\x77\x46\x07\xe7\xe7\xa3\x80\x27\x0b\x1b\x3d\xf1\x4c\x1d\x33\x5c\x98\x40\x1b\x5f\xd1\x37\x43\x24\x76\xb8\xe5\xb2\xd6\xce\x97\x8d\x21\xbe\x6d\x44\x21\xbb\xc3\x92\x44\xa4\x82\xd3\xe5\xe4\xbe\x35\xb5\xa6\x13\x1a\x2d\xe7\xd4\x7a\x38\xf1\xc2\x54\xdc\x71\xd3\xb4\x2e\x60\x2d\xc2\xd8\x72\xa5\xe2\x19\xa3\xfb\x41\x5d\x07\x4a\x4e\x74\xe5\xa7\xc9\xc2\x9f\xdc\xb7\xfe\xb0\xa6\xf8\x66\xf3\x76\xfd\x32\x1f\x2b\x91\xae\xb1\x56\x94\x81\xfb\x9a\x70\x8b\x1d\x01\xb7\xd8\x85\xf9\xb8\x46\xe3\xe5\xe5\xaf\x6a\x45\xd1\x86\xd0\x51\x9b\x26\xbb\xc2\x51\xfd\xc1\x2f\xa5\x98\x74\x63\x1a\x2b\x85\xbb\x92\xeb\x33\xee\xd3\xcb\x51\x5c\x2d\x55\x75\xcd\x8b\xed\xfd\xf7\x42\x19\xa9\x69\xf3\x74\x22\x0c\xc8\x5d\xb4\x88\xcb\xfe\x95\x15\x95\x15\xb4\x38\x41\xb1\x5d\x0f\xe2\x83\x90\x6a\x3d\xc6\x05\xb8\xed\x99\xd6\xe7\x02\x96\xfb\x1d\x5c\xf9\xcf\x25\x88\x66\xde\x05\x61\x51\x12\x93\xe7\x9c\x98\xa6\x59\x94\x32\xd9\x17\x4e\x7e\xbc\xb6\xab\x52\x55\xa6\xa8\x91\xb0\xa8\x43\x21\x16\x16\xf5\xbc\xa3\xdc\x8f\xc5\xab\x30\x15\x7e\xec\x4b\x7d\x3b\x59\xa6\xca\xfa\x25\x4c\x59\x22\xa6\x79\x38\xa3\x22\xe1\x56\x96\xfa\xfc\xc9\xcc\x8f\x85\x15\xc6\x9e\xbf\x7e\x13\x10\xe3\x3d\x0f\x3d\x74\xd8\xf8\xe7\xf4\xe7\xcf\xde\xea\xe6\x34\x9d\x97\x78\x5a\xa2\x8b\xe4\x1c\x06\xe4\x96\x9c\x2d\xc1\xa3\x97\xfe\xe6\xe7\x4f\x6e\x2d\x7c\x41\xf5\xcf\x74\x1e\x06\x02\x7f\xef\xfd\x53\xca\x73\x88\xce\xff\xf3\x67\x6c\x29\xdc\x1d\xf9\xcb\x4b\x56\xb1\x5c\x30\xa6\xf9\x83\x5b\x4b\xee\xcb\xc6\x75\xd2\x72\x52\x07\x06\xcc\xb9\x1f\x80\xef\xc8\xd1\x81\xcc\x49\x13\x22\x4c\x8b\x3e\xa6\xc4\x25\xd9\xdf\xff\xee\x5b\xf4\xbe\xe3\x38\x99\x45\xef\xe3\xc5\xa9\xba\x38\xc5\x8b\xa9\x45\xd5\xe5\xd4\xa2\xfb\xda\x6f\x20\x2b\x6c\xed\x89\x21\x0a\xb4\x21\x17\xc0\xee\xdb\xbd\x27\x19\xdc\x62\xf7\x21\x06\x6c\x58\x98\x05\xb8\x2f\x6c\x6e\xb9\x2f\xc0\x3d\x96\xff\x1e\x83\xfb\x44\xfe\xfb\x44\x56\x11\x8e\x9d\x8b\x98\x8c\x4d\x48\xc6\xda\xc7\x2f\x18\x64\x41\xda\xfb\x68\x9f\xdb\x88\x0c\x8c\x20\xb2\x2a\x45\x1c\x1b\x0f\x9f\x3f\xe9\x2c\x0d\xfb\xc2\x3e\x26\x02\x8e\x09\xc6\xde\x21\x73\x4d\xc7\x8e\x3b\x26\x3f\xd8\x7d\xfb\x3c\x05\xf7\xbb\xbd\xa1\xe0\x5e\xda\x1d\x0d\xa1\x3e\x74\xc7\x94\xf9\xe8\xc5\x1a\x5b\xb4\xb0\x95\xc2\x06\xa5\xeb\xee\x8a\xb0\x31\x18\x7f\xc3\x63\xdb\x13\x50\x57\xfb\x78\xd0\xbb\xc0\x08\xf8\x60\x2c\x9f\x4c\xe1\x58\x8a\xfe\xf7\xf7\x6b\xb4\x6e\xbb\x86\xf0\xe6\x16\x3d\xc5\x50\x07\x4a\xd1\x15\xb5\x90\x63\x75\xee\x93\x70\x6c\xca\xd1\x5b\xa5\x72\x2c\x7b\x18\x3e\x3b\xb4\x67\xe4\x5f\x74\xac\x90\x7b\xdd\x23\xbb\xbd\xd3\x17\x45\x61\x3e\x3e\x0b\x9d\x1f\xaf\x69\x18\xdb\x3f\xc2\x38\x14\x76\x3a\x26\xc9\xd8\x24\x53\xb3\x28\x20\xb6\x8e\xa2\xc5\x7e\x59\xef\x08\x41\xfa\x14\x0e\x0a\x1e\xbb\x8e\xc2\x78\x24\x4c\xfc\x87\xef\x23\xec\xa1\xe1\x38\xfe\xfe\x19\x79\x68\xda\x31\xe1\xff\xf2\xbf\x82\xf8\x97\xff\xd5\xb4\xe5\x4f\x47\xfe\x94\x7a\xcd\x51\xb4\x80\xb3\xd0\xb4\xf1\x97\x73\x16\x16\x44\xcc\xc3\xd4\x7c\xfc\x7f\x03\x00\x00\xff\xff\x70\x05\x86\x9f\x90\x6e\x01\x00"), }, "/templates": &vfsgenÛ°DirInfo{ name: "templates", diff --git a/test/with_api_v2/acceptance.go b/test/with_api_v2/acceptance.go index e6b977aafd..786db77eb8 100644 --- a/test/with_api_v2/acceptance.go +++ b/test/with_api_v2/acceptance.go @@ -59,9 +59,9 @@ type AcceptanceOpts struct { func (opts *AcceptanceOpts) alertString(a *models.Alert) string { if time.Time(a.EndsAt).IsZero() { - return fmt.Sprintf("%s[%v:]", a, opts.relativeTime(time.Time(a.StartsAt))) + return fmt.Sprintf("%v[%v:]", a, opts.relativeTime(time.Time(a.StartsAt))) } - return fmt.Sprintf("%s[%v:%v]", a, opts.relativeTime(time.Time(a.StartsAt)), opts.relativeTime(time.Time(a.EndsAt))) + return fmt.Sprintf("%v[%v:%v]", a, opts.relativeTime(time.Time(a.StartsAt)), opts.relativeTime(time.Time(a.EndsAt))) } // expandTime returns the absolute time for the relative time @@ -352,7 +352,7 @@ func (am *Alertmanager) WaitForCluster(size int) error { return err } - if len(status.Payload.Peers) == size { + if len(status.Payload.Cluster.Peers) == size { return nil } time.Sleep(100 * time.Millisecond) @@ -362,7 +362,7 @@ func (am *Alertmanager) WaitForCluster(size int) error { "failed to wait for Alertmanager instance %q to join cluster: expected %v peers, but got %v", am.clusterAddr, size, - len(status.Payload.Peers), + len(status.Payload.Cluster.Peers), ) } @@ -437,7 +437,7 @@ func (am *Alertmanager) Push(at float64, alerts ...*TestAlert) { _, err := am.clientV2.Alert.PostAlerts(¶ms) if err != nil { - am.t.Errorf("Error pushing %v: %s", cas, err) + am.t.Errorf("Error pushing %v: %v", cas, err) } }) } diff --git a/test/with_api_v2/api_v2_client/client/alert/get_alerts_parameters.go b/test/with_api_v2/api_v2_client/client/alert/get_alerts_parameters.go index 50d2c49270..bacb8b0535 100644 --- a/test/with_api_v2/api_v2_client/client/alert/get_alerts_parameters.go +++ b/test/with_api_v2/api_v2_client/client/alert/get_alerts_parameters.go @@ -6,10 +6,11 @@ package alert // Editing this file might prove futile when you re-run the swagger generate command import ( - "context" "net/http" "time" + "golang.org/x/net/context" + "github.com/go-openapi/errors" "github.com/go-openapi/runtime" cr "github.com/go-openapi/runtime/client" diff --git a/test/with_api_v2/api_v2_client/client/alert/post_alerts_parameters.go b/test/with_api_v2/api_v2_client/client/alert/post_alerts_parameters.go index c944e4fe46..235b210973 100644 --- a/test/with_api_v2/api_v2_client/client/alert/post_alerts_parameters.go +++ b/test/with_api_v2/api_v2_client/client/alert/post_alerts_parameters.go @@ -6,10 +6,11 @@ package alert // Editing this file might prove futile when you re-run the swagger generate command import ( - "context" "net/http" "time" + "golang.org/x/net/context" + "github.com/go-openapi/errors" "github.com/go-openapi/runtime" cr "github.com/go-openapi/runtime/client" diff --git a/test/with_api_v2/api_v2_client/client/general/get_receivers_parameters.go b/test/with_api_v2/api_v2_client/client/general/get_receivers_parameters.go deleted file mode 100644 index 6f585fc7ec..0000000000 --- a/test/with_api_v2/api_v2_client/client/general/get_receivers_parameters.go +++ /dev/null @@ -1,113 +0,0 @@ -// Code generated by go-swagger; DO NOT EDIT. - -package general - -// This file was generated by the swagger tool. -// Editing this file might prove futile when you re-run the swagger generate command - -import ( - "context" - "net/http" - "time" - - "github.com/go-openapi/errors" - "github.com/go-openapi/runtime" - cr "github.com/go-openapi/runtime/client" - - strfmt "github.com/go-openapi/strfmt" -) - -// NewGetReceiversParams creates a new GetReceiversParams object -// with the default values initialized. -func NewGetReceiversParams() *GetReceiversParams { - - return &GetReceiversParams{ - - timeout: cr.DefaultTimeout, - } -} - -// NewGetReceiversParamsWithTimeout creates a new GetReceiversParams object -// with the default values initialized, and the ability to set a timeout on a request -func NewGetReceiversParamsWithTimeout(timeout time.Duration) *GetReceiversParams { - - return &GetReceiversParams{ - - timeout: timeout, - } -} - -// NewGetReceiversParamsWithContext creates a new GetReceiversParams object -// with the default values initialized, and the ability to set a context for a request -func NewGetReceiversParamsWithContext(ctx context.Context) *GetReceiversParams { - - return &GetReceiversParams{ - - Context: ctx, - } -} - -// NewGetReceiversParamsWithHTTPClient creates a new GetReceiversParams object -// with the default values initialized, and the ability to set a custom HTTPClient for a request -func NewGetReceiversParamsWithHTTPClient(client *http.Client) *GetReceiversParams { - - return &GetReceiversParams{ - HTTPClient: client, - } -} - -/*GetReceiversParams contains all the parameters to send to the API endpoint -for the get receivers operation typically these are written to a http.Request -*/ -type GetReceiversParams struct { - timeout time.Duration - Context context.Context - HTTPClient *http.Client -} - -// WithTimeout adds the timeout to the get receivers params -func (o *GetReceiversParams) WithTimeout(timeout time.Duration) *GetReceiversParams { - o.SetTimeout(timeout) - return o -} - -// SetTimeout adds the timeout to the get receivers params -func (o *GetReceiversParams) SetTimeout(timeout time.Duration) { - o.timeout = timeout -} - -// WithContext adds the context to the get receivers params -func (o *GetReceiversParams) WithContext(ctx context.Context) *GetReceiversParams { - o.SetContext(ctx) - return o -} - -// SetContext adds the context to the get receivers params -func (o *GetReceiversParams) SetContext(ctx context.Context) { - o.Context = ctx -} - -// WithHTTPClient adds the HTTPClient to the get receivers params -func (o *GetReceiversParams) WithHTTPClient(client *http.Client) *GetReceiversParams { - o.SetHTTPClient(client) - return o -} - -// SetHTTPClient adds the HTTPClient to the get receivers params -func (o *GetReceiversParams) SetHTTPClient(client *http.Client) { - o.HTTPClient = client -} - -// WriteToRequest writes these params to a swagger request -func (o *GetReceiversParams) WriteToRequest(r runtime.ClientRequest, reg strfmt.Registry) error { - - if err := r.SetTimeout(o.timeout); err != nil { - return err - } - var res []error - - if len(res) > 0 { - return errors.CompositeValidationError(res...) - } - return nil -} diff --git a/test/with_api_v2/api_v2_client/client/general/get_receivers_responses.go b/test/with_api_v2/api_v2_client/client/general/get_receivers_responses.go deleted file mode 100644 index 3b9e30903b..0000000000 --- a/test/with_api_v2/api_v2_client/client/general/get_receivers_responses.go +++ /dev/null @@ -1,65 +0,0 @@ -// Code generated by go-swagger; DO NOT EDIT. - -package general - -// This file was generated by the swagger tool. -// Editing this file might prove futile when you re-run the swagger generate command - -import ( - "fmt" - "io" - - "github.com/go-openapi/runtime" - - strfmt "github.com/go-openapi/strfmt" - - models "github.com/prometheus/alertmanager/test/with_api_v2/api_v2_client/models" -) - -// GetReceiversReader is a Reader for the GetReceivers structure. -type GetReceiversReader struct { - formats strfmt.Registry -} - -// ReadResponse reads a server response into the received o. -func (o *GetReceiversReader) ReadResponse(response runtime.ClientResponse, consumer runtime.Consumer) (interface{}, error) { - switch response.Code() { - - case 200: - result := NewGetReceiversOK() - if err := result.readResponse(response, consumer, o.formats); err != nil { - return nil, err - } - return result, nil - - default: - return nil, runtime.NewAPIError("unknown error", response, response.Code()) - } -} - -// NewGetReceiversOK creates a GetReceiversOK with default headers values -func NewGetReceiversOK() *GetReceiversOK { - return &GetReceiversOK{} -} - -/*GetReceiversOK handles this case with default header values. - -Receivers response -*/ -type GetReceiversOK struct { - Payload []models.Receiver -} - -func (o *GetReceiversOK) Error() string { - return fmt.Sprintf("[GET /receivers][%d] getReceiversOK %+v", 200, o.Payload) -} - -func (o *GetReceiversOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { - - // response payload - if err := consumer.Consume(response.Body(), &o.Payload); err != nil && err != io.EOF { - return err - } - - return nil -} diff --git a/test/with_api_v2/api_v2_client/client/general/get_status_parameters.go b/test/with_api_v2/api_v2_client/client/general/get_status_parameters.go index 2fae2aee3c..db0c79e673 100644 --- a/test/with_api_v2/api_v2_client/client/general/get_status_parameters.go +++ b/test/with_api_v2/api_v2_client/client/general/get_status_parameters.go @@ -6,10 +6,11 @@ package general // Editing this file might prove futile when you re-run the swagger generate command import ( - "context" "net/http" "time" + "golang.org/x/net/context" + "github.com/go-openapi/errors" "github.com/go-openapi/runtime" cr "github.com/go-openapi/runtime/client" diff --git a/test/with_api_v2/api_v2_client/client/receiver/get_receivers_parameters.go b/test/with_api_v2/api_v2_client/client/receiver/get_receivers_parameters.go index fd2b08b0de..e0773d7b43 100644 --- a/test/with_api_v2/api_v2_client/client/receiver/get_receivers_parameters.go +++ b/test/with_api_v2/api_v2_client/client/receiver/get_receivers_parameters.go @@ -6,10 +6,11 @@ package receiver // Editing this file might prove futile when you re-run the swagger generate command import ( - "context" "net/http" "time" + "golang.org/x/net/context" + "github.com/go-openapi/errors" "github.com/go-openapi/runtime" cr "github.com/go-openapi/runtime/client" diff --git a/test/with_api_v2/api_v2_client/client/silence/delete_silence_parameters.go b/test/with_api_v2/api_v2_client/client/silence/delete_silence_parameters.go index 6b49b30289..96b21e399c 100644 --- a/test/with_api_v2/api_v2_client/client/silence/delete_silence_parameters.go +++ b/test/with_api_v2/api_v2_client/client/silence/delete_silence_parameters.go @@ -6,10 +6,11 @@ package silence // Editing this file might prove futile when you re-run the swagger generate command import ( - "context" "net/http" "time" + "golang.org/x/net/context" + "github.com/go-openapi/errors" "github.com/go-openapi/runtime" cr "github.com/go-openapi/runtime/client" diff --git a/test/with_api_v2/api_v2_client/client/silence/get_silence_parameters.go b/test/with_api_v2/api_v2_client/client/silence/get_silence_parameters.go index bd6f345044..ae9babbad6 100644 --- a/test/with_api_v2/api_v2_client/client/silence/get_silence_parameters.go +++ b/test/with_api_v2/api_v2_client/client/silence/get_silence_parameters.go @@ -6,10 +6,11 @@ package silence // Editing this file might prove futile when you re-run the swagger generate command import ( - "context" "net/http" "time" + "golang.org/x/net/context" + "github.com/go-openapi/errors" "github.com/go-openapi/runtime" cr "github.com/go-openapi/runtime/client" diff --git a/test/with_api_v2/api_v2_client/client/silence/get_silence_responses.go b/test/with_api_v2/api_v2_client/client/silence/get_silence_responses.go index 4c1ed0e8da..a891eb5315 100644 --- a/test/with_api_v2/api_v2_client/client/silence/get_silence_responses.go +++ b/test/with_api_v2/api_v2_client/client/silence/get_silence_responses.go @@ -61,7 +61,7 @@ func NewGetSilenceOK() *GetSilenceOK { Get silence response */ type GetSilenceOK struct { - Payload *models.Silence + Payload *models.GettableSilence } func (o *GetSilenceOK) Error() string { @@ -70,7 +70,7 @@ func (o *GetSilenceOK) Error() string { func (o *GetSilenceOK) readResponse(response runtime.ClientResponse, consumer runtime.Consumer, formats strfmt.Registry) error { - o.Payload = new(models.Silence) + o.Payload = new(models.GettableSilence) // response payload if err := consumer.Consume(response.Body(), o.Payload); err != nil && err != io.EOF { diff --git a/test/with_api_v2/api_v2_client/client/silence/get_silences_parameters.go b/test/with_api_v2/api_v2_client/client/silence/get_silences_parameters.go index f26119bec4..a7c2cedaca 100644 --- a/test/with_api_v2/api_v2_client/client/silence/get_silences_parameters.go +++ b/test/with_api_v2/api_v2_client/client/silence/get_silences_parameters.go @@ -6,10 +6,11 @@ package silence // Editing this file might prove futile when you re-run the swagger generate command import ( - "context" "net/http" "time" + "golang.org/x/net/context" + "github.com/go-openapi/errors" "github.com/go-openapi/runtime" cr "github.com/go-openapi/runtime/client" diff --git a/test/with_api_v2/api_v2_client/client/silence/get_silences_responses.go b/test/with_api_v2/api_v2_client/client/silence/get_silences_responses.go index 9edd74295f..4e6338f516 100644 --- a/test/with_api_v2/api_v2_client/client/silence/get_silences_responses.go +++ b/test/with_api_v2/api_v2_client/client/silence/get_silences_responses.go @@ -54,7 +54,7 @@ func NewGetSilencesOK() *GetSilencesOK { Get silences response */ type GetSilencesOK struct { - Payload models.Silences + Payload models.GettableSilences } func (o *GetSilencesOK) Error() string { diff --git a/test/with_api_v2/api_v2_client/client/silence/post_silences_parameters.go b/test/with_api_v2/api_v2_client/client/silence/post_silences_parameters.go index f0dd9a2cce..2814392470 100644 --- a/test/with_api_v2/api_v2_client/client/silence/post_silences_parameters.go +++ b/test/with_api_v2/api_v2_client/client/silence/post_silences_parameters.go @@ -6,10 +6,11 @@ package silence // Editing this file might prove futile when you re-run the swagger generate command import ( - "context" "net/http" "time" + "golang.org/x/net/context" + "github.com/go-openapi/errors" "github.com/go-openapi/runtime" cr "github.com/go-openapi/runtime/client" @@ -67,7 +68,7 @@ type PostSilencesParams struct { The silence to create */ - Silence *models.Silence + Silence *models.PostableSilence timeout time.Duration Context context.Context @@ -108,13 +109,13 @@ func (o *PostSilencesParams) SetHTTPClient(client *http.Client) { } // WithSilence adds the silence to the post silences params -func (o *PostSilencesParams) WithSilence(silence *models.Silence) *PostSilencesParams { +func (o *PostSilencesParams) WithSilence(silence *models.PostableSilence) *PostSilencesParams { o.SetSilence(silence) return o } // SetSilence adds the silence to the post silences params -func (o *PostSilencesParams) SetSilence(silence *models.Silence) { +func (o *PostSilencesParams) SetSilence(silence *models.PostableSilence) { o.Silence = silence } diff --git a/test/with_api_v2/api_v2_client/models/alert.go b/test/with_api_v2/api_v2_client/models/alert.go index 4a399eed78..0755b385d3 100644 --- a/test/with_api_v2/api_v2_client/models/alert.go +++ b/test/with_api_v2/api_v2_client/models/alert.go @@ -6,7 +6,6 @@ package models // Editing this file might prove futile when you re-run the swagger generate command import ( - "encoding/json" "strconv" strfmt "github.com/go-openapi/strfmt" @@ -35,7 +34,8 @@ type Alert struct { GeneratorURL strfmt.URI `json:"generatorURL,omitempty"` // labels - Labels LabelSet `json:"labels,omitempty"` + // Required: true + Labels LabelSet `json:"labels"` // receivers Receivers []*Receiver `json:"receivers"` @@ -138,10 +138,6 @@ func (m *Alert) validateGeneratorURL(formats strfmt.Registry) error { func (m *Alert) validateLabels(formats strfmt.Registry) error { - if swag.IsZero(m.Labels) { // not required - return nil - } - if err := m.Labels.Validate(formats); err != nil { if ve, ok := err.(*errors.Validation); ok { return ve.ValidateName("labels") @@ -238,96 +234,3 @@ func (m *Alert) UnmarshalBinary(b []byte) error { *m = res return nil } - -// AlertStatus alert status -// swagger:model AlertStatus -type AlertStatus struct { - - // inhibited by - InhibitedBy []string `json:"inhibitedBy"` - - // silenced by - SilencedBy []string `json:"silencedBy"` - - // state - // Enum: [unprocessed active suppressed] - State string `json:"state,omitempty"` -} - -// Validate validates this alert status -func (m *AlertStatus) Validate(formats strfmt.Registry) error { - var res []error - - if err := m.validateState(formats); err != nil { - res = append(res, err) - } - - if len(res) > 0 { - return errors.CompositeValidationError(res...) - } - return nil -} - -var alertStatusTypeStatePropEnum []interface{} - -func init() { - var res []string - if err := json.Unmarshal([]byte(`["unprocessed","active","suppressed"]`), &res); err != nil { - panic(err) - } - for _, v := range res { - alertStatusTypeStatePropEnum = append(alertStatusTypeStatePropEnum, v) - } -} - -const ( - - // AlertStatusStateUnprocessed captures enum value "unprocessed" - AlertStatusStateUnprocessed string = "unprocessed" - - // AlertStatusStateActive captures enum value "active" - AlertStatusStateActive string = "active" - - // AlertStatusStateSuppressed captures enum value "suppressed" - AlertStatusStateSuppressed string = "suppressed" -) - -// prop value enum -func (m *AlertStatus) validateStateEnum(path, location string, value string) error { - if err := validate.Enum(path, location, value, alertStatusTypeStatePropEnum); err != nil { - return err - } - return nil -} - -func (m *AlertStatus) validateState(formats strfmt.Registry) error { - - if swag.IsZero(m.State) { // not required - return nil - } - - // value enum - if err := m.validateStateEnum("status"+"."+"state", "body", m.State); err != nil { - return err - } - - return nil -} - -// MarshalBinary interface implementation -func (m *AlertStatus) MarshalBinary() ([]byte, error) { - if m == nil { - return nil, nil - } - return swag.WriteJSON(m) -} - -// UnmarshalBinary interface implementation -func (m *AlertStatus) UnmarshalBinary(b []byte) error { - var res AlertStatus - if err := swag.ReadJSON(b, &res); err != nil { - return err - } - *m = res - return nil -} diff --git a/test/with_api_v2/api_v2_client/models/alert_status.go b/test/with_api_v2/api_v2_client/models/alert_status.go new file mode 100644 index 0000000000..673deaabda --- /dev/null +++ b/test/with_api_v2/api_v2_client/models/alert_status.go @@ -0,0 +1,138 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// AlertStatus alert status +// swagger:model alertStatus +type AlertStatus struct { + + // inhibited by + // Required: true + InhibitedBy []string `json:"inhibitedBy"` + + // silenced by + // Required: true + SilencedBy []string `json:"silencedBy"` + + // state + // Required: true + // Enum: [unprocessed active suppressed] + State *string `json:"state"` +} + +// Validate validates this alert status +func (m *AlertStatus) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateInhibitedBy(formats); err != nil { + res = append(res, err) + } + + if err := m.validateSilencedBy(formats); err != nil { + res = append(res, err) + } + + if err := m.validateState(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *AlertStatus) validateInhibitedBy(formats strfmt.Registry) error { + + if err := validate.Required("inhibitedBy", "body", m.InhibitedBy); err != nil { + return err + } + + return nil +} + +func (m *AlertStatus) validateSilencedBy(formats strfmt.Registry) error { + + if err := validate.Required("silencedBy", "body", m.SilencedBy); err != nil { + return err + } + + return nil +} + +var alertStatusTypeStatePropEnum []interface{} + +func init() { + var res []string + if err := json.Unmarshal([]byte(`["unprocessed","active","suppressed"]`), &res); err != nil { + panic(err) + } + for _, v := range res { + alertStatusTypeStatePropEnum = append(alertStatusTypeStatePropEnum, v) + } +} + +const ( + + // AlertStatusStateUnprocessed captures enum value "unprocessed" + AlertStatusStateUnprocessed string = "unprocessed" + + // AlertStatusStateActive captures enum value "active" + AlertStatusStateActive string = "active" + + // AlertStatusStateSuppressed captures enum value "suppressed" + AlertStatusStateSuppressed string = "suppressed" +) + +// prop value enum +func (m *AlertStatus) validateStateEnum(path, location string, value string) error { + if err := validate.Enum(path, location, value, alertStatusTypeStatePropEnum); err != nil { + return err + } + return nil +} + +func (m *AlertStatus) validateState(formats strfmt.Registry) error { + + if err := validate.Required("state", "body", m.State); err != nil { + return err + } + + // value enum + if err := m.validateStateEnum("state", "body", *m.State); err != nil { + return err + } + + return nil +} + +// MarshalBinary interface implementation +func (m *AlertStatus) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *AlertStatus) UnmarshalBinary(b []byte) error { + var res AlertStatus + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/test/with_api_v2/api_v2_client/models/alertmanager_config.go b/test/with_api_v2/api_v2_client/models/alertmanager_config.go new file mode 100644 index 0000000000..6b41f1bcd3 --- /dev/null +++ b/test/with_api_v2/api_v2_client/models/alertmanager_config.go @@ -0,0 +1,64 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// AlertmanagerConfig alertmanager config +// swagger:model alertmanagerConfig +type AlertmanagerConfig struct { + + // original + // Required: true + Original *string `json:"original"` +} + +// Validate validates this alertmanager config +func (m *AlertmanagerConfig) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateOriginal(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *AlertmanagerConfig) validateOriginal(formats strfmt.Registry) error { + + if err := validate.Required("original", "body", m.Original); err != nil { + return err + } + + return nil +} + +// MarshalBinary interface implementation +func (m *AlertmanagerConfig) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *AlertmanagerConfig) UnmarshalBinary(b []byte) error { + var res AlertmanagerConfig + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/test/with_api_v2/api_v2_client/models/alertmanager_status.go b/test/with_api_v2/api_v2_client/models/alertmanager_status.go index d205a60a39..5c6c785df0 100644 --- a/test/with_api_v2/api_v2_client/models/alertmanager_status.go +++ b/test/with_api_v2/api_v2_client/models/alertmanager_status.go @@ -6,8 +6,6 @@ package models // Editing this file might prove futile when you re-run the swagger generate command import ( - "strconv" - strfmt "github.com/go-openapi/strfmt" "github.com/go-openapi/errors" @@ -19,33 +17,41 @@ import ( // swagger:model alertmanagerStatus type AlertmanagerStatus struct { - // name + // cluster + // Required: true + Cluster *ClusterStatus `json:"cluster"` + + // config // Required: true - Name *string `json:"name"` + Config *AlertmanagerConfig `json:"config"` - // peers + // uptime // Required: true - // Minimum: 0 - Peers []*PeerStatus `json:"peers"` + // Format: date-time + Uptime *strfmt.DateTime `json:"uptime"` - // status in cluster + // version info // Required: true - StatusInCluster *string `json:"statusInCluster"` + VersionInfo *VersionInfo `json:"versionInfo"` } // Validate validates this alertmanager status func (m *AlertmanagerStatus) Validate(formats strfmt.Registry) error { var res []error - if err := m.validateName(formats); err != nil { + if err := m.validateCluster(formats); err != nil { res = append(res, err) } - if err := m.validatePeers(formats); err != nil { + if err := m.validateConfig(formats); err != nil { res = append(res, err) } - if err := m.validateStatusInCluster(formats); err != nil { + if err := m.validateUptime(formats); err != nil { + res = append(res, err) + } + + if err := m.validateVersionInfo(formats); err != nil { res = append(res, err) } @@ -55,46 +61,70 @@ func (m *AlertmanagerStatus) Validate(formats strfmt.Registry) error { return nil } -func (m *AlertmanagerStatus) validateName(formats strfmt.Registry) error { +func (m *AlertmanagerStatus) validateCluster(formats strfmt.Registry) error { - if err := validate.Required("name", "body", m.Name); err != nil { + if err := validate.Required("cluster", "body", m.Cluster); err != nil { return err } + if m.Cluster != nil { + if err := m.Cluster.Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("cluster") + } + return err + } + } + return nil } -func (m *AlertmanagerStatus) validatePeers(formats strfmt.Registry) error { +func (m *AlertmanagerStatus) validateConfig(formats strfmt.Registry) error { - if err := validate.Required("peers", "body", m.Peers); err != nil { + if err := validate.Required("config", "body", m.Config); err != nil { return err } - for i := 0; i < len(m.Peers); i++ { - if swag.IsZero(m.Peers[i]) { // not required - continue - } - - if m.Peers[i] != nil { - if err := m.Peers[i].Validate(formats); err != nil { - if ve, ok := err.(*errors.Validation); ok { - return ve.ValidateName("peers" + "." + strconv.Itoa(i)) - } - return err + if m.Config != nil { + if err := m.Config.Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("config") } + return err } + } + return nil +} + +func (m *AlertmanagerStatus) validateUptime(formats strfmt.Registry) error { + + if err := validate.Required("uptime", "body", m.Uptime); err != nil { + return err + } + + if err := validate.FormatOf("uptime", "body", "date-time", m.Uptime.String(), formats); err != nil { + return err } return nil } -func (m *AlertmanagerStatus) validateStatusInCluster(formats strfmt.Registry) error { +func (m *AlertmanagerStatus) validateVersionInfo(formats strfmt.Registry) error { - if err := validate.Required("statusInCluster", "body", m.StatusInCluster); err != nil { + if err := validate.Required("versionInfo", "body", m.VersionInfo); err != nil { return err } + if m.VersionInfo != nil { + if err := m.VersionInfo.Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("versionInfo") + } + return err + } + } + return nil } diff --git a/test/with_api_v2/api_v2_client/models/cluster_status.go b/test/with_api_v2/api_v2_client/models/cluster_status.go new file mode 100644 index 0000000000..2ce826ecca --- /dev/null +++ b/test/with_api_v2/api_v2_client/models/cluster_status.go @@ -0,0 +1,117 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "strconv" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// ClusterStatus cluster status +// swagger:model clusterStatus +type ClusterStatus struct { + + // name + // Required: true + Name *string `json:"name"` + + // peers + // Required: true + // Minimum: 0 + Peers []*PeerStatus `json:"peers"` + + // status + // Required: true + Status *string `json:"status"` +} + +// Validate validates this cluster status +func (m *ClusterStatus) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateName(formats); err != nil { + res = append(res, err) + } + + if err := m.validatePeers(formats); err != nil { + res = append(res, err) + } + + if err := m.validateStatus(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *ClusterStatus) validateName(formats strfmt.Registry) error { + + if err := validate.Required("name", "body", m.Name); err != nil { + return err + } + + return nil +} + +func (m *ClusterStatus) validatePeers(formats strfmt.Registry) error { + + if err := validate.Required("peers", "body", m.Peers); err != nil { + return err + } + + for i := 0; i < len(m.Peers); i++ { + if swag.IsZero(m.Peers[i]) { // not required + continue + } + + if m.Peers[i] != nil { + if err := m.Peers[i].Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("peers" + "." + strconv.Itoa(i)) + } + return err + } + } + + } + + return nil +} + +func (m *ClusterStatus) validateStatus(formats strfmt.Registry) error { + + if err := validate.Required("status", "body", m.Status); err != nil { + return err + } + + return nil +} + +// MarshalBinary interface implementation +func (m *ClusterStatus) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *ClusterStatus) UnmarshalBinary(b []byte) error { + var res ClusterStatus + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/test/with_api_v2/api_v2_client/models/gettable_silence.go b/test/with_api_v2/api_v2_client/models/gettable_silence.go new file mode 100644 index 0000000000..a03412d2b6 --- /dev/null +++ b/test/with_api_v2/api_v2_client/models/gettable_silence.go @@ -0,0 +1,182 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// GettableSilence gettable silence +// swagger:model gettableSilence +type GettableSilence struct { + + // id + // Required: true + ID *string `json:"id"` + + // status + // Required: true + Status *SilenceStatus `json:"status"` + + // updated at + // Required: true + // Format: date-time + UpdatedAt *strfmt.DateTime `json:"updatedAt"` + + Silence +} + +// UnmarshalJSON unmarshals this object from a JSON structure +func (m *GettableSilence) UnmarshalJSON(raw []byte) error { + // AO0 + var dataAO0 struct { + ID *string `json:"id"` + + Status *SilenceStatus `json:"status"` + + UpdatedAt *strfmt.DateTime `json:"updatedAt"` + } + if err := swag.ReadJSON(raw, &dataAO0); err != nil { + return err + } + + m.ID = dataAO0.ID + + m.Status = dataAO0.Status + + m.UpdatedAt = dataAO0.UpdatedAt + + // AO1 + var aO1 Silence + if err := swag.ReadJSON(raw, &aO1); err != nil { + return err + } + m.Silence = aO1 + + return nil +} + +// MarshalJSON marshals this object to a JSON structure +func (m GettableSilence) MarshalJSON() ([]byte, error) { + _parts := make([][]byte, 0, 2) + + var dataAO0 struct { + ID *string `json:"id"` + + Status *SilenceStatus `json:"status"` + + UpdatedAt *strfmt.DateTime `json:"updatedAt"` + } + + dataAO0.ID = m.ID + + dataAO0.Status = m.Status + + dataAO0.UpdatedAt = m.UpdatedAt + + jsonDataAO0, errAO0 := swag.WriteJSON(dataAO0) + if errAO0 != nil { + return nil, errAO0 + } + _parts = append(_parts, jsonDataAO0) + + aO1, err := swag.WriteJSON(m.Silence) + if err != nil { + return nil, err + } + _parts = append(_parts, aO1) + + return swag.ConcatJSON(_parts...), nil +} + +// Validate validates this gettable silence +func (m *GettableSilence) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateID(formats); err != nil { + res = append(res, err) + } + + if err := m.validateStatus(formats); err != nil { + res = append(res, err) + } + + if err := m.validateUpdatedAt(formats); err != nil { + res = append(res, err) + } + + // validation for a type composition with Silence + if err := m.Silence.Validate(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *GettableSilence) validateID(formats strfmt.Registry) error { + + if err := validate.Required("id", "body", m.ID); err != nil { + return err + } + + return nil +} + +func (m *GettableSilence) validateStatus(formats strfmt.Registry) error { + + if err := validate.Required("status", "body", m.Status); err != nil { + return err + } + + if m.Status != nil { + if err := m.Status.Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("status") + } + return err + } + } + + return nil +} + +func (m *GettableSilence) validateUpdatedAt(formats strfmt.Registry) error { + + if err := validate.Required("updatedAt", "body", m.UpdatedAt); err != nil { + return err + } + + if err := validate.FormatOf("updatedAt", "body", "date-time", m.UpdatedAt.String(), formats); err != nil { + return err + } + + return nil +} + +// MarshalBinary interface implementation +func (m *GettableSilence) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *GettableSilence) UnmarshalBinary(b []byte) error { + var res GettableSilence + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/test/with_api_v2/api_v2_client/models/silences.go b/test/with_api_v2/api_v2_client/models/gettable_silences.go similarity index 75% rename from test/with_api_v2/api_v2_client/models/silences.go rename to test/with_api_v2/api_v2_client/models/gettable_silences.go index 0906a700f8..3993a967da 100644 --- a/test/with_api_v2/api_v2_client/models/silences.go +++ b/test/with_api_v2/api_v2_client/models/gettable_silences.go @@ -14,12 +14,12 @@ import ( "github.com/go-openapi/swag" ) -// Silences silences -// swagger:model silences -type Silences []*Silence +// GettableSilences gettable silences +// swagger:model gettableSilences +type GettableSilences []*GettableSilence -// Validate validates this silences -func (m Silences) Validate(formats strfmt.Registry) error { +// Validate validates this gettable silences +func (m GettableSilences) Validate(formats strfmt.Registry) error { var res []error for i := 0; i < len(m); i++ { diff --git a/test/with_api_v2/api_v2_client/models/matcher.go b/test/with_api_v2/api_v2_client/models/matcher.go index f626e306a8..78bc819472 100644 --- a/test/with_api_v2/api_v2_client/models/matcher.go +++ b/test/with_api_v2/api_v2_client/models/matcher.go @@ -8,7 +8,9 @@ package models import ( strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/errors" "github.com/go-openapi/swag" + "github.com/go-openapi/validate" ) // Matcher matcher @@ -16,20 +18,64 @@ import ( type Matcher struct { // is regex - IsRegex bool `json:"isRegex,omitempty"` + // Required: true + IsRegex *bool `json:"isRegex"` // name - Name string `json:"name,omitempty"` - - // regex - Regex string `json:"regex,omitempty"` + // Required: true + Name *string `json:"name"` // value - Value string `json:"value,omitempty"` + // Required: true + Value *string `json:"value"` } // Validate validates this matcher func (m *Matcher) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateIsRegex(formats); err != nil { + res = append(res, err) + } + + if err := m.validateName(formats); err != nil { + res = append(res, err) + } + + if err := m.validateValue(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Matcher) validateIsRegex(formats strfmt.Registry) error { + + if err := validate.Required("isRegex", "body", m.IsRegex); err != nil { + return err + } + + return nil +} + +func (m *Matcher) validateName(formats strfmt.Registry) error { + + if err := validate.Required("name", "body", m.Name); err != nil { + return err + } + + return nil +} + +func (m *Matcher) validateValue(formats strfmt.Registry) error { + + if err := validate.Required("value", "body", m.Value); err != nil { + return err + } + return nil } diff --git a/test/with_api_v2/api_v2_client/models/peer_status.go b/test/with_api_v2/api_v2_client/models/peer_status.go index ddfd58b18f..9d9c34f404 100644 --- a/test/with_api_v2/api_v2_client/models/peer_status.go +++ b/test/with_api_v2/api_v2_client/models/peer_status.go @@ -8,7 +8,9 @@ package models import ( strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/errors" "github.com/go-openapi/swag" + "github.com/go-openapi/validate" ) // PeerStatus peer status @@ -16,14 +18,47 @@ import ( type PeerStatus struct { // address - Address string `json:"address,omitempty"` + // Required: true + Address *string `json:"address"` // name - Name string `json:"name,omitempty"` + // Required: true + Name *string `json:"name"` } // Validate validates this peer status func (m *PeerStatus) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateAddress(formats); err != nil { + res = append(res, err) + } + + if err := m.validateName(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *PeerStatus) validateAddress(formats strfmt.Registry) error { + + if err := validate.Required("address", "body", m.Address); err != nil { + return err + } + + return nil +} + +func (m *PeerStatus) validateName(formats strfmt.Registry) error { + + if err := validate.Required("name", "body", m.Name); err != nil { + return err + } + return nil } diff --git a/test/with_api_v2/api_v2_client/models/postable_silence.go b/test/with_api_v2/api_v2_client/models/postable_silence.go new file mode 100644 index 0000000000..1fa1fb2910 --- /dev/null +++ b/test/with_api_v2/api_v2_client/models/postable_silence.go @@ -0,0 +1,103 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/swag" +) + +// PostableSilence postable silence +// swagger:model postableSilence +type PostableSilence struct { + + // id + ID string `json:"id,omitempty"` + + Silence +} + +// UnmarshalJSON unmarshals this object from a JSON structure +func (m *PostableSilence) UnmarshalJSON(raw []byte) error { + // AO0 + var dataAO0 struct { + ID string `json:"id,omitempty"` + } + if err := swag.ReadJSON(raw, &dataAO0); err != nil { + return err + } + + m.ID = dataAO0.ID + + // AO1 + var aO1 Silence + if err := swag.ReadJSON(raw, &aO1); err != nil { + return err + } + m.Silence = aO1 + + return nil +} + +// MarshalJSON marshals this object to a JSON structure +func (m PostableSilence) MarshalJSON() ([]byte, error) { + _parts := make([][]byte, 0, 2) + + var dataAO0 struct { + ID string `json:"id,omitempty"` + } + + dataAO0.ID = m.ID + + jsonDataAO0, errAO0 := swag.WriteJSON(dataAO0) + if errAO0 != nil { + return nil, errAO0 + } + _parts = append(_parts, jsonDataAO0) + + aO1, err := swag.WriteJSON(m.Silence) + if err != nil { + return nil, err + } + _parts = append(_parts, aO1) + + return swag.ConcatJSON(_parts...), nil +} + +// Validate validates this postable silence +func (m *PostableSilence) Validate(formats strfmt.Registry) error { + var res []error + + // validation for a type composition with Silence + if err := m.Silence.Validate(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +// MarshalBinary interface implementation +func (m *PostableSilence) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *PostableSilence) UnmarshalBinary(b []byte) error { + var res PostableSilence + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/test/with_api_v2/api_v2_client/models/receiver.go b/test/with_api_v2/api_v2_client/models/receiver.go index e7ceccef43..61c2748a55 100644 --- a/test/with_api_v2/api_v2_client/models/receiver.go +++ b/test/with_api_v2/api_v2_client/models/receiver.go @@ -8,7 +8,9 @@ package models import ( strfmt "github.com/go-openapi/strfmt" + "github.com/go-openapi/errors" "github.com/go-openapi/swag" + "github.com/go-openapi/validate" ) // Receiver receiver @@ -16,11 +18,30 @@ import ( type Receiver struct { // name - Name string `json:"name,omitempty"` + // Required: true + Name *string `json:"name"` } // Validate validates this receiver func (m *Receiver) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateName(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *Receiver) validateName(formats strfmt.Registry) error { + + if err := validate.Required("name", "body", m.Name); err != nil { + return err + } + return nil } diff --git a/test/with_api_v2/api_v2_client/models/silence.go b/test/with_api_v2/api_v2_client/models/silence.go index 747edcfa35..742ba17d78 100644 --- a/test/with_api_v2/api_v2_client/models/silence.go +++ b/test/with_api_v2/api_v2_client/models/silence.go @@ -6,8 +6,6 @@ package models // Editing this file might prove futile when you re-run the swagger generate command import ( - "encoding/json" - strfmt "github.com/go-openapi/strfmt" "github.com/go-openapi/errors" @@ -20,55 +18,49 @@ import ( type Silence struct { // comment - Comment string `json:"comment,omitempty"` + // Required: true + Comment *string `json:"comment"` // created by - CreatedBy string `json:"createdBy,omitempty"` + // Required: true + CreatedBy *string `json:"createdBy"` // ends at + // Required: true // Format: date-time - EndsAt strfmt.DateTime `json:"endsAt,omitempty"` - - // id - ID string `json:"id,omitempty"` + EndsAt *strfmt.DateTime `json:"endsAt"` // matchers // Required: true Matchers Matchers `json:"matchers"` // starts at + // Required: true // Format: date-time - StartsAt strfmt.DateTime `json:"startsAt,omitempty"` - - // status - Status *SilenceStatus `json:"status,omitempty"` - - // updated at - // Format: date-time - UpdatedAt strfmt.DateTime `json:"updatedAt,omitempty"` + StartsAt *strfmt.DateTime `json:"startsAt"` } // Validate validates this silence func (m *Silence) Validate(formats strfmt.Registry) error { var res []error - if err := m.validateEndsAt(formats); err != nil { + if err := m.validateComment(formats); err != nil { res = append(res, err) } - if err := m.validateMatchers(formats); err != nil { + if err := m.validateCreatedBy(formats); err != nil { res = append(res, err) } - if err := m.validateStartsAt(formats); err != nil { + if err := m.validateEndsAt(formats); err != nil { res = append(res, err) } - if err := m.validateStatus(formats); err != nil { + if err := m.validateMatchers(formats); err != nil { res = append(res, err) } - if err := m.validateUpdatedAt(formats); err != nil { + if err := m.validateStartsAt(formats); err != nil { res = append(res, err) } @@ -78,73 +70,60 @@ func (m *Silence) Validate(formats strfmt.Registry) error { return nil } -func (m *Silence) validateEndsAt(formats strfmt.Registry) error { - - if swag.IsZero(m.EndsAt) { // not required - return nil - } +func (m *Silence) validateComment(formats strfmt.Registry) error { - if err := validate.FormatOf("endsAt", "body", "date-time", m.EndsAt.String(), formats); err != nil { + if err := validate.Required("comment", "body", m.Comment); err != nil { return err } return nil } -func (m *Silence) validateMatchers(formats strfmt.Registry) error { - - if err := validate.Required("matchers", "body", m.Matchers); err != nil { - return err - } +func (m *Silence) validateCreatedBy(formats strfmt.Registry) error { - if err := m.Matchers.Validate(formats); err != nil { - if ve, ok := err.(*errors.Validation); ok { - return ve.ValidateName("matchers") - } + if err := validate.Required("createdBy", "body", m.CreatedBy); err != nil { return err } return nil } -func (m *Silence) validateStartsAt(formats strfmt.Registry) error { +func (m *Silence) validateEndsAt(formats strfmt.Registry) error { - if swag.IsZero(m.StartsAt) { // not required - return nil + if err := validate.Required("endsAt", "body", m.EndsAt); err != nil { + return err } - if err := validate.FormatOf("startsAt", "body", "date-time", m.StartsAt.String(), formats); err != nil { + if err := validate.FormatOf("endsAt", "body", "date-time", m.EndsAt.String(), formats); err != nil { return err } return nil } -func (m *Silence) validateStatus(formats strfmt.Registry) error { +func (m *Silence) validateMatchers(formats strfmt.Registry) error { - if swag.IsZero(m.Status) { // not required - return nil + if err := validate.Required("matchers", "body", m.Matchers); err != nil { + return err } - if m.Status != nil { - if err := m.Status.Validate(formats); err != nil { - if ve, ok := err.(*errors.Validation); ok { - return ve.ValidateName("status") - } - return err + if err := m.Matchers.Validate(formats); err != nil { + if ve, ok := err.(*errors.Validation); ok { + return ve.ValidateName("matchers") } + return err } return nil } -func (m *Silence) validateUpdatedAt(formats strfmt.Registry) error { +func (m *Silence) validateStartsAt(formats strfmt.Registry) error { - if swag.IsZero(m.UpdatedAt) { // not required - return nil + if err := validate.Required("startsAt", "body", m.StartsAt); err != nil { + return err } - if err := validate.FormatOf("updatedAt", "body", "date-time", m.UpdatedAt.String(), formats); err != nil { + if err := validate.FormatOf("startsAt", "body", "date-time", m.StartsAt.String(), formats); err != nil { return err } @@ -168,90 +147,3 @@ func (m *Silence) UnmarshalBinary(b []byte) error { *m = res return nil } - -// SilenceStatus silence status -// swagger:model SilenceStatus -type SilenceStatus struct { - - // state - // Enum: [expired active pending] - State string `json:"state,omitempty"` -} - -// Validate validates this silence status -func (m *SilenceStatus) Validate(formats strfmt.Registry) error { - var res []error - - if err := m.validateState(formats); err != nil { - res = append(res, err) - } - - if len(res) > 0 { - return errors.CompositeValidationError(res...) - } - return nil -} - -var silenceStatusTypeStatePropEnum []interface{} - -func init() { - var res []string - if err := json.Unmarshal([]byte(`["expired","active","pending"]`), &res); err != nil { - panic(err) - } - for _, v := range res { - silenceStatusTypeStatePropEnum = append(silenceStatusTypeStatePropEnum, v) - } -} - -const ( - - // SilenceStatusStateExpired captures enum value "expired" - SilenceStatusStateExpired string = "expired" - - // SilenceStatusStateActive captures enum value "active" - SilenceStatusStateActive string = "active" - - // SilenceStatusStatePending captures enum value "pending" - SilenceStatusStatePending string = "pending" -) - -// prop value enum -func (m *SilenceStatus) validateStateEnum(path, location string, value string) error { - if err := validate.Enum(path, location, value, silenceStatusTypeStatePropEnum); err != nil { - return err - } - return nil -} - -func (m *SilenceStatus) validateState(formats strfmt.Registry) error { - - if swag.IsZero(m.State) { // not required - return nil - } - - // value enum - if err := m.validateStateEnum("status"+"."+"state", "body", m.State); err != nil { - return err - } - - return nil -} - -// MarshalBinary interface implementation -func (m *SilenceStatus) MarshalBinary() ([]byte, error) { - if m == nil { - return nil, nil - } - return swag.WriteJSON(m) -} - -// UnmarshalBinary interface implementation -func (m *SilenceStatus) UnmarshalBinary(b []byte) error { - var res SilenceStatus - if err := swag.ReadJSON(b, &res); err != nil { - return err - } - *m = res - return nil -} diff --git a/test/with_api_v2/api_v2_client/models/silence_status.go b/test/with_api_v2/api_v2_client/models/silence_status.go new file mode 100644 index 0000000000..82c9b435de --- /dev/null +++ b/test/with_api_v2/api_v2_client/models/silence_status.go @@ -0,0 +1,104 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + "encoding/json" + + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// SilenceStatus silence status +// swagger:model silenceStatus +type SilenceStatus struct { + + // state + // Required: true + // Enum: [expired active pending] + State *string `json:"state"` +} + +// Validate validates this silence status +func (m *SilenceStatus) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateState(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +var silenceStatusTypeStatePropEnum []interface{} + +func init() { + var res []string + if err := json.Unmarshal([]byte(`["expired","active","pending"]`), &res); err != nil { + panic(err) + } + for _, v := range res { + silenceStatusTypeStatePropEnum = append(silenceStatusTypeStatePropEnum, v) + } +} + +const ( + + // SilenceStatusStateExpired captures enum value "expired" + SilenceStatusStateExpired string = "expired" + + // SilenceStatusStateActive captures enum value "active" + SilenceStatusStateActive string = "active" + + // SilenceStatusStatePending captures enum value "pending" + SilenceStatusStatePending string = "pending" +) + +// prop value enum +func (m *SilenceStatus) validateStateEnum(path, location string, value string) error { + if err := validate.Enum(path, location, value, silenceStatusTypeStatePropEnum); err != nil { + return err + } + return nil +} + +func (m *SilenceStatus) validateState(formats strfmt.Registry) error { + + if err := validate.Required("state", "body", m.State); err != nil { + return err + } + + // value enum + if err := m.validateStateEnum("state", "body", *m.State); err != nil { + return err + } + + return nil +} + +// MarshalBinary interface implementation +func (m *SilenceStatus) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *SilenceStatus) UnmarshalBinary(b []byte) error { + var res SilenceStatus + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/test/with_api_v2/api_v2_client/models/version_info.go b/test/with_api_v2/api_v2_client/models/version_info.go new file mode 100644 index 0000000000..5cdbc2bdd5 --- /dev/null +++ b/test/with_api_v2/api_v2_client/models/version_info.go @@ -0,0 +1,149 @@ +// Code generated by go-swagger; DO NOT EDIT. + +package models + +// This file was generated by the swagger tool. +// Editing this file might prove futile when you re-run the swagger generate command + +import ( + strfmt "github.com/go-openapi/strfmt" + + "github.com/go-openapi/errors" + "github.com/go-openapi/swag" + "github.com/go-openapi/validate" +) + +// VersionInfo version info +// swagger:model versionInfo +type VersionInfo struct { + + // branch + // Required: true + Branch *string `json:"branch"` + + // build date + // Required: true + BuildDate *string `json:"buildDate"` + + // build user + // Required: true + BuildUser *string `json:"buildUser"` + + // go version + // Required: true + GoVersion *string `json:"goVersion"` + + // revision + // Required: true + Revision *string `json:"revision"` + + // version + // Required: true + Version *string `json:"version"` +} + +// Validate validates this version info +func (m *VersionInfo) Validate(formats strfmt.Registry) error { + var res []error + + if err := m.validateBranch(formats); err != nil { + res = append(res, err) + } + + if err := m.validateBuildDate(formats); err != nil { + res = append(res, err) + } + + if err := m.validateBuildUser(formats); err != nil { + res = append(res, err) + } + + if err := m.validateGoVersion(formats); err != nil { + res = append(res, err) + } + + if err := m.validateRevision(formats); err != nil { + res = append(res, err) + } + + if err := m.validateVersion(formats); err != nil { + res = append(res, err) + } + + if len(res) > 0 { + return errors.CompositeValidationError(res...) + } + return nil +} + +func (m *VersionInfo) validateBranch(formats strfmt.Registry) error { + + if err := validate.Required("branch", "body", m.Branch); err != nil { + return err + } + + return nil +} + +func (m *VersionInfo) validateBuildDate(formats strfmt.Registry) error { + + if err := validate.Required("buildDate", "body", m.BuildDate); err != nil { + return err + } + + return nil +} + +func (m *VersionInfo) validateBuildUser(formats strfmt.Registry) error { + + if err := validate.Required("buildUser", "body", m.BuildUser); err != nil { + return err + } + + return nil +} + +func (m *VersionInfo) validateGoVersion(formats strfmt.Registry) error { + + if err := validate.Required("goVersion", "body", m.GoVersion); err != nil { + return err + } + + return nil +} + +func (m *VersionInfo) validateRevision(formats strfmt.Registry) error { + + if err := validate.Required("revision", "body", m.Revision); err != nil { + return err + } + + return nil +} + +func (m *VersionInfo) validateVersion(formats strfmt.Registry) error { + + if err := validate.Required("version", "body", m.Version); err != nil { + return err + } + + return nil +} + +// MarshalBinary interface implementation +func (m *VersionInfo) MarshalBinary() ([]byte, error) { + if m == nil { + return nil, nil + } + return swag.WriteJSON(m) +} + +// UnmarshalBinary interface implementation +func (m *VersionInfo) UnmarshalBinary(b []byte) error { + var res VersionInfo + if err := swag.ReadJSON(b, &res); err != nil { + return err + } + *m = res + return nil +} diff --git a/test/with_api_v2/mock.go b/test/with_api_v2/mock.go index 944ae412a8..6915b77ddf 100644 --- a/test/with_api_v2/mock.go +++ b/test/with_api_v2/mock.go @@ -108,26 +108,31 @@ func (s *TestSilence) nativeSilence(opts *AcceptanceOpts) *models.Silence { for i := 0; i < len(s.match); i += 2 { nsil.Matchers = append(nsil.Matchers, &models.Matcher{ - Name: s.match[i], - Value: s.match[i+1], + Name: &s.match[i], + Value: &s.match[i+1], }) } + t := true for i := 0; i < len(s.matchRE); i += 2 { nsil.Matchers = append(nsil.Matchers, &models.Matcher{ - Name: s.matchRE[i], - Value: s.matchRE[i+1], - IsRegex: true, + Name: &s.matchRE[i], + Value: &s.matchRE[i+1], + IsRegex: &t, }) } if s.startsAt > 0 { - nsil.StartsAt = strfmt.DateTime(opts.expandTime(s.startsAt)) + start := strfmt.DateTime(opts.expandTime(s.startsAt)) + nsil.StartsAt = &start } if s.endsAt > 0 { - nsil.EndsAt = strfmt.DateTime(opts.expandTime(s.endsAt)) + end := strfmt.DateTime(opts.expandTime(s.endsAt)) + nsil.EndsAt = &end } - nsil.Comment = "some comment" - nsil.CreatedBy = "admin@example.com" + comment := "some comment" + createdBy := "admin@example.com" + nsil.Comment = &comment + nsil.CreatedBy = &createdBy return nsil } @@ -161,7 +166,7 @@ func Alert(keyval ...interface{}) *TestAlert { } // nativeAlert converts the declared test alert into a full alert based -// on the given paramters. +// on the given parameters. func (a *TestAlert) nativeAlert(opts *AcceptanceOpts) *models.Alert { na := &models.Alert{ Labels: a.labels, @@ -169,7 +174,8 @@ func (a *TestAlert) nativeAlert(opts *AcceptanceOpts) *models.Alert { } if a.startsAt > 0 { - na.StartsAt = strfmt.DateTime(opts.expandTime(a.startsAt)) + start := strfmt.DateTime(opts.expandTime(a.startsAt)) + na.StartsAt = start } if a.endsAt > 0 { na.EndsAt = strfmt.DateTime(opts.expandTime(a.endsAt)) @@ -301,10 +307,12 @@ func (ws *MockWebhook) ServeHTTP(w http.ResponseWriter, req *http.Request) { annotations[k] = v } + start := strfmt.DateTime(a.StartsAt) + alerts = append(alerts, &models.Alert{ Labels: labels, Annotations: annotations, - StartsAt: strfmt.DateTime(a.StartsAt), + StartsAt: start, EndsAt: strfmt.DateTime(a.EndsAt), GeneratorURL: strfmt.URI(a.GeneratorURL), }) diff --git a/ui/app/Makefile b/ui/app/Makefile index 56d9dff9ef..98e4a14c7e 100644 --- a/ui/app/Makefile +++ b/ui/app/Makefile @@ -1,16 +1,19 @@ -ELM_FILES := $(shell find src -iname *.elm) +# Use `=` instead of `:=` expanding variable lazely, not at beginning. Needed as +# elm files change during execution. +ELM_FILES = $(shell find src -iname *.elm) DOCKER_IMG := elm-env DOCKER_CMD := docker run --rm -t -v $(PWD):/app -w /app $(DOCKER_IMG) # macOS requires mktemp template to be at the end of the filename. TEMPFILE := $(shell mktemp ./elm-XXXXXXXXXX) # --output flag for elm make must end in .js or .html. TEMPFILE_JS := "$(TEMPFILE).js" +TEMPOPENAPI := $(shell mktemp -d ./openapi-XXXXXXXXXX) ifeq ($(NO_DOCKER), true) DOCKER_CMD= endif -all: test script.js +all: script.js test elm-env: @(if [ "$(NO_DOCKER)" != "true" ] ; then \ @@ -22,7 +25,7 @@ format: elm-env $(ELM_FILES) @echo ">> format front-end code" @$(DOCKER_CMD) elm-format --yes $(ELM_FILES) -test: elm-env +test: src/Data elm-env @$(DOCKER_CMD) rm -rf elm-stuff/generated-code @$(DOCKER_CMD) elm-format $(ELM_FILES) --validate @$(DOCKER_CMD) elm-test @@ -30,7 +33,7 @@ test: elm-env dev-server: elm reactor -script.js: elm-env format $(ELM_FILES) +script.js: src/Data elm-env format $(ELM_FILES) @echo ">> building script.js" @$(DOCKER_CMD) rm -rf elm-stuff @$(DOCKER_CMD) elm make src/Main.elm --optimize --output $(TEMPFILE_JS) @@ -38,7 +41,28 @@ script.js: elm-env format $(ELM_FILES) @rm -rf $(TEMPFILE_JS) @rm -rf $(TEMPFILE) +src/Data: ../../api/v2/openapi.yaml + -rm -r src/Data + # TODO: Don't use :latest tag. + docker run --user=$(shell id -u $(USER)):$(shell id -g $(USER)) --rm -v ${PWD}/../..:/local openapitools/openapi-generator-cli:latest generate \ + -i /local/api/v2/openapi.yaml\ + -g elm \ + -o /local/ui/app/$(TEMPOPENAPI) + # We only want data directory & DateTime package. + cp -r $(TEMPOPENAPI)/src/Data src/Data + cp -r $(TEMPOPENAPI)/src/DateTime.elm src/DateTime.elm + # openapi-generator still generates LabelSet, will be resolved with + # https://github.com/OpenAPITools/openapi-generator/issues/1140#issuecomment-432796436 + rm src/Data/LabelSet.elm + # openapi-generator tries to expose Silence as a union type (`Silence(..)`) + git checkout src/Data/Silence.elm + rm -rf $(TEMPOPENAPI) + + clean: - @rm script.js - @rm -rf elm-stuff + - @rm -rf src/Data + - @rm -f src/DateTime.elm - @docker rmi $(DOCKER_IMG) + - rm -r openapi-* diff --git a/ui/app/elm.json b/ui/app/elm.json index 77031fb370..6a6fc20ad6 100644 --- a/ui/app/elm.json +++ b/ui/app/elm.json @@ -15,7 +15,8 @@ "elm/regex": "1.0.0", "elm/time": "1.0.0", "elm/url": "1.0.0", - "rtfeldman/elm-iso8601-date-strings": "1.1.2" + "rtfeldman/elm-iso8601-date-strings": "1.1.2", + "NoRedInk/elm-json-decode-pipeline": "1.0.0" }, "indirect": { "elm/virtual-dom": "1.0.0", diff --git a/ui/app/src/Alerts/Api.elm b/ui/app/src/Alerts/Api.elm index 08ef732c38..b0a0eab011 100644 --- a/ui/app/src/Alerts/Api.elm +++ b/ui/app/src/Alerts/Api.elm @@ -18,19 +18,19 @@ escapeRegExp text = fetchReceivers : String -> Cmd (ApiData (List Receiver)) -fetchReceivers apiUrl = +fetchReceivers basePath = Utils.Api.send (Utils.Api.get - (apiUrl ++ "/receivers") + (makeApiUrl basePath ++ "/receivers") (field "data" (list (Json.map (\receiver -> Receiver receiver (escapeRegExp receiver)) string))) ) fetchAlerts : String -> Filter -> Cmd (ApiData (List Alert)) -fetchAlerts apiUrl filter = +fetchAlerts basePath filter = let url = - String.join "/" [ apiUrl, "alerts" ++ generateQueryString filter ] + String.join "/" [ makeApiUrl basePath, "alerts" ++ generateQueryString filter ] in Utils.Api.send (Utils.Api.get url alertsDecoder) @@ -58,3 +58,17 @@ alertDecoder = ) (field "startsAt" iso8601Time) (field "generatorURL" Json.string) + + +makeApiUrl : String -> String +makeApiUrl externalUrl = + let + url = + if String.endsWith "/" externalUrl then + String.dropRight 1 externalUrl + + else + externalUrl + in + -- For now alerts are still fetched from the v1 API. + url ++ "/api/v1" diff --git a/ui/app/src/Data/Alert.elm b/ui/app/src/Data/Alert.elm new file mode 100644 index 0000000000..5bf450dcf8 --- /dev/null +++ b/ui/app/src/Data/Alert.elm @@ -0,0 +1,63 @@ +{- + Alertmanager API + API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) + + OpenAPI spec version: 0.0.1 + + NOTE: This file is auto generated by the openapi-generator. + https://github.com/openapitools/openapi-generator.git + Do not edit this file manually. +-} + + +module Data.Alert exposing (Alert, decoder, encoder) + +import Data.AlertStatus as AlertStatus exposing (AlertStatus) +import Data.Receiver as Receiver exposing (Receiver) +import DateTime exposing (DateTime) +import Dict exposing (Dict) +import Json.Decode as Decode exposing (Decoder) +import Json.Decode.Pipeline exposing (optional, required) +import Json.Encode as Encode + + +type alias Alert = + { startsAt : Maybe DateTime + , updatedAt : Maybe DateTime + , endsAt : Maybe DateTime + , generatorURL : Maybe String + , labels : Dict String String + , annotations : Maybe (Dict String String) + , receivers : Maybe (List Receiver) + , fingerprint : Maybe String + , status : Maybe AlertStatus + } + + +decoder : Decoder Alert +decoder = + Decode.succeed Alert + |> optional "startsAt" (Decode.nullable DateTime.decoder) Nothing + |> optional "updatedAt" (Decode.nullable DateTime.decoder) Nothing + |> optional "endsAt" (Decode.nullable DateTime.decoder) Nothing + |> optional "generatorURL" (Decode.nullable Decode.string) Nothing + |> required "labels" (Decode.dict Decode.string) + |> optional "annotations" (Decode.nullable (Decode.dict Decode.string)) Nothing + |> optional "receivers" (Decode.nullable (Decode.list Receiver.decoder)) Nothing + |> optional "fingerprint" (Decode.nullable Decode.string) Nothing + |> optional "status" (Decode.nullable AlertStatus.decoder) Nothing + + +encoder : Alert -> Encode.Value +encoder model = + Encode.object + [ ( "startsAt", Maybe.withDefault Encode.null (Maybe.map DateTime.encoder model.startsAt) ) + , ( "updatedAt", Maybe.withDefault Encode.null (Maybe.map DateTime.encoder model.updatedAt) ) + , ( "endsAt", Maybe.withDefault Encode.null (Maybe.map DateTime.encoder model.endsAt) ) + , ( "generatorURL", Maybe.withDefault Encode.null (Maybe.map Encode.string model.generatorURL) ) + , ( "labels", Encode.dict identity Encode.string model.labels ) + , ( "annotations", Maybe.withDefault Encode.null (Maybe.map (Encode.dict identity Encode.string) model.annotations) ) + , ( "receivers", Maybe.withDefault Encode.null (Maybe.map (Encode.list Receiver.encoder) model.receivers) ) + , ( "fingerprint", Maybe.withDefault Encode.null (Maybe.map Encode.string model.fingerprint) ) + , ( "status", Maybe.withDefault Encode.null (Maybe.map AlertStatus.encoder model.status) ) + ] diff --git a/ui/app/src/Data/AlertStatus.elm b/ui/app/src/Data/AlertStatus.elm new file mode 100644 index 0000000000..f70a123eff --- /dev/null +++ b/ui/app/src/Data/AlertStatus.elm @@ -0,0 +1,81 @@ +{- + Alertmanager API + API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) + + OpenAPI spec version: 0.0.1 + + NOTE: This file is auto generated by the openapi-generator. + https://github.com/openapitools/openapi-generator.git + Do not edit this file manually. +-} + + +module Data.AlertStatus exposing (AlertStatus, State(..), decoder, encoder) + +import Dict exposing (Dict) +import Json.Decode as Decode exposing (Decoder) +import Json.Decode.Pipeline exposing (optional, required) +import Json.Encode as Encode + + +type alias AlertStatus = + { state : State + , silencedBy : List String + , inhibitedBy : List String + } + + +type State + = Unprocessed + | Active + | Suppressed + + +decoder : Decoder AlertStatus +decoder = + Decode.succeed AlertStatus + |> required "state" stateDecoder + |> required "silencedBy" (Decode.list Decode.string) + |> required "inhibitedBy" (Decode.list Decode.string) + + +encoder : AlertStatus -> Encode.Value +encoder model = + Encode.object + [ ( "state", stateEncoder model.state ) + , ( "silencedBy", Encode.list Encode.string model.silencedBy ) + , ( "inhibitedBy", Encode.list Encode.string model.inhibitedBy ) + ] + + +stateDecoder : Decoder State +stateDecoder = + Decode.string + |> Decode.andThen + (\str -> + case str of + "unprocessed" -> + Decode.succeed Unprocessed + + "active" -> + Decode.succeed Active + + "suppressed" -> + Decode.succeed Suppressed + + other -> + Decode.fail <| "Unknown type: " ++ other + ) + + +stateEncoder : State -> Encode.Value +stateEncoder model = + case model of + Unprocessed -> + Encode.string "unprocessed" + + Active -> + Encode.string "active" + + Suppressed -> + Encode.string "suppressed" diff --git a/ui/app/src/Data/AlertmanagerConfig.elm b/ui/app/src/Data/AlertmanagerConfig.elm new file mode 100644 index 0000000000..c3a939b934 --- /dev/null +++ b/ui/app/src/Data/AlertmanagerConfig.elm @@ -0,0 +1,36 @@ +{- + Alertmanager API + API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) + + OpenAPI spec version: 0.0.1 + + NOTE: This file is auto generated by the openapi-generator. + https://github.com/openapitools/openapi-generator.git + Do not edit this file manually. +-} + + +module Data.AlertmanagerConfig exposing (AlertmanagerConfig, decoder, encoder) + +import Dict exposing (Dict) +import Json.Decode as Decode exposing (Decoder) +import Json.Decode.Pipeline exposing (optional, required) +import Json.Encode as Encode + + +type alias AlertmanagerConfig = + { original : String + } + + +decoder : Decoder AlertmanagerConfig +decoder = + Decode.succeed AlertmanagerConfig + |> required "original" Decode.string + + +encoder : AlertmanagerConfig -> Encode.Value +encoder model = + Encode.object + [ ( "original", Encode.string model.original ) + ] diff --git a/ui/app/src/Data/AlertmanagerStatus.elm b/ui/app/src/Data/AlertmanagerStatus.elm new file mode 100644 index 0000000000..16a058d6ee --- /dev/null +++ b/ui/app/src/Data/AlertmanagerStatus.elm @@ -0,0 +1,49 @@ +{- + Alertmanager API + API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) + + OpenAPI spec version: 0.0.1 + + NOTE: This file is auto generated by the openapi-generator. + https://github.com/openapitools/openapi-generator.git + Do not edit this file manually. +-} + + +module Data.AlertmanagerStatus exposing (AlertmanagerStatus, decoder, encoder) + +import Data.AlertmanagerConfig as AlertmanagerConfig exposing (AlertmanagerConfig) +import Data.ClusterStatus as ClusterStatus exposing (ClusterStatus) +import Data.VersionInfo as VersionInfo exposing (VersionInfo) +import DateTime exposing (DateTime) +import Dict exposing (Dict) +import Json.Decode as Decode exposing (Decoder) +import Json.Decode.Pipeline exposing (optional, required) +import Json.Encode as Encode + + +type alias AlertmanagerStatus = + { cluster : ClusterStatus + , versionInfo : VersionInfo + , config : AlertmanagerConfig + , uptime : DateTime + } + + +decoder : Decoder AlertmanagerStatus +decoder = + Decode.succeed AlertmanagerStatus + |> required "cluster" ClusterStatus.decoder + |> required "versionInfo" VersionInfo.decoder + |> required "config" AlertmanagerConfig.decoder + |> required "uptime" DateTime.decoder + + +encoder : AlertmanagerStatus -> Encode.Value +encoder model = + Encode.object + [ ( "cluster", ClusterStatus.encoder model.cluster ) + , ( "versionInfo", VersionInfo.encoder model.versionInfo ) + , ( "config", AlertmanagerConfig.encoder model.config ) + , ( "uptime", DateTime.encoder model.uptime ) + ] diff --git a/ui/app/src/Data/Alerts.elm b/ui/app/src/Data/Alerts.elm new file mode 100644 index 0000000000..8d1d93f3c3 --- /dev/null +++ b/ui/app/src/Data/Alerts.elm @@ -0,0 +1,33 @@ +{- + Alertmanager API + API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) + + OpenAPI spec version: 0.0.1 + + NOTE: This file is auto generated by the openapi-generator. + https://github.com/openapitools/openapi-generator.git + Do not edit this file manually. +-} + + +module Data.Alerts exposing (Alerts, decoder, encoder) + +import Data.Alert as Alert exposing (Alert) +import Dict exposing (Dict) +import Json.Decode as Decode exposing (Decoder) +import Json.Decode.Pipeline exposing (optional, required) +import Json.Encode as Encode + + +type alias Alerts = + List Alert + + +decoder : Decoder Alerts +decoder = + Decode.list Alert.decoder + + +encoder : Alerts -> Encode.Value +encoder items = + Encode.list Alert.encoder items diff --git a/ui/app/src/Data/ClusterStatus.elm b/ui/app/src/Data/ClusterStatus.elm new file mode 100644 index 0000000000..984fc10c86 --- /dev/null +++ b/ui/app/src/Data/ClusterStatus.elm @@ -0,0 +1,43 @@ +{- + Alertmanager API + API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) + + OpenAPI spec version: 0.0.1 + + NOTE: This file is auto generated by the openapi-generator. + https://github.com/openapitools/openapi-generator.git + Do not edit this file manually. +-} + + +module Data.ClusterStatus exposing (ClusterStatus, decoder, encoder) + +import Data.PeerStatus as PeerStatus exposing (PeerStatus) +import Dict exposing (Dict) +import Json.Decode as Decode exposing (Decoder) +import Json.Decode.Pipeline exposing (optional, required) +import Json.Encode as Encode + + +type alias ClusterStatus = + { name : String + , status : String + , peers : List PeerStatus + } + + +decoder : Decoder ClusterStatus +decoder = + Decode.succeed ClusterStatus + |> required "name" Decode.string + |> required "status" Decode.string + |> required "peers" (Decode.list PeerStatus.decoder) + + +encoder : ClusterStatus -> Encode.Value +encoder model = + Encode.object + [ ( "name", Encode.string model.name ) + , ( "status", Encode.string model.status ) + , ( "peers", Encode.list PeerStatus.encoder model.peers ) + ] diff --git a/ui/app/src/Data/GettableSilence.elm b/ui/app/src/Data/GettableSilence.elm new file mode 100644 index 0000000000..98698baee4 --- /dev/null +++ b/ui/app/src/Data/GettableSilence.elm @@ -0,0 +1,60 @@ +{- + Alertmanager API + API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) + + OpenAPI spec version: 0.0.1 + + NOTE: This file is auto generated by the openapi-generator. + https://github.com/openapitools/openapi-generator.git + Do not edit this file manually. +-} + + +module Data.GettableSilence exposing (GettableSilence, decoder, encoder) + +import Data.Matchers as Matchers exposing (Matchers) +import Data.SilenceStatus as SilenceStatus exposing (SilenceStatus) +import DateTime exposing (DateTime) +import Dict exposing (Dict) +import Json.Decode as Decode exposing (Decoder) +import Json.Decode.Pipeline exposing (optional, required) +import Json.Encode as Encode + + +type alias GettableSilence = + { matchers : Matchers + , startsAt : DateTime + , endsAt : DateTime + , createdBy : String + , comment : String + , id : String + , status : SilenceStatus + , updatedAt : DateTime + } + + +decoder : Decoder GettableSilence +decoder = + Decode.succeed GettableSilence + |> required "matchers" Matchers.decoder + |> required "startsAt" DateTime.decoder + |> required "endsAt" DateTime.decoder + |> required "createdBy" Decode.string + |> required "comment" Decode.string + |> required "id" Decode.string + |> required "status" SilenceStatus.decoder + |> required "updatedAt" DateTime.decoder + + +encoder : GettableSilence -> Encode.Value +encoder model = + Encode.object + [ ( "matchers", Matchers.encoder model.matchers ) + , ( "startsAt", DateTime.encoder model.startsAt ) + , ( "endsAt", DateTime.encoder model.endsAt ) + , ( "createdBy", Encode.string model.createdBy ) + , ( "comment", Encode.string model.comment ) + , ( "id", Encode.string model.id ) + , ( "status", SilenceStatus.encoder model.status ) + , ( "updatedAt", DateTime.encoder model.updatedAt ) + ] diff --git a/ui/app/src/Data/GettableSilences.elm b/ui/app/src/Data/GettableSilences.elm new file mode 100644 index 0000000000..f90377c497 --- /dev/null +++ b/ui/app/src/Data/GettableSilences.elm @@ -0,0 +1,33 @@ +{- + Alertmanager API + API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) + + OpenAPI spec version: 0.0.1 + + NOTE: This file is auto generated by the openapi-generator. + https://github.com/openapitools/openapi-generator.git + Do not edit this file manually. +-} + + +module Data.GettableSilences exposing (GettableSilences, decoder, encoder) + +import Data.GettableSilence as GettableSilence exposing (GettableSilence) +import Dict exposing (Dict) +import Json.Decode as Decode exposing (Decoder) +import Json.Decode.Pipeline exposing (optional, required) +import Json.Encode as Encode + + +type alias GettableSilences = + List GettableSilence + + +decoder : Decoder GettableSilences +decoder = + Decode.list GettableSilence.decoder + + +encoder : GettableSilences -> Encode.Value +encoder items = + Encode.list GettableSilence.encoder items diff --git a/ui/app/src/Data/InlineResponse200.elm b/ui/app/src/Data/InlineResponse200.elm new file mode 100644 index 0000000000..3299743d88 --- /dev/null +++ b/ui/app/src/Data/InlineResponse200.elm @@ -0,0 +1,36 @@ +{- + Alertmanager API + API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) + + OpenAPI spec version: 0.0.1 + + NOTE: This file is auto generated by the openapi-generator. + https://github.com/openapitools/openapi-generator.git + Do not edit this file manually. +-} + + +module Data.InlineResponse200 exposing (InlineResponse200, decoder, encoder) + +import Dict exposing (Dict) +import Json.Decode as Decode exposing (Decoder) +import Json.Decode.Pipeline exposing (optional, required) +import Json.Encode as Encode + + +type alias InlineResponse200 = + { silenceID : Maybe String + } + + +decoder : Decoder InlineResponse200 +decoder = + Decode.succeed InlineResponse200 + |> optional "silenceID" (Decode.nullable Decode.string) Nothing + + +encoder : InlineResponse200 -> Encode.Value +encoder model = + Encode.object + [ ( "silenceID", Maybe.withDefault Encode.null (Maybe.map Encode.string model.silenceID) ) + ] diff --git a/ui/app/src/Data/Matcher.elm b/ui/app/src/Data/Matcher.elm new file mode 100644 index 0000000000..8fc72a9aac --- /dev/null +++ b/ui/app/src/Data/Matcher.elm @@ -0,0 +1,42 @@ +{- + Alertmanager API + API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) + + OpenAPI spec version: 0.0.1 + + NOTE: This file is auto generated by the openapi-generator. + https://github.com/openapitools/openapi-generator.git + Do not edit this file manually. +-} + + +module Data.Matcher exposing (Matcher, decoder, encoder) + +import Dict exposing (Dict) +import Json.Decode as Decode exposing (Decoder) +import Json.Decode.Pipeline exposing (optional, required) +import Json.Encode as Encode + + +type alias Matcher = + { name : String + , value : String + , isRegex : Bool + } + + +decoder : Decoder Matcher +decoder = + Decode.succeed Matcher + |> required "name" Decode.string + |> required "value" Decode.string + |> required "isRegex" Decode.bool + + +encoder : Matcher -> Encode.Value +encoder model = + Encode.object + [ ( "name", Encode.string model.name ) + , ( "value", Encode.string model.value ) + , ( "isRegex", Encode.bool model.isRegex ) + ] diff --git a/ui/app/src/Data/Matchers.elm b/ui/app/src/Data/Matchers.elm new file mode 100644 index 0000000000..3498593887 --- /dev/null +++ b/ui/app/src/Data/Matchers.elm @@ -0,0 +1,33 @@ +{- + Alertmanager API + API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) + + OpenAPI spec version: 0.0.1 + + NOTE: This file is auto generated by the openapi-generator. + https://github.com/openapitools/openapi-generator.git + Do not edit this file manually. +-} + + +module Data.Matchers exposing (Matchers, decoder, encoder) + +import Data.Matcher as Matcher exposing (Matcher) +import Dict exposing (Dict) +import Json.Decode as Decode exposing (Decoder) +import Json.Decode.Pipeline exposing (optional, required) +import Json.Encode as Encode + + +type alias Matchers = + List Matcher + + +decoder : Decoder Matchers +decoder = + Decode.list Matcher.decoder + + +encoder : Matchers -> Encode.Value +encoder items = + Encode.list Matcher.encoder items diff --git a/ui/app/src/Data/PeerStatus.elm b/ui/app/src/Data/PeerStatus.elm new file mode 100644 index 0000000000..a5327350ae --- /dev/null +++ b/ui/app/src/Data/PeerStatus.elm @@ -0,0 +1,39 @@ +{- + Alertmanager API + API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) + + OpenAPI spec version: 0.0.1 + + NOTE: This file is auto generated by the openapi-generator. + https://github.com/openapitools/openapi-generator.git + Do not edit this file manually. +-} + + +module Data.PeerStatus exposing (PeerStatus, decoder, encoder) + +import Dict exposing (Dict) +import Json.Decode as Decode exposing (Decoder) +import Json.Decode.Pipeline exposing (optional, required) +import Json.Encode as Encode + + +type alias PeerStatus = + { name : String + , address : String + } + + +decoder : Decoder PeerStatus +decoder = + Decode.succeed PeerStatus + |> required "name" Decode.string + |> required "address" Decode.string + + +encoder : PeerStatus -> Encode.Value +encoder model = + Encode.object + [ ( "name", Encode.string model.name ) + , ( "address", Encode.string model.address ) + ] diff --git a/ui/app/src/Data/PostableSilence.elm b/ui/app/src/Data/PostableSilence.elm new file mode 100644 index 0000000000..0c1d558b23 --- /dev/null +++ b/ui/app/src/Data/PostableSilence.elm @@ -0,0 +1,53 @@ +{- + Alertmanager API + API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) + + OpenAPI spec version: 0.0.1 + + NOTE: This file is auto generated by the openapi-generator. + https://github.com/openapitools/openapi-generator.git + Do not edit this file manually. +-} + + +module Data.PostableSilence exposing (PostableSilence, decoder, encoder) + +import Data.Matchers as Matchers exposing (Matchers) +import DateTime exposing (DateTime) +import Dict exposing (Dict) +import Json.Decode as Decode exposing (Decoder) +import Json.Decode.Pipeline exposing (optional, required) +import Json.Encode as Encode + + +type alias PostableSilence = + { matchers : Matchers + , startsAt : DateTime + , endsAt : DateTime + , createdBy : String + , comment : String + , id : Maybe String + } + + +decoder : Decoder PostableSilence +decoder = + Decode.succeed PostableSilence + |> required "matchers" Matchers.decoder + |> required "startsAt" DateTime.decoder + |> required "endsAt" DateTime.decoder + |> required "createdBy" Decode.string + |> required "comment" Decode.string + |> optional "id" (Decode.nullable Decode.string) Nothing + + +encoder : PostableSilence -> Encode.Value +encoder model = + Encode.object + [ ( "matchers", Matchers.encoder model.matchers ) + , ( "startsAt", DateTime.encoder model.startsAt ) + , ( "endsAt", DateTime.encoder model.endsAt ) + , ( "createdBy", Encode.string model.createdBy ) + , ( "comment", Encode.string model.comment ) + , ( "id", Maybe.withDefault Encode.null (Maybe.map Encode.string model.id) ) + ] diff --git a/ui/app/src/Data/Receiver.elm b/ui/app/src/Data/Receiver.elm new file mode 100644 index 0000000000..3836d5ad0d --- /dev/null +++ b/ui/app/src/Data/Receiver.elm @@ -0,0 +1,36 @@ +{- + Alertmanager API + API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) + + OpenAPI spec version: 0.0.1 + + NOTE: This file is auto generated by the openapi-generator. + https://github.com/openapitools/openapi-generator.git + Do not edit this file manually. +-} + + +module Data.Receiver exposing (Receiver, decoder, encoder) + +import Dict exposing (Dict) +import Json.Decode as Decode exposing (Decoder) +import Json.Decode.Pipeline exposing (optional, required) +import Json.Encode as Encode + + +type alias Receiver = + { name : String + } + + +decoder : Decoder Receiver +decoder = + Decode.succeed Receiver + |> required "name" Decode.string + + +encoder : Receiver -> Encode.Value +encoder model = + Encode.object + [ ( "name", Encode.string model.name ) + ] diff --git a/ui/app/src/Data/Silence.elm b/ui/app/src/Data/Silence.elm new file mode 100644 index 0000000000..8a09ed4e8d --- /dev/null +++ b/ui/app/src/Data/Silence.elm @@ -0,0 +1,50 @@ +{- + Alertmanager API + API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) + + OpenAPI spec version: 0.0.1 + + NOTE: This file is auto generated by the openapi-generator. + https://github.com/openapitools/openapi-generator.git + Do not edit this file manually. +-} + + +module Data.Silence exposing (Silence, decoder, encoder) + +import Data.Matchers as Matchers exposing (Matchers) +import DateTime exposing (DateTime) +import Dict exposing (Dict) +import Json.Decode as Decode exposing (Decoder) +import Json.Decode.Pipeline exposing (optional, required) +import Json.Encode as Encode + + +type alias Silence = + { matchers : Matchers + , startsAt : DateTime + , endsAt : DateTime + , createdBy : String + , comment : String + } + + +decoder : Decoder Silence +decoder = + Decode.succeed Silence + |> required "matchers" Matchers.decoder + |> required "startsAt" DateTime.decoder + |> required "endsAt" DateTime.decoder + |> required "createdBy" Decode.string + |> required "comment" Decode.string + + +encoder : Silence -> Encode.Value +encoder model = + Encode.object + [ ( "matchers", Matchers.encoder model.matchers ) + , ( "startsAt", DateTime.encoder model.startsAt ) + , ( "endsAt", DateTime.encoder model.endsAt ) + , ( "createdBy", Encode.string model.createdBy ) + , ( "comment", Encode.string model.comment ) + ] diff --git a/ui/app/src/Data/SilenceStatus.elm b/ui/app/src/Data/SilenceStatus.elm new file mode 100644 index 0000000000..63ecff18b5 --- /dev/null +++ b/ui/app/src/Data/SilenceStatus.elm @@ -0,0 +1,75 @@ +{- + Alertmanager API + API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) + + OpenAPI spec version: 0.0.1 + + NOTE: This file is auto generated by the openapi-generator. + https://github.com/openapitools/openapi-generator.git + Do not edit this file manually. +-} + + +module Data.SilenceStatus exposing (SilenceStatus, State(..), decoder, encoder) + +import Dict exposing (Dict) +import Json.Decode as Decode exposing (Decoder) +import Json.Decode.Pipeline exposing (optional, required) +import Json.Encode as Encode + + +type alias SilenceStatus = + { state : State + } + + +type State + = Expired + | Active + | Pending + + +decoder : Decoder SilenceStatus +decoder = + Decode.succeed SilenceStatus + |> required "state" stateDecoder + + +encoder : SilenceStatus -> Encode.Value +encoder model = + Encode.object + [ ( "state", stateEncoder model.state ) + ] + + +stateDecoder : Decoder State +stateDecoder = + Decode.string + |> Decode.andThen + (\str -> + case str of + "expired" -> + Decode.succeed Expired + + "active" -> + Decode.succeed Active + + "pending" -> + Decode.succeed Pending + + other -> + Decode.fail <| "Unknown type: " ++ other + ) + + +stateEncoder : State -> Encode.Value +stateEncoder model = + case model of + Expired -> + Encode.string "expired" + + Active -> + Encode.string "active" + + Pending -> + Encode.string "pending" diff --git a/ui/app/src/Data/VersionInfo.elm b/ui/app/src/Data/VersionInfo.elm new file mode 100644 index 0000000000..68f4e20b8a --- /dev/null +++ b/ui/app/src/Data/VersionInfo.elm @@ -0,0 +1,51 @@ +{- + Alertmanager API + API of the Prometheus Alertmanager (https://github.com/prometheus/alertmanager) + + OpenAPI spec version: 0.0.1 + + NOTE: This file is auto generated by the openapi-generator. + https://github.com/openapitools/openapi-generator.git + Do not edit this file manually. +-} + + +module Data.VersionInfo exposing (VersionInfo, decoder, encoder) + +import Dict exposing (Dict) +import Json.Decode as Decode exposing (Decoder) +import Json.Decode.Pipeline exposing (optional, required) +import Json.Encode as Encode + + +type alias VersionInfo = + { version : String + , revision : String + , branch : String + , buildUser : String + , buildDate : String + , goVersion : String + } + + +decoder : Decoder VersionInfo +decoder = + Decode.succeed VersionInfo + |> required "version" Decode.string + |> required "revision" Decode.string + |> required "branch" Decode.string + |> required "buildUser" Decode.string + |> required "buildDate" Decode.string + |> required "goVersion" Decode.string + + +encoder : VersionInfo -> Encode.Value +encoder model = + Encode.object + [ ( "version", Encode.string model.version ) + , ( "revision", Encode.string model.revision ) + , ( "branch", Encode.string model.branch ) + , ( "buildUser", Encode.string model.buildUser ) + , ( "buildDate", Encode.string model.buildDate ) + , ( "goVersion", Encode.string model.goVersion ) + ] diff --git a/ui/app/src/DateTime.elm b/ui/app/src/DateTime.elm new file mode 100644 index 0000000000..a560b4588b --- /dev/null +++ b/ui/app/src/DateTime.elm @@ -0,0 +1,37 @@ +module DateTime exposing (DateTime, decoder, encoder, toString) + +import Iso8601 +import Json.Decode as Decode exposing (Decoder) +import Json.Encode as Encode +import Result +import Time + + +type alias DateTime = + Time.Posix + + +decoder : Decoder DateTime +decoder = + Decode.string + |> Decode.andThen decodeIsoString + + +encoder : DateTime -> Encode.Value +encoder = + Encode.string << toString + + +decodeIsoString : String -> Decoder DateTime +decodeIsoString str = + case Iso8601.toTime str of + Result.Ok posix -> + Decode.succeed posix + + Result.Err _ -> + Decode.fail <| "Invalid date: " ++ str + + +toString : DateTime -> String +toString = + Iso8601.fromTime diff --git a/ui/app/src/Silences/Api.elm b/ui/app/src/Silences/Api.elm index 120fa09f7d..50979b017b 100644 --- a/ui/app/src/Silences/Api.elm +++ b/ui/app/src/Silences/Api.elm @@ -1,42 +1,43 @@ module Silences.Api exposing (create, destroy, getSilence, getSilences) +import Data.GettableSilence exposing (GettableSilence) +import Data.GettableSilences +import Data.PostableSilence exposing (PostableSilence) import Http -import Silences.Decoders exposing (create, destroy, list, show) -import Silences.Encoders -import Silences.Types exposing (Silence) +import Silences.Decoders import Utils.Api import Utils.Filter exposing (Filter, generateQueryString) import Utils.Types exposing (ApiData(..)) -getSilences : String -> Filter -> (ApiData (List Silence) -> msg) -> Cmd msg +getSilences : String -> Filter -> (ApiData (List GettableSilence) -> msg) -> Cmd msg getSilences apiUrl filter msg = let url = String.join "/" [ apiUrl, "silences" ++ generateQueryString filter ] in - Utils.Api.send (Utils.Api.get url list) + Utils.Api.send (Utils.Api.get url Data.GettableSilences.decoder) |> Cmd.map msg -getSilence : String -> String -> (ApiData Silence -> msg) -> Cmd msg +getSilence : String -> String -> (ApiData GettableSilence -> msg) -> Cmd msg getSilence apiUrl uuid msg = let url = String.join "/" [ apiUrl, "silence", uuid ] in - Utils.Api.send (Utils.Api.get url show) + Utils.Api.send (Utils.Api.get url Data.GettableSilence.decoder) |> Cmd.map msg -create : String -> Silence -> Cmd (ApiData String) +create : String -> PostableSilence -> Cmd (ApiData String) create apiUrl silence = let url = String.join "/" [ apiUrl, "silences" ] body = - Http.jsonBody <| Silences.Encoders.silence silence + Http.jsonBody <| Data.PostableSilence.encoder silence in -- TODO: This should return the silence, not just the ID, so that we can -- redirect to the silence show page. @@ -44,7 +45,7 @@ create apiUrl silence = (Utils.Api.post url body Silences.Decoders.create) -destroy : String -> Silence -> (ApiData String -> msg) -> Cmd msg +destroy : String -> GettableSilence -> (ApiData String -> msg) -> Cmd msg destroy apiUrl silence msg = -- The incorrect route using "silences" receives a 405. The route seems to -- be matching on /silences and ignoring the :sid, should be getting a 404. diff --git a/ui/app/src/Silences/Decoders.elm b/ui/app/src/Silences/Decoders.elm index 6399be5a8d..dc89485b40 100644 --- a/ui/app/src/Silences/Decoders.elm +++ b/ui/app/src/Silences/Decoders.elm @@ -1,77 +1,15 @@ -module Silences.Decoders exposing (create, destroy, list, show) +module Silences.Decoders exposing (create, destroy) import Json.Decode as Json exposing (fail, field, succeed) -import Silences.Types exposing (Silence, State(..), Status) import Utils.Api exposing (andMap, iso8601Time) import Utils.Types exposing (ApiData(..), Matcher, Time) -show : Json.Decoder Silence -show = - Json.at [ "data" ] silenceDecoder - - -list : Json.Decoder (List Silence) -list = - Json.at [ "data" ] (Json.list silenceDecoder) - - create : Json.Decoder String create = - Json.at [ "data", "silenceId" ] Json.string + Json.at [ "silenceID" ] Json.string destroy : Json.Decoder String destroy = Json.at [ "status" ] Json.string - - -silenceDecoder : Json.Decoder Silence -silenceDecoder = - Json.succeed Silence - |> andMap (field "id" Json.string) - |> andMap (field "createdBy" Json.string) - -- Remove this maybe once the api either disallows empty comments on - -- creation, or returns an empty string. - |> andMap - (Json.maybe (field "comment" Json.string) - |> Json.andThen (\x -> Json.succeed <| Maybe.withDefault "" x) - ) - |> andMap (field "startsAt" iso8601Time) - |> andMap (field "endsAt" iso8601Time) - |> andMap (field "updatedAt" iso8601Time) - |> andMap (field "matchers" (Json.list matcherDecoder)) - |> andMap (field "status" statusDecoder) - - -statusDecoder : Json.Decoder Status -statusDecoder = - Json.succeed Status - |> andMap (field "state" Json.string |> Json.andThen stateDecoder) - - -stateDecoder : String -> Json.Decoder State -stateDecoder state = - case state of - "active" -> - succeed Active - - "pending" -> - succeed Pending - - "expired" -> - succeed Expired - - _ -> - fail <| - "Silence.status.state must be one of 'active', 'pending' or 'expired' but was'" - ++ state - ++ "'." - - -matcherDecoder : Json.Decoder Matcher -matcherDecoder = - Json.map3 Matcher - (field "isRegex" Json.bool) - (field "name" Json.string) - (field "value" Json.string) diff --git a/ui/app/src/Silences/Encoders.elm b/ui/app/src/Silences/Encoders.elm deleted file mode 100644 index 98b04e5c87..0000000000 --- a/ui/app/src/Silences/Encoders.elm +++ /dev/null @@ -1,27 +0,0 @@ -module Silences.Encoders exposing (matcher, silence) - -import Json.Encode as Encode -import Silences.Types exposing (Silence) -import Utils.Date -import Utils.Types exposing (Matcher) - - -silence : Silence -> Encode.Value -silence silence_ = - Encode.object - [ ( "id", Encode.string silence_.id ) - , ( "createdBy", Encode.string silence_.createdBy ) - , ( "comment", Encode.string silence_.comment ) - , ( "startsAt", Encode.string (Utils.Date.encode silence_.startsAt) ) - , ( "endsAt", Encode.string (Utils.Date.encode silence_.endsAt) ) - , ( "matchers", Encode.list matcher silence_.matchers ) - ] - - -matcher : Matcher -> Encode.Value -matcher m = - Encode.object - [ ( "name", Encode.string m.name ) - , ( "value", Encode.string m.value ) - , ( "isRegex", Encode.bool m.isRegex ) - ] diff --git a/ui/app/src/Silences/Types.elm b/ui/app/src/Silences/Types.elm index 1cbc1df73b..aa7ed4a64d 100644 --- a/ui/app/src/Silences/Types.elm +++ b/ui/app/src/Silences/Types.elm @@ -1,63 +1,42 @@ module Silences.Types exposing - ( Silence - , SilenceId - , State(..) - , Status - , nullMatcher + ( nullMatcher , nullSilence , nullSilenceStatus , stateToString ) +import Data.Matcher exposing (Matcher) +import Data.Matchers exposing (Matchers) +import Data.PostableSilence exposing (PostableSilence) +import Data.SilenceStatus exposing (SilenceStatus, State(..)) import Time exposing (Posix) -import Utils.Types exposing (Matcher) -nullSilence : Silence +nullSilence : PostableSilence nullSilence = - { id = "" + { id = Nothing , createdBy = "" , comment = "" , startsAt = Time.millisToPosix 0 , endsAt = Time.millisToPosix 0 - , updatedAt = Time.millisToPosix 0 - , matchers = [ nullMatcher ] - , status = nullSilenceStatus + , matchers = nullMatchers } -nullSilenceStatus : Status +nullSilenceStatus : SilenceStatus nullSilenceStatus = { state = Expired } -nullMatcher : Matcher -nullMatcher = - Matcher False "" "" - - -type alias Silence = - { id : SilenceId - , createdBy : String - , comment : String - , startsAt : Posix - , endsAt : Posix - , updatedAt : Posix - , matchers : List Matcher - , status : Status - } - - -type alias Status = - { state : State - } +nullMatchers : Matchers +nullMatchers = + [ nullMatcher ] -type State - = Active - | Pending - | Expired +nullMatcher : Matcher +nullMatcher = + Matcher "" "" False stateToString : State -> String @@ -71,7 +50,3 @@ stateToString state = Expired -> "expired" - - -type alias SilenceId = - String diff --git a/ui/app/src/Status/Api.elm b/ui/app/src/Status/Api.elm index 0708c5fd75..6155828e6e 100644 --- a/ui/app/src/Status/Api.elm +++ b/ui/app/src/Status/Api.elm @@ -1,19 +1,20 @@ module Status.Api exposing (getStatus) +import Data.AlertmanagerStatus exposing (AlertmanagerStatus) import Json.Decode exposing (Decoder, at, bool, field, int, list, map2, maybe, string) import Status.Types exposing (ClusterPeer, ClusterStatus, StatusResponse, VersionInfo) import Utils.Api exposing (get, send) import Utils.Types exposing (ApiData) -getStatus : String -> (ApiData StatusResponse -> msg) -> Cmd msg +getStatus : String -> (ApiData AlertmanagerStatus -> msg) -> Cmd msg getStatus apiUrl msg = let url = String.join "/" [ apiUrl, "status" ] request = - get url decodeStatusResponse + get url Data.AlertmanagerStatus.decoder in Cmd.map msg <| send request diff --git a/ui/app/src/Updates.elm b/ui/app/src/Updates.elm index dda962e8f6..608856c01d 100644 --- a/ui/app/src/Updates.elm +++ b/ui/app/src/Updates.elm @@ -41,7 +41,7 @@ update msg ({ basePath, apiUrl } as model) = NavigateToSilenceView silenceId -> let ( silenceView, cmd ) = - Views.SilenceView.Updates.update (SilenceViewTypes.InitSilenceView silenceId) model.silenceView apiUrl + Views.SilenceView.Updates.update (SilenceViewTypes.InitSilenceView silenceId) model.silenceView basePath apiUrl in ( { model | route = SilenceViewRoute silenceId, silenceView = silenceView } , Cmd.map MsgForSilenceView cmd @@ -104,7 +104,7 @@ update msg ({ basePath, apiUrl } as model) = MsgForSilenceView subMsg -> let ( silenceView, cmd ) = - Views.SilenceView.Updates.update subMsg model.silenceView apiUrl + Views.SilenceView.Updates.update subMsg model.silenceView basePath apiUrl in ( { model | silenceView = silenceView }, Cmd.map MsgForSilenceView cmd ) diff --git a/ui/app/src/Utils/Api.elm b/ui/app/src/Utils/Api.elm index 1acfb89652..be6fb9396d 100644 --- a/ui/app/src/Utils/Api.elm +++ b/ui/app/src/Utils/Api.elm @@ -126,7 +126,7 @@ makeApiUrl externalUrl = else externalUrl in - url ++ "/api/v1" + url ++ "/api/v2" andMap : Json.Decoder a -> Json.Decoder (a -> b) -> Json.Decoder b diff --git a/ui/app/src/Utils/List.elm b/ui/app/src/Utils/List.elm index 4c45bfcab4..b3e4d52700 100644 --- a/ui/app/src/Utils/List.elm +++ b/ui/app/src/Utils/List.elm @@ -1,7 +1,8 @@ module Utils.List exposing (groupBy, lastElem, mjoin, mstring, nextElem, replaceIf, replaceIndex, zip) +import Data.Matcher exposing (Matcher) +import Data.Matchers exposing (Matchers) import Dict exposing (Dict) -import Utils.Types exposing (Matcher, Matchers) nextElem : a -> List a -> Maybe a diff --git a/ui/app/src/Views/AlertList/AlertView.elm b/ui/app/src/Views/AlertList/AlertView.elm index 1b08e652f8..173a55c33f 100644 --- a/ui/app/src/Views/AlertList/AlertView.elm +++ b/ui/app/src/Views/AlertList/AlertView.elm @@ -1,6 +1,7 @@ module Views.AlertList.AlertView exposing (addLabelMsg, view) import Alerts.Types exposing (Alert) +import Dict import Html exposing (..) import Html.Attributes exposing (class, href, readonly, style, title, value) import Html.Events exposing (onClick) @@ -105,7 +106,7 @@ silenceButton alert = Nothing -> a [ class "btn btn-outline-info border-0" - , href (newSilenceFromAlertLabels alert.labels) + , href (newSilenceFromAlertLabels <| Dict.fromList alert.labels) ] [ i [ class "fa fa-bell-slash-o mr-2" ] [] , text "Silence" diff --git a/ui/app/src/Views/AlertList/Updates.elm b/ui/app/src/Views/AlertList/Updates.elm index c5e4a4d7ea..5872ff3279 100644 --- a/ui/app/src/Views/AlertList/Updates.elm +++ b/ui/app/src/Views/AlertList/Updates.elm @@ -48,8 +48,8 @@ update msg ({ groupBar, filterBar, receiverBar } as model) filter apiUrl basePat in ( { model | alerts = Loading, filterBar = newFilterBar, groupBar = newGroupBar, activeId = Nothing } , Cmd.batch - [ Api.fetchAlerts apiUrl filter |> Cmd.map (AlertsFetched >> MsgForAlertList) - , ReceiverBar.fetchReceivers apiUrl |> Cmd.map (MsgForReceiverBar >> MsgForAlertList) + [ Api.fetchAlerts basePath filter |> Cmd.map (AlertsFetched >> MsgForAlertList) + , ReceiverBar.fetchReceivers basePath |> Cmd.map (MsgForReceiverBar >> MsgForAlertList) ] ) diff --git a/ui/app/src/Views/SilenceForm/Parsing.elm b/ui/app/src/Views/SilenceForm/Parsing.elm index 4443659026..5c71b0da49 100644 --- a/ui/app/src/Views/SilenceForm/Parsing.elm +++ b/ui/app/src/Views/SilenceForm/Parsing.elm @@ -1,14 +1,16 @@ module Views.SilenceForm.Parsing exposing (newSilenceFromAlertLabels, silenceFormEditParser, silenceFormNewParser) +import Dict exposing (Dict) import Url exposing (percentEncode) import Url.Parser exposing ((), (), Parser, map, oneOf, s, string) import Url.Parser.Query as Query import Utils.Filter exposing (Matcher, parseFilter) -newSilenceFromAlertLabels : List ( String, String ) -> String +newSilenceFromAlertLabels : Dict String String -> String newSilenceFromAlertLabels labels = labels + |> Dict.toList |> List.map (\( k, v ) -> Utils.Filter.Matcher k Utils.Filter.Eq v) |> Utils.Filter.stringifyFilter |> percentEncode diff --git a/ui/app/src/Views/SilenceForm/Types.elm b/ui/app/src/Views/SilenceForm/Types.elm index f4fd1d616a..dcd770c062 100644 --- a/ui/app/src/Views/SilenceForm/Types.elm +++ b/ui/app/src/Views/SilenceForm/Types.elm @@ -15,7 +15,10 @@ module Views.SilenceForm.Types exposing import Alerts.Types exposing (Alert) import Browser.Navigation exposing (Key) -import Silences.Types exposing (Silence, SilenceId, nullSilence) +import Data.GettableSilence exposing (GettableSilence) +import Data.Matcher exposing (Matcher) +import Data.PostableSilence exposing (PostableSilence) +import Silences.Types exposing (nullSilence) import Time exposing (Posix) import Utils.Date exposing (addDuration, durationFormat, parseDuration, timeDifference, timeFromString, timeToString) import Utils.Filter @@ -27,7 +30,7 @@ import Utils.FormValidation , stringNotEmpty , validate ) -import Utils.Types exposing (ApiData(..), Duration, Matcher) +import Utils.Types exposing (ApiData(..), Duration) type alias Model = @@ -40,7 +43,7 @@ type alias Model = type alias SilenceForm = - { id : String + { id : Maybe String , createdBy : ValidatedField , comment : ValidatedField , startsAt : ValidatedField @@ -66,8 +69,8 @@ type SilenceFormMsg | FetchSilence String | NewSilenceFromMatchers String (List Utils.Filter.Matcher) | NewSilenceFromMatchersAndTime String (List Utils.Filter.Matcher) Posix - | SilenceFetch (ApiData Silence) - | SilenceCreate (ApiData SilenceId) + | SilenceFetch (ApiData GettableSilence) + | SilenceCreate (ApiData String) type SilenceFormFieldMsg @@ -98,7 +101,7 @@ initSilenceForm key = } -toSilence : SilenceForm -> Maybe Silence +toSilence : SilenceForm -> Maybe PostableSilence toSilence { id, comment, matchers, createdBy, startsAt, endsAt } = Result.map5 (\nonEmptyComment validMatchers nonEmptyCreatedBy parsedStartsAt parsedEndsAt -> @@ -119,9 +122,9 @@ toSilence { id, comment, matchers, createdBy, startsAt, endsAt } = |> Result.toMaybe -fromSilence : Silence -> SilenceForm +fromSilence : GettableSilence -> SilenceForm fromSilence { id, createdBy, comment, startsAt, endsAt, matchers } = - { id = id + { id = Just id , createdBy = initialField createdBy , comment = initialField comment , startsAt = initialField (timeToString startsAt) @@ -167,7 +170,7 @@ validateMatcherForm { name, value, isRegex } = empty : SilenceForm empty = - { id = "" + { id = Nothing , createdBy = initialField "" , comment = initialField "" , startsAt = initialField "" @@ -211,12 +214,12 @@ fromMatchersAndTime defaultCreator matchers now = appendMatcher : MatcherForm -> Result String (List Matcher) -> Result String (List Matcher) appendMatcher { isRegex, name, value } = Result.map2 (::) - (Result.map2 (Matcher isRegex) (stringNotEmpty name.value) (Ok value.value)) + (Result.map2 (\k v -> Matcher k v isRegex) (stringNotEmpty name.value) (Ok value.value)) filterMatcherToMatcher : Utils.Filter.Matcher -> Maybe Matcher filterMatcherToMatcher { key, op, value } = - Maybe.map (\operator -> Matcher operator key value) <| + Maybe.map (\operator -> Matcher key value operator) <| case op of Utils.Filter.Eq -> Just False diff --git a/ui/app/src/Views/SilenceForm/Updates.elm b/ui/app/src/Views/SilenceForm/Updates.elm index 89685f8c7c..a39f92fbd5 100644 --- a/ui/app/src/Views/SilenceForm/Updates.elm +++ b/ui/app/src/Views/SilenceForm/Updates.elm @@ -236,7 +236,7 @@ update msg model basePath apiUrl = Just silence -> ( { model | alerts = Loading } , Alerts.Api.fetchAlerts - apiUrl + basePath { nullFilter | text = Just (Utils.List.mjoin silence.matchers) } |> Cmd.map (AlertGroupsPreview >> MsgForSilenceForm) ) diff --git a/ui/app/src/Views/SilenceForm/Views.elm b/ui/app/src/Views/SilenceForm/Views.elm index b33dadff72..53814517be 100644 --- a/ui/app/src/Views/SilenceForm/Views.elm +++ b/ui/app/src/Views/SilenceForm/Views.elm @@ -1,10 +1,10 @@ module Views.SilenceForm.Views exposing (view) import Alerts.Types exposing (Alert) +import Data.Silence exposing (Silence) import Html exposing (Html, a, button, div, fieldset, h1, input, label, legend, span, strong, text, textarea) import Html.Attributes exposing (class, href) import Html.Events exposing (onClick) -import Silences.Types exposing (Silence, SilenceId) import Utils.Filter import Utils.FormValidation exposing (ValidatedField, ValidationState(..)) import Utils.Types exposing (ApiData) @@ -14,7 +14,7 @@ import Views.Shared.Types exposing (Msg) import Views.SilenceForm.Types exposing (MatcherForm, Model, SilenceForm, SilenceFormFieldMsg(..), SilenceFormMsg(..)) -view : Maybe SilenceId -> List Utils.Filter.Matcher -> String -> Model -> Html SilenceFormMsg +view : Maybe String -> List Utils.Filter.Matcher -> String -> Model -> Html SilenceFormMsg view maybeId matchers defaultCreator { form, silenceId, alerts, activeAlertId } = let ( title, resetClick ) = @@ -95,7 +95,7 @@ matcherInput matchers = ] -informationBlock : Maybe String -> ApiData SilenceId -> ApiData (List Alert) -> Html SilenceFormMsg +informationBlock : Maybe String -> ApiData String -> ApiData (List Alert) -> Html SilenceFormMsg informationBlock activeAlertId silence alerts = case silence of Utils.Types.Success _ -> diff --git a/ui/app/src/Views/SilenceList/SilenceView.elm b/ui/app/src/Views/SilenceList/SilenceView.elm index 59ac27e28e..27a662e280 100644 --- a/ui/app/src/Views/SilenceList/SilenceView.elm +++ b/ui/app/src/Views/SilenceList/SilenceView.elm @@ -1,15 +1,18 @@ module Views.SilenceList.SilenceView exposing (deleteButton, editButton, view) +import Data.GettableSilence exposing (GettableSilence) +import Data.Matcher exposing (Matcher) +import Data.Matchers exposing (Matchers) +import Data.SilenceStatus exposing (State(..)) +import Dict exposing (Dict) import Html exposing (Html, a, b, button, div, h3, i, li, p, small, span, text) import Html.Attributes exposing (class, href, style) import Html.Events exposing (onClick) -import Silences.Types exposing (Silence, State(..)) import Time exposing (Posix) import Types exposing (Msg(..)) import Utils.Date import Utils.Filter import Utils.List -import Utils.Types exposing (Matcher) import Utils.Views exposing (buttonLink) import Views.FilterBar.Types as FilterBarTypes import Views.Shared.Dialog as Dialog @@ -17,7 +20,7 @@ import Views.SilenceForm.Parsing exposing (newSilenceFromAlertLabels) import Views.SilenceList.Types exposing (SilenceListMsg(..)) -view : Bool -> Silence -> Html Msg +view : Bool -> GettableSilence -> Html Msg view showConfirmationDialog silence = li [ -- speedup rendering in Chrome, because list-group-item className @@ -50,7 +53,7 @@ view showConfirmationDialog silence = ] -confirmSilenceDeleteView : Silence -> Bool -> Dialog.Config Msg +confirmSilenceDeleteView : GettableSilence -> Bool -> Dialog.Config Msg confirmSilenceDeleteView silence refresh = { onClose = MsgForSilenceList Views.SilenceList.Types.FetchSilences , title = "Expire Silence" @@ -95,11 +98,19 @@ matcherButton matcher = Utils.Views.labelButton (Just msg) (Utils.List.mstring matcher) -editButton : Silence -> Html Msg +editButton : GettableSilence -> Html Msg editButton silence = let matchers = List.map (\s -> ( s.name, s.value )) silence.matchers + + editUrl = + String.join "/" [ "#/silences", silence.id, "edit" ] + + default = + a [ class "btn btn-outline-info border-0", href editUrl ] + [ text "Edit" + ] in case silence.status.state of -- If the silence is expired, do not edit it, but instead create a new @@ -107,22 +118,16 @@ editButton silence = Expired -> a [ class "btn btn-outline-info border-0" - , href (newSilenceFromAlertLabels matchers) + , href (newSilenceFromAlertLabels <| Dict.fromList matchers) ] [ text "Recreate" ] _ -> - let - editUrl = - String.join "/" [ "#/silences", silence.id, "edit" ] - in - a [ class "btn btn-outline-info border-0", href editUrl ] - [ text "Edit" - ] + default -deleteButton : Silence -> Bool -> Html Msg +deleteButton : GettableSilence -> Bool -> Html Msg deleteButton silence refresh = case silence.status.state of Expired -> @@ -146,7 +151,7 @@ deleteButton silence refresh = detailsButton : String -> Html Msg -detailsButton silenceId = - a [ class "btn btn-outline-info border-0", href ("#/silences/" ++ silenceId) ] +detailsButton id = + a [ class "btn btn-outline-info border-0", href ("#/silences/" ++ id) ] [ text "View" ] diff --git a/ui/app/src/Views/SilenceList/Types.elm b/ui/app/src/Views/SilenceList/Types.elm index 51a9bca8ec..c52def2f53 100644 --- a/ui/app/src/Views/SilenceList/Types.elm +++ b/ui/app/src/Views/SilenceList/Types.elm @@ -1,22 +1,24 @@ module Views.SilenceList.Types exposing (Model, SilenceListMsg(..), SilenceTab, initSilenceList) import Browser.Navigation exposing (Key) -import Silences.Types exposing (Silence, SilenceId, State(..)) +import Data.GettableSilence exposing (GettableSilence) +import Data.GettableSilences exposing (GettableSilences) +import Data.SilenceStatus exposing (State(..)) import Utils.Types exposing (ApiData(..)) import Views.FilterBar.Types as FilterBar type SilenceListMsg - = ConfirmDestroySilence Silence Bool - | DestroySilence Silence Bool - | SilencesFetch (ApiData (List Silence)) + = ConfirmDestroySilence GettableSilence Bool + | DestroySilence GettableSilence Bool + | SilencesFetch (ApiData (List GettableSilence)) | FetchSilences | MsgForFilterBar FilterBar.Msg | SetTab State type alias SilenceTab = - { silences : List Silence + { silences : GettableSilences , tab : State , count : Int } @@ -26,7 +28,7 @@ type alias Model = { silences : ApiData (List SilenceTab) , filterBar : FilterBar.Model , tab : State - , showConfirmationDialog : Maybe SilenceId + , showConfirmationDialog : Maybe String , key : Key } diff --git a/ui/app/src/Views/SilenceList/Updates.elm b/ui/app/src/Views/SilenceList/Updates.elm index 786706397f..437c752d3a 100644 --- a/ui/app/src/Views/SilenceList/Updates.elm +++ b/ui/app/src/Views/SilenceList/Updates.elm @@ -1,8 +1,10 @@ module Views.SilenceList.Updates exposing (update, urlUpdate) import Browser.Navigation as Navigation +import Data.GettableSilence exposing (GettableSilence) +import Data.GettableSilences exposing (GettableSilences) +import Data.SilenceStatus exposing (State(..)) import Silences.Api as Api -import Silences.Types exposing (Silence, State(..)) import Utils.Api as ApiData import Utils.Filter exposing (Filter, generateQueryString) import Utils.Types as Types exposing (ApiData(..), Matchers, Time) @@ -62,7 +64,7 @@ update msg model filter basePath apiUrl = ( { model | tab = tab }, Cmd.none ) -groupSilencesByState : List Silence -> State -> SilenceTab +groupSilencesByState : List GettableSilence -> State -> SilenceTab groupSilencesByState silences state = let silencesInTab = @@ -79,9 +81,14 @@ states = [ Active, Pending, Expired ] -filterSilencesByState : State -> List Silence -> List Silence +filterSilencesByState : State -> GettableSilences -> GettableSilences filterSilencesByState state = - List.filter (.status >> .state >> (==) state) + List.filter (filterSilenceByState state) + + +filterSilenceByState : State -> GettableSilence -> Bool +filterSilenceByState state silence = + silence.status.state == state urlUpdate : Maybe String -> ( SilenceListMsg, Filter ) diff --git a/ui/app/src/Views/SilenceList/Views.elm b/ui/app/src/Views/SilenceList/Views.elm index e14e7ca611..435f5427f5 100644 --- a/ui/app/src/Views/SilenceList/Views.elm +++ b/ui/app/src/Views/SilenceList/Views.elm @@ -1,10 +1,13 @@ module Views.SilenceList.Views exposing (filterSilencesByState, groupSilencesByState, silencesView, states, tabView, tabsView, view) +import Data.GettableSilence exposing (GettableSilence) +import Data.GettableSilences exposing (GettableSilences) +import Data.SilenceStatus exposing (State(..)) import Html exposing (..) import Html.Attributes exposing (..) import Html.Keyed import Html.Lazy exposing (lazy, lazy2, lazy3) -import Silences.Types exposing (Silence, SilenceId, State(..), stateToString) +import Silences.Types exposing (stateToString) import Types exposing (Msg(..)) import Utils.String as StringUtils import Utils.Types exposing (ApiData(..), Matcher) @@ -53,7 +56,7 @@ tabView currentTab count tab = ] -silencesView : Maybe SilenceId -> State -> ApiData (List SilenceTab) -> Html Msg +silencesView : Maybe String -> State -> ApiData (List SilenceTab) -> Html Msg silencesView showConfirmationDialog tab silencesTab = case silencesTab of Success tabs -> @@ -87,7 +90,7 @@ silencesView showConfirmationDialog tab silencesTab = loading -groupSilencesByState : List Silence -> List ( State, List Silence ) +groupSilencesByState : GettableSilences -> List ( State, GettableSilences ) groupSilencesByState silences = List.map (\state -> ( state, filterSilencesByState state silences )) states @@ -97,6 +100,11 @@ states = [ Active, Pending, Expired ] -filterSilencesByState : State -> List Silence -> List Silence +filterSilencesByState : State -> GettableSilences -> GettableSilences filterSilencesByState state = - List.filter (.status >> .state >> (==) state) + List.filter (filterSilenceByState state) + + +filterSilenceByState : State -> GettableSilence -> Bool +filterSilenceByState state silence = + silence.status.state == state diff --git a/ui/app/src/Views/SilenceView/Types.elm b/ui/app/src/Views/SilenceView/Types.elm index f186e362da..ba16c3cb4e 100644 --- a/ui/app/src/Views/SilenceView/Types.elm +++ b/ui/app/src/Views/SilenceView/Types.elm @@ -2,22 +2,23 @@ module Views.SilenceView.Types exposing (Model, SilenceViewMsg(..), initSilenceV import Alerts.Types exposing (Alert) import Browser.Navigation exposing (Key) -import Silences.Types exposing (Silence, SilenceId) +import Data.GettableSilence exposing (GettableSilence) +import Data.GettableSilences exposing (GettableSilences) import Utils.Types exposing (ApiData(..)) type SilenceViewMsg = FetchSilence String - | SilenceFetched (ApiData Silence) + | SilenceFetched (ApiData GettableSilence) | SetActiveAlert (Maybe String) | AlertGroupsPreview (ApiData (List Alert)) - | InitSilenceView SilenceId - | ConfirmDestroySilence Silence Bool + | InitSilenceView String + | ConfirmDestroySilence GettableSilence Bool | Reload String type alias Model = - { silence : ApiData Silence + { silence : ApiData GettableSilence , alerts : ApiData (List Alert) , activeAlertId : Maybe String , showConfirmationDialog : Bool diff --git a/ui/app/src/Views/SilenceView/Updates.elm b/ui/app/src/Views/SilenceView/Updates.elm index c36e66cc65..b7d1c9d6c5 100644 --- a/ui/app/src/Views/SilenceView/Updates.elm +++ b/ui/app/src/Views/SilenceView/Updates.elm @@ -9,8 +9,8 @@ import Utils.Types exposing (ApiData(..)) import Views.SilenceView.Types exposing (Model, SilenceViewMsg(..)) -update : SilenceViewMsg -> Model -> String -> ( Model, Cmd SilenceViewMsg ) -update msg model apiUrl = +update : SilenceViewMsg -> Model -> String -> String -> ( Model, Cmd SilenceViewMsg ) +update msg model basePath apiUrl = case msg of FetchSilence id -> ( model, getSilence apiUrl id SilenceFetched ) @@ -31,7 +31,7 @@ update msg model apiUrl = , alerts = Loading } , Alerts.Api.fetchAlerts - apiUrl + basePath { nullFilter | text = Just (Utils.List.mjoin silence.matchers), showSilenced = Just True } |> Cmd.map AlertGroupsPreview ) diff --git a/ui/app/src/Views/SilenceView/Views.elm b/ui/app/src/Views/SilenceView/Views.elm index eaf0f2d57d..7352a9121f 100644 --- a/ui/app/src/Views/SilenceView/Views.elm +++ b/ui/app/src/Views/SilenceView/Views.elm @@ -1,10 +1,13 @@ module Views.SilenceView.Views exposing (view) import Alerts.Types exposing (Alert) +import Data.GettableSilence exposing (GettableSilence) +import Data.GettableSilences exposing (GettableSilences) +import Data.SilenceStatus import Html exposing (Html, b, button, div, h1, h2, h3, label, p, span, text) import Html.Attributes exposing (class, href) import Html.Events exposing (onClick) -import Silences.Types exposing (Silence, stateToString) +import Silences.Types exposing (stateToString) import Types exposing (Msg(..)) import Utils.Date exposing (dateTimeFormat) import Utils.List @@ -38,7 +41,7 @@ view { silence, alerts, activeAlertId, showConfirmationDialog } = error msg -viewSilence : Maybe String -> ApiData (List Alert) -> Silence -> Bool -> Html Msg +viewSilence : Maybe String -> ApiData (List Alert) -> GettableSilence -> Bool -> Html Msg viewSilence activeAlertId alerts silence showPromptDialog = let affectedAlerts = @@ -58,7 +61,7 @@ viewSilence activeAlertId alerts silence showPromptDialog = , formGroup "Starts at" <| text <| dateTimeFormat silence.startsAt , formGroup "Ends at" <| text <| dateTimeFormat silence.endsAt , formGroup "Updated at" <| text <| dateTimeFormat silence.updatedAt - , formGroup "Created by" <| text silence.createdBy + , formGroup "Created by" <| text <| silence.createdBy , formGroup "Comment" <| text silence.comment , formGroup "State" <| text <| stateToString silence.status.state , formGroup "Matchers" <| @@ -75,9 +78,9 @@ viewSilence activeAlertId alerts silence showPromptDialog = ] -confirmSilenceDeleteView : Silence -> Bool -> Dialog.Config Msg +confirmSilenceDeleteView : GettableSilence -> Bool -> Dialog.Config Msg confirmSilenceDeleteView silence refresh = - { onClose = MsgForSilenceView (SilenceViewTypes.Reload silence.id) + { onClose = MsgForSilenceView (SilenceViewTypes.Reload <| silence.id) , title = "Expire Silence" , body = text "Are you sure you want to expire this silence?" , footer = @@ -99,13 +102,13 @@ formGroup key content = ] -expireButton : Silence -> Bool -> Html Msg +expireButton : GettableSilence -> Bool -> Html Msg expireButton silence refresh = case silence.status.state of - Silences.Types.Expired -> + Data.SilenceStatus.Expired -> text "" - Silences.Types.Active -> + Data.SilenceStatus.Active -> button [ class "btn btn-outline-danger border-0" , onClick (MsgForSilenceView (SilenceViewTypes.ConfirmDestroySilence silence refresh)) @@ -113,7 +116,7 @@ expireButton silence refresh = [ text "Expire" ] - Silences.Types.Pending -> + Data.SilenceStatus.Pending -> button [ class "btn btn-outline-danger border-0" , onClick (MsgForSilenceView (SilenceViewTypes.ConfirmDestroySilence silence refresh)) diff --git a/ui/app/src/Views/Status/Types.elm b/ui/app/src/Views/Status/Types.elm index 4b3936350c..a7f0438d9f 100644 --- a/ui/app/src/Views/Status/Types.elm +++ b/ui/app/src/Views/Status/Types.elm @@ -1,16 +1,17 @@ module Views.Status.Types exposing (StatusModel, StatusMsg(..), initStatusModel) +import Data.AlertmanagerStatus exposing (AlertmanagerStatus) import Status.Types exposing (StatusResponse) import Utils.Types exposing (ApiData(..)) type StatusMsg - = NewStatus (ApiData StatusResponse) + = NewStatus (ApiData AlertmanagerStatus) | InitStatusView type alias StatusModel = - { statusInfo : ApiData StatusResponse + { statusInfo : ApiData AlertmanagerStatus } diff --git a/ui/app/src/Views/Status/Updates.elm b/ui/app/src/Views/Status/Updates.elm index 66846a1e46..4a3f52b0aa 100644 --- a/ui/app/src/Views/Status/Updates.elm +++ b/ui/app/src/Views/Status/Updates.elm @@ -12,4 +12,4 @@ update msg model basePath = ( { model | status = { statusInfo = apiResponse } }, Cmd.none ) InitStatusView -> - ( model, getStatus basePath (NewStatus >> MsgForStatus) ) + ( model, getStatus "/api/v2/" (NewStatus >> MsgForStatus) ) diff --git a/ui/app/src/Views/Status/Views.elm b/ui/app/src/Views/Status/Views.elm index 44b5b88cbc..e14f9cbba7 100644 --- a/ui/app/src/Views/Status/Views.elm +++ b/ui/app/src/Views/Status/Views.elm @@ -1,9 +1,14 @@ module Views.Status.Views exposing (view) +import Data.AlertmanagerStatus exposing (AlertmanagerStatus) +import Data.ClusterStatus exposing (ClusterStatus) +import Data.PeerStatus exposing (PeerStatus) +import Data.VersionInfo exposing (VersionInfo) import Html exposing (..) import Html.Attributes exposing (class, classList, style) -import Status.Types exposing (ClusterPeer, ClusterStatus, StatusResponse, VersionInfo) +import Status.Types exposing (StatusResponse, VersionInfo) import Types exposing (Msg(..)) +import Utils.Date exposing (timeToString) import Utils.Types exposing (ApiData(..)) import Utils.Views import Views.Status.Types exposing (StatusModel) @@ -25,17 +30,17 @@ view { statusInfo } = Utils.Views.error msg -viewStatusInfo : StatusResponse -> Html Types.Msg +viewStatusInfo : AlertmanagerStatus -> Html Types.Msg viewStatusInfo status = div [] [ h1 [] [ text "Status" ] , div [ class "form-group row" ] [ b [ class "col-sm-2" ] [ text "Uptime:" ] - , div [ class "col-sm-10" ] [ text status.uptime ] + , div [ class "col-sm-10" ] [ text <| timeToString status.uptime ] ] - , viewClusterStatus status.clusterStatus + , viewClusterStatus status.cluster , viewVersionInformation status.versionInfo - , viewConfig status.config + , viewConfig status.config.original ] @@ -51,46 +56,36 @@ viewConfig config = ] -viewClusterStatus : Maybe ClusterStatus -> Html Types.Msg -viewClusterStatus clusterStatus = - case clusterStatus of - Just { name, status, peers } -> - span [] - [ h2 [] [ text "Cluster Status" ] - , div [ class "form-group row" ] - [ b [ class "col-sm-2" ] [ text "Name:" ] - , div [ class "col-sm-10" ] [ text name ] - ] - , div [ class "form-group row" ] - [ b [ class "col-sm-2" ] [ text "Status:" ] - , div [ class "col-sm-10" ] - [ span - [ classList - [ ( "badge", True ) - , ( "badge-success", status == "ready" ) - , ( "badge-warning", status == "settling" ) - ] - ] - [ text status ] +viewClusterStatus : ClusterStatus -> Html Types.Msg +viewClusterStatus { name, status, peers } = + span [] + [ h2 [] [ text "Cluster Status" ] + , div [ class "form-group row" ] + [ b [ class "col-sm-2" ] [ text "Name:" ] + , div [ class "col-sm-10" ] [ text name ] + ] + , div [ class "form-group row" ] + [ b [ class "col-sm-2" ] [ text "Status:" ] + , div [ class "col-sm-10" ] + [ span + [ classList + [ ( "badge", True ) + , ( "badge-success", status == "ready" ) + , ( "badge-warning", status == "settling" ) ] ] - , div [ class "form-group row" ] - [ b [ class "col-sm-2" ] [ text "Peers:" ] - , ul [ class "col-sm-10" ] <| - List.map viewClusterPeer peers - ] - ] - - Nothing -> - span [] - [ h2 [] [ text "Mesh Status" ] - , div [ class "form-group row" ] - [ div [ class "col-sm-10" ] [ text "Mesh not configured" ] - ] + [ text status ] ] + ] + , div [ class "form-group row" ] + [ b [ class "col-sm-2" ] [ text "Peers:" ] + , ul [ class "col-sm-10" ] <| + List.map viewClusterPeer peers + ] + ] -viewClusterPeer : ClusterPeer -> Html Types.Msg +viewClusterPeer : PeerStatus -> Html Types.Msg viewClusterPeer peer = li [] [ div [ class "" ]