From e4e053b18eacd777c5aab9d5bf489f9f99b328a1 Mon Sep 17 00:00:00 2001 From: Max Leonard Inden Date: Thu, 8 Nov 2018 17:46:04 +0000 Subject: [PATCH] ui: Move /status & /silences to API v2 This patch makes the Alertmanager UI (/status & /silences) use the api/v2 endpoint. In addition it adds logic to generate the elm side data model based on the OpenAPI specification. Signed-off-by: Max Leonard Inden --- .travis.yml | 2 +- Makefile | 3 +- api/v2/api.go | 91 +++-- api/v2/models/alert.go | 101 +---- api/v2/models/alert_status.go | 138 +++++++ api/v2/models/alertmanager_config.go | 64 +++ api/v2/models/alertmanager_status.go | 104 +++-- api/v2/models/cluster_status.go | 117 ++++++ api/v2/models/matcher.go | 58 ++- api/v2/models/peer_status.go | 39 +- api/v2/models/receiver.go | 23 +- api/v2/models/silence.go | 137 ++----- api/v2/models/silence_status.go | 104 +++++ api/v2/models/version_info.go | 149 +++++++ api/v2/openapi.yaml | 114 +++++- api/v2/restapi/embedded_spec.go | 382 +++++++++++++----- asset/assets_vfsdata.go | 4 +- test/with_api_v2/acceptance.go | 10 +- .../client/alert/get_alerts_parameters.go | 3 +- .../client/alert/post_alerts_parameters.go | 3 +- .../general/get_receivers_parameters.go | 113 ------ .../client/general/get_receivers_responses.go | 65 --- .../client/general/get_status_parameters.go | 3 +- .../receiver/get_receivers_parameters.go | 3 +- .../silence/delete_silence_parameters.go | 3 +- .../client/silence/get_silence_parameters.go | 3 +- .../client/silence/get_silences_parameters.go | 3 +- .../silence/post_silences_parameters.go | 3 +- .../with_api_v2/api_v2_client/models/alert.go | 101 +---- .../api_v2_client/models/alert_status.go | 138 +++++++ .../models/alertmanager_config.go | 64 +++ .../models/alertmanager_status.go | 104 +++-- .../api_v2_client/models/cluster_status.go | 117 ++++++ .../api_v2_client/models/matcher.go | 58 ++- .../api_v2_client/models/peer_status.go | 39 +- .../api_v2_client/models/receiver.go | 23 +- .../api_v2_client/models/silence.go | 137 ++----- .../api_v2_client/models/silence_status.go | 104 +++++ .../api_v2_client/models/version_info.go | 149 +++++++ test/with_api_v2/mock.go | 32 +- ui/app/Makefile | 30 +- ui/app/elm.json | 3 +- ui/app/src/Data/Alert.elm | 63 +++ ui/app/src/Data/AlertStatus.elm | 81 ++++ ui/app/src/Data/AlertmanagerConfig.elm | 36 ++ ui/app/src/Data/AlertmanagerStatus.elm | 49 +++ ui/app/src/Data/Alerts.elm | 33 ++ ui/app/src/Data/ClusterStatus.elm | 43 ++ ui/app/src/Data/InlineResponse200.elm | 36 ++ ui/app/src/Data/Matcher.elm | 42 ++ ui/app/src/Data/Matchers.elm | 33 ++ ui/app/src/Data/PeerStatus.elm | 39 ++ ui/app/src/Data/Receiver.elm | 36 ++ ui/app/src/Data/Silence.elm | 60 +++ ui/app/src/Data/SilenceStatus.elm | 75 ++++ ui/app/src/Data/Silences.elm | 33 ++ ui/app/src/Data/VersionInfo.elm | 51 +++ ui/app/src/DateTime.elm | 37 ++ ui/app/src/Silences/Api.elm | 16 +- ui/app/src/Silences/Decoders.elm | 66 +-- ui/app/src/Silences/Encoders.elm | 27 -- ui/app/src/Silences/Types.elm | 55 +-- ui/app/src/Status/Api.elm | 5 +- ui/app/src/Utils/List.elm | 3 +- ui/app/src/Views/AlertList/AlertView.elm | 3 +- ui/app/src/Views/SilenceForm/Parsing.elm | 4 +- ui/app/src/Views/SilenceForm/Types.elm | 16 +- ui/app/src/Views/SilenceForm/Views.elm | 6 +- ui/app/src/Views/SilenceList/SilenceView.elm | 122 +++--- ui/app/src/Views/SilenceList/Types.elm | 8 +- ui/app/src/Views/SilenceList/Updates.elm | 20 +- ui/app/src/Views/SilenceList/Views.elm | 32 +- ui/app/src/Views/SilenceView/Types.elm | 5 +- ui/app/src/Views/SilenceView/Updates.elm | 1 + ui/app/src/Views/SilenceView/Views.elm | 58 +-- ui/app/src/Views/Status/Types.elm | 5 +- ui/app/src/Views/Status/Updates.elm | 2 +- ui/app/src/Views/Status/Views.elm | 75 ++-- 78 files changed, 3093 insertions(+), 1124 deletions(-) create mode 100644 api/v2/models/alert_status.go create mode 100644 api/v2/models/alertmanager_config.go create mode 100644 api/v2/models/cluster_status.go create mode 100644 api/v2/models/silence_status.go create mode 100644 api/v2/models/version_info.go delete mode 100644 test/with_api_v2/api_v2_client/client/general/get_receivers_parameters.go delete mode 100644 test/with_api_v2/api_v2_client/client/general/get_receivers_responses.go create mode 100644 test/with_api_v2/api_v2_client/models/alert_status.go create mode 100644 test/with_api_v2/api_v2_client/models/alertmanager_config.go create mode 100644 test/with_api_v2/api_v2_client/models/cluster_status.go create mode 100644 test/with_api_v2/api_v2_client/models/silence_status.go create mode 100644 test/with_api_v2/api_v2_client/models/version_info.go create mode 100644 ui/app/src/Data/Alert.elm create mode 100644 ui/app/src/Data/AlertStatus.elm create mode 100644 ui/app/src/Data/AlertmanagerConfig.elm create mode 100644 ui/app/src/Data/AlertmanagerStatus.elm create mode 100644 ui/app/src/Data/Alerts.elm create mode 100644 ui/app/src/Data/ClusterStatus.elm create mode 100644 ui/app/src/Data/InlineResponse200.elm create mode 100644 ui/app/src/Data/Matcher.elm create mode 100644 ui/app/src/Data/Matchers.elm create mode 100644 ui/app/src/Data/PeerStatus.elm create mode 100644 ui/app/src/Data/Receiver.elm create mode 100644 ui/app/src/Data/Silence.elm create mode 100644 ui/app/src/Data/SilenceStatus.elm create mode 100644 ui/app/src/Data/Silences.elm create mode 100644 ui/app/src/Data/VersionInfo.elm create mode 100644 ui/app/src/DateTime.elm delete mode 100644 ui/app/src/Silences/Encoders.elm diff --git a/.travis.yml b/.travis.yml index 39a06a31..aba4ea09 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 f30a12f6..7a034c62 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 10499c9a..abff40e5 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 } } @@ -447,7 +469,7 @@ func (api *API) getSilencesHandler(params silence_ops.GetSilencesParams) middlew func silenceMatchesFilterLabels(s open_api_models.Silence, 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) @@ -485,28 +507,34 @@ func (api *API) deleteSilenceHandler(params silence_ops.DeleteSilenceParams) mid } func silenceFromProto(s *silencepb.Silence) (open_api_models.Silence, 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.Silence{ ID: s.Id, - StartsAt: strfmt.DateTime(s.StartsAt), - EndsAt: strfmt.DateTime(s.EndsAt), - UpdatedAt: strfmt.DateTime(s.UpdatedAt), + StartsAt: &start, + EndsAt: &end, + UpdatedAt: &updated, Status: &open_api_models.SilenceStatus{ - State: string(types.CalcSilenceState(s.StartsAt, s.EndsAt)), + State: &state, }, - Comment: s.Comment, - CreatedBy: s.CreatedBy, + 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'", @@ -554,21 +582,26 @@ func (api *API) postSilencesHandler(params silence_ops.PostSilencesParams) middl } func silenceToProto(s *open_api_models.Silence) (*silencepb.Silence, error) { + // updatedAt is optional, make sure to check if nil. + updated := time.Time{} + if s.UpdatedAt != nil { + updated = time.Time(*s.UpdatedAt) + } 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), + UpdatedAt: updated, + 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 4a399eed..0755b385 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 00000000..673deaab --- /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 00000000..6b41f1bc --- /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 d205a60a..5c6c785d 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 - Name *string `json:"name"` + Cluster *ClusterStatus `json:"cluster"` - // peers + // config // Required: true - // Minimum: 0 - Peers []*PeerStatus `json:"peers"` + Config *AlertmanagerConfig `json:"config"` - // status in cluster + // uptime // Required: true - StatusInCluster *string `json:"statusInCluster"` + // Format: date-time + Uptime *strfmt.DateTime `json:"uptime"` + + // version info + // Required: true + 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 } - return nil -} - -func (m *AlertmanagerStatus) 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 + 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) validateStatusInCluster(formats strfmt.Registry) error { +func (m *AlertmanagerStatus) validateConfig(formats strfmt.Registry) error { - if err := validate.Required("statusInCluster", "body", m.StatusInCluster); err != nil { + if err := validate.Required("config", "body", m.Config); err != nil { 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) validateVersionInfo(formats strfmt.Registry) error { + + 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 00000000..2ce826ec --- /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/matcher.go b/api/v2/models/matcher.go index f626e306..78bc8194 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 ddfd58b1..9d9c34f4 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/receiver.go b/api/v2/models/receiver.go index e7ceccef..61c2748a 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 747edcfa..651aa4bf 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,14 +18,17 @@ 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"` + EndsAt *strfmt.DateTime `json:"endsAt"` // id ID string `json:"id,omitempty"` @@ -37,21 +38,30 @@ type Silence struct { Matchers Matchers `json:"matchers"` // starts at + // Required: true // Format: date-time - StartsAt strfmt.DateTime `json:"startsAt,omitempty"` + StartsAt *strfmt.DateTime `json:"startsAt"` // status Status *SilenceStatus `json:"status,omitempty"` // updated at // Format: date-time - UpdatedAt strfmt.DateTime `json:"updatedAt,omitempty"` + UpdatedAt *strfmt.DateTime `json:"updatedAt,omitempty"` } // Validate validates this silence func (m *Silence) Validate(formats strfmt.Registry) error { var res []error + if err := m.validateComment(formats); err != nil { + res = append(res, err) + } + + if err := m.validateCreatedBy(formats); err != nil { + res = append(res, err) + } + if err := m.validateEndsAt(formats); err != nil { res = append(res, err) } @@ -78,10 +88,28 @@ func (m *Silence) Validate(formats strfmt.Registry) error { return nil } +func (m *Silence) validateComment(formats strfmt.Registry) error { + + if err := validate.Required("comment", "body", m.Comment); err != nil { + return err + } + + return nil +} + +func (m *Silence) validateCreatedBy(formats strfmt.Registry) error { + + if err := validate.Required("createdBy", "body", m.CreatedBy); err != nil { + return err + } + + return nil +} + func (m *Silence) validateEndsAt(formats strfmt.Registry) error { - if swag.IsZero(m.EndsAt) { // not required - return nil + if err := validate.Required("endsAt", "body", m.EndsAt); err != nil { + return err } if err := validate.FormatOf("endsAt", "body", "date-time", m.EndsAt.String(), formats); err != nil { @@ -109,8 +137,8 @@ func (m *Silence) validateMatchers(formats strfmt.Registry) error { func (m *Silence) validateStartsAt(formats strfmt.Registry) error { - if swag.IsZero(m.StartsAt) { // not required - return nil + if err := validate.Required("startsAt", "body", m.StartsAt); err != nil { + return err } if err := validate.FormatOf("startsAt", "body", "date-time", m.StartsAt.String(), formats); err != nil { @@ -168,90 +196,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 00000000..82c9b435 --- /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 00000000..5cdbc2bd --- /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 41b87eb9..939ea661 100644 --- a/api/v2/openapi.yaml +++ b/api/v2/openapi.yaml @@ -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,6 +273,9 @@ definitions: type: string address: type: string + required: + - name + - address silence: type: object properties: @@ -243,18 +292,27 @@ definitions: updatedAt: type: string format: date-time + x-nullable: true createdBy: type: string comment: type: string status: - type: object - properties: - state: - type: string - enum: ["expired", "active", "pending"] + $ref: '#/definitions/silenceStatus' required: - matchers + - startsAt + - endsAt + - createdBy + - comment + silenceStatus: + type: object + properties: + state: + type: string + enum: ["expired", "active", "pending"] + required: + - state silences: type: array items: @@ -273,8 +331,10 @@ definitions: type: string isRegex: type: boolean - regex: - type: string + required: + - name + - value + - isRegex # Define required properties for 'alert' alerts: type: array @@ -306,24 +366,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 4720c751..e2359052 100644 --- a/api/v2/restapi/embedded_spec.go +++ b/api/v2/restapi/embedded_spec.go @@ -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,17 +428,11 @@ func init() { "$ref": "#/definitions/peerStatus" } }, - "statusInCluster": { + "status": { "type": "string" } } }, - "alerts": { - "type": "array", - "items": { - "$ref": "#/definitions/alert" - } - }, "labelSet": { "type": "object", "additionalProperties": { @@ -395,6 +441,11 @@ func init() { }, "matcher": { "type": "object", + "required": [ + "name", + "value", + "isRegex" + ], "properties": { "isRegex": { "type": "boolean" @@ -402,9 +453,6 @@ func init() { "name": { "type": "string" }, - "regex": { - "type": "string" - }, "value": { "type": "string" } @@ -419,6 +467,10 @@ func init() { }, "peerStatus": { "type": "object", + "required": [ + "name", + "address" + ], "properties": { "address": { "type": "string" @@ -430,6 +482,9 @@ func init() { }, "receiver": { "type": "object", + "required": [ + "name" + ], "properties": { "name": { "type": "string" @@ -439,7 +494,11 @@ func init() { "silence": { "type": "object", "required": [ - "matchers" + "matchers", + "startsAt", + "endsAt", + "createdBy", + "comment" ], "properties": { "comment": { @@ -463,21 +522,28 @@ func init() { "format": "date-time" }, "status": { - "type": "object", - "properties": { - "state": { - "type": "string", - "enum": [ - "expired", - "active", - "pending" - ] - } - } + "$ref": "#/definitions/silenceStatus" }, "updatedAt": { "type": "string", - "format": "date-time" + "format": "date-time", + "x-nullable": true + } + } + }, + "silenceStatus": { + "type": "object", + "required": [ + "state" + ], + "properties": { + "state": { + "type": "string", + "enum": [ + "expired", + "active", + "pending" + ] } } }, @@ -486,6 +552,37 @@ func init() { "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" + } + } } }, "responses": { @@ -827,6 +924,9 @@ func init() { "definitions": { "alert": { "type": "object", + "required": [ + "labels" + ], "properties": { "annotations": { "$ref": "#/definitions/labelSet" @@ -856,29 +956,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 +964,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,17 +1053,11 @@ func init() { "$ref": "#/definitions/peerStatus" } }, - "statusInCluster": { + "status": { "type": "string" } } }, - "alerts": { - "type": "array", - "items": { - "$ref": "#/definitions/alert" - } - }, "labelSet": { "type": "object", "additionalProperties": { @@ -923,6 +1066,11 @@ func init() { }, "matcher": { "type": "object", + "required": [ + "name", + "value", + "isRegex" + ], "properties": { "isRegex": { "type": "boolean" @@ -930,9 +1078,6 @@ func init() { "name": { "type": "string" }, - "regex": { - "type": "string" - }, "value": { "type": "string" } @@ -947,6 +1092,10 @@ func init() { }, "peerStatus": { "type": "object", + "required": [ + "name", + "address" + ], "properties": { "address": { "type": "string" @@ -958,6 +1107,9 @@ func init() { }, "receiver": { "type": "object", + "required": [ + "name" + ], "properties": { "name": { "type": "string" @@ -967,7 +1119,11 @@ func init() { "silence": { "type": "object", "required": [ - "matchers" + "matchers", + "startsAt", + "endsAt", + "createdBy", + "comment" ], "properties": { "comment": { @@ -991,21 +1147,28 @@ func init() { "format": "date-time" }, "status": { - "type": "object", - "properties": { - "state": { - "type": "string", - "enum": [ - "expired", - "active", - "pending" - ] - } - } + "$ref": "#/definitions/silenceStatus" }, "updatedAt": { "type": "string", - "format": "date-time" + "format": "date-time", + "x-nullable": true + } + } + }, + "silenceStatus": { + "type": "object", + "required": [ + "state" + ], + "properties": { + "state": { + "type": "string", + "enum": [ + "expired", + "active", + "pending" + ] } } }, @@ -1014,6 +1177,37 @@ func init() { "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" + } + } } }, "responses": { diff --git a/asset/assets_vfsdata.go b/asset/assets_vfsdata.go index b1b49d46..c2951d09 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: 94581, - 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\xb2\x20\x8c\xbe\x8a\xcd\xd1\xd6\x02\x5a\x65\x46\xf2\x2d\x09\x65\x2c\x9d\x5c\x3b\x4e\x27\x4e\x62\x3b\x49\x27\x6e\x4f\x7e\x90\x02\x6d\xda\x32\xe8\x40\xa0\x6d\xd9\xe2\x3c\xfb\xf9\x50\xe0\x55\x22\x95\xac\x99\x3d\xe7\xfc\x7b\xf7\x8a\x29\x02\x28\x14\x80\x42\xdd\x50\x28\xae\x87\x89\x0c\x74\x14\x4b\x22\xe9\x83\x93\x4c\xc5\xda\x54\xab\x28\xd0\xce\x30\x2f\x58\x53\x44\x82\x02\x4d\x1f\x94\xd0\x89\x92\x6b\xda\xe5\x4c\x82\x76\x43\xa6\x40\xa7\x45\xb5\x29\x29\xab\x28\xb2\x09\x1a\x0a\xd0\xaa\x28\xa8\xf6\x96\x83\x23\x0a\x24\x4d\x53\x5a\x82\x12\x44\x54\x40\x6d\x81\x28\x41\xe9\x65\x50\x2b\xa1\x0b\xa2\xc1\xc2\xaf\x76\xa0\x49\x52\xe9\x60\x1b\x92\xb2\x03\xb1\x0c\xed\x3f\xed\x33\x21\x02\x8a\x5e\xab\xdd\x46\x84\x57\xba\xdd\x01\x5e\x76\x9b\x2c\x03\xfc\x6f\xc0\x84\x93\x04\xaa\xb8\x54\x91\x49\x48\x50\x41\x66\x17\x82\x12\x19\xbe\x0c\xf3\xff\x0e\x7e\x01\xe1\xb0\x80\x61\x15\x45\x4e\xa2\x0a\x8a\x8f\x21\x2a\x51\x0c\x96\xc1\xfe\xff\x0c\xeb\x88\x04\xb0\x8c\x77\x15\xf1\x80\xc4\x15\xc4\x9f\x40\x5c\x22\x1e\x2d\x43\xfe\xff\xe7\x58\x62\x12\x41\xe3\x68\xaa\xc3\x89\x49\x58\x19\xce\x53\x08\xcb\xe1\xc4\xcb\xc0\xff\x5f\x36\xc2\x90\xc4\xd0\x36\xc6\xea\x20\x67\x0b\x6c\x6e\x93\x31\x26\x5d\x3e\x92\x6e\x48\xcc\x7b\xcf\xf4\x43\x74\xa5\xc5\xad\x6d\x01\x25\x92\x5b\xf5\x36\x20\x8a\x56\x44\x54\x1a\xde\xe5\x0d\xa1\x1c\xf2\xf6\x62\x53\x48\xaa\x8d\x49\x52\x69\x7f\x59\xb6\x87\x72\x1e\x77\x96\x21\x00\x5f\x80\x41\x78\x05\xcc\x4d\x15\x0c\x94\x6b\xb4\xdb\x04\x08\x82\x65\x50\x24\xa8\x40\xf3\xeb\xd0\xa0\x24\x83\xc7\xcd\xf0\x20\x6a\x84\x48\x22\x9a\xde\x70\xb5\x16\x32\x41\xca\xe5\xb4\x4b\x13\xc6\x8a\x98\x32\xc1\x9e\x29\xc5\x67\x44\x52\x48\x58\x7f\x98\xec\xc9\x61\xd2\xeb\x51\x71\x92\x9c\x32\x4d\x54\x2f\xa1\xc3\x9c\xff\xa7\x14\x26\x6c\x5a\x83\x54\xc2\xd1\x25\x1c\xc1\xfa\x43\xb1\x27\xbb\x5d\xe5\xfa\x43\xd1\xeb\x51\x7d\x22\x4e\x99\x72\x39\x28\x66\x5e\x15\xc2\x6f\x22\xe4\x99\x3e\x67\x02\xee\x8d\x68\xa1\x29\x85\x31\x23\x8b\x1d\xe4\x9b\xe5\x44\x9e\xa6\x14\x56\x0d\x24\x07\x08\x49\x86\x8b\xa0\xc0\x59\x7f\xc8\xf7\xc4\x90\xf7\x7a\x34\x39\xe1\xa7\x4c\x9f\xf0\xd3\x1c\x83\xe4\x44\x9e\x32\x05\x49\x4a\xa1\x7d\x58\x2a\x87\x9a\xcf\x94\xee\x0d\xf2\xb9\xd2\xe5\x5c\xa9\x93\xa4\x80\x2b\x4e\xf4\x29\x93\x20\x7e\x1f\x5f\x03\x4c\x20\x30\xc5\xcc\xee\xd1\x27\xc9\x29\xa8\x62\xea\xd5\x6f\x42\xda\x18\x0c\xfb\x7b\x4c\x0c\xc5\xc6\x46\x01\x48\x2c\x00\xa2\xd0\x59\x9e\xe4\x55\xc3\x6d\x18\xac\x24\x66\xb8\x35\xca\xf8\x3f\x5e\x18\x64\x1a\x3d\x0e\x66\x81\x0a\xc8\x49\x23\xe4\x82\x80\xa6\x93\x28\x10\x38\x82\xc6\x7a\xb6\x77\x55\xf6\x2e\x37\xc4\x30\x47\x66\x2f\xe9\x76\x49\x52\xe0\x46\x87\x39\xbe\x3c\x47\xb2\x97\x50\x08\x58\x7f\x18\xec\x89\x61\xd0\xeb\x51\x7e\x12\x98\x75\x0e\x4e\xb1\xaa\x2d\x49\xf2\x92\x9e\x30\xb4\x15\x14\x34\xc0\x53\x0a\x0f\x1d\xaf\x9f\xd2\x52\xfd\x3b\xaf\x52\xf4\x43\xc7\x1b\x00\xf7\x24\xf8\x9e\x4a\x71\x9b\x5e\xb1\x29\x39\xaf\x54\x3f\x33\xac\x37\xc7\x4a\xb1\x0e\x68\x26\x33\x6c\x87\x7a\x63\x63\x48\x15\x3b\x27\xf2\x44\xd7\x17\xb8\x68\x7e\x5d\x6f\x7e\x72\x3a\x94\xae\x3f\x94\x4c\xba\x3e\x55\xee\x75\x32\x3d\x27\xd2\xe5\x95\x96\xa6\xde\xb3\x95\xac\xe2\xe4\x74\xa8\x5c\xbf\xdb\xd5\x66\x17\x9b\xbd\x0c\x9a\x69\xd7\xa7\xc2\x82\xc3\x25\x74\x39\x68\x97\xd3\x02\xee\x99\xe1\xd7\x14\x5e\x30\xa2\x17\x20\x1b\x6e\x9f\xc3\x4e\xaa\xb0\xbb\x5d\x51\xef\x00\x04\x13\xae\x4f\x13\xdb\xcd\x6d\xd9\x0d\x88\x7a\x57\x89\xe9\x2a\x5a\xea\xc7\x08\x87\x72\x79\x17\x7b\xea\x76\x93\xa6\xee\x20\x61\x89\xeb\x53\x6e\x3b\xbd\xab\x77\x0a\x49\xbd\x63\x6e\x3a\x4e\x1a\x3a\x36\x52\x25\xef\x3a\x68\xee\xba\xdb\xe5\xed\xfd\x03\x67\xdc\xf5\x69\x60\xb1\xb8\x5c\xc6\x02\x78\x1d\x93\x80\xd6\xd9\x99\x86\x52\x80\x9f\x11\x43\x14\xee\x34\x56\xba\x99\xcb\xee\x13\x6d\x38\xb8\x26\x8a\xd2\x14\xff\x1b\x56\x40\x89\xdf\x02\x65\xf9\xc8\xcc\xd4\xae\x10\xa6\x66\x8c\xcd\xf4\xa8\xef\x99\x87\x5b\x3d\xda\x18\x78\x03\xec\x61\x89\xf5\x56\x78\x5e\x4b\x51\x10\xcb\x69\x3c\x11\xee\x24\x3e\x23\xb2\xe7\x78\x6b\x7b\x91\xd4\x42\x49\x3e\x99\xfe\xdb\xa1\xa0\xaa\x7b\xee\xd0\xec\x02\x7d\xae\xe2\xdb\xb5\x57\x4a\xc5\x8a\x38\xe7\x5a\x5f\x4f\xbd\x47\x8f\xce\x22\x7d\x9e\xf8\x6e\x10\x5f\x3d\x12\x93\xab\x47\x41\xac\xc4\x23\x7f\x12\xfb\x8f\x06\x6e\xdf\xed\x3f\x3a\x8f\xa4\x9e\x3e\x72\x7a\xb2\xe7\xb8\x57\x63\xa7\x22\x9e\x5f\x2d\xf0\x4c\x30\x1b\x03\x12\x76\x84\xab\xde\x07\x41\x87\x86\xb7\x68\x26\xdc\xeb\xf8\x9a\x50\x3a\x34\x65\x1a\x97\xcd\xc7\xf2\x0a\x7f\x2b\xa0\x1e\x95\x9b\x22\x0a\xc9\xa0\xdf\xdf\xd3\x34\xe7\xaf\x76\xf1\xef\xb1\x5f\x0a\xeb\xfd\x61\x14\x12\xc9\x18\x53\x59\x0d\xfb\xc6\x89\xfd\x0b\x11\x68\x67\x9d\xe9\xd9\xb5\x88\xc3\x35\x39\x9f\xcb\x64\x32\x31\x3a\x43\xf1\x94\x37\x71\xf2\x8e\x1d\x56\x54\xef\x76\x0f\xc9\x0e\x85\xf5\x41\xc1\x0b\x93\xb5\x48\xae\x49\xb7\xb3\xd7\xef\x76\x89\x64\x2f\x90\x3a\x94\xf9\x6b\x10\x91\x34\x0a\xc9\xfa\x11\x91\x28\xad\xcc\x3f\xba\x37\x30\xc3\xcb\xb0\x1a\x0c\x73\xf4\x90\xb7\x5c\xb0\x29\x79\x45\xe1\x60\x49\x87\xc8\x6a\xbd\xca\x38\x79\xb9\x78\xfb\x39\x0b\x6a\x1c\x5d\x3e\x3d\x38\x13\xa3\xbe\x27\xf7\x14\x92\x95\x99\x8b\x75\xe9\x76\xb2\x72\xa2\xd9\xbe\xe1\x74\x66\xe3\x50\x3a\xd2\x5e\xf6\xc2\x07\xe5\xfa\xf8\xc2\xfc\x0a\x40\xb9\x81\x15\x02\x86\x4f\xa2\xf2\xd2\xed\xae\xd7\x1b\x5b\xee\x69\xd5\x98\x92\xb2\xe7\x73\x03\x6d\x34\xf0\x94\xeb\x1b\x04\xfa\x56\xeb\x7a\xd9\x32\x4e\x3b\x2a\xba\xd7\x4f\x29\xbc\x6b\xd5\x77\xb2\x4a\x83\xf6\x5d\xd0\xdf\xdb\xcf\x45\x5f\x6b\x0d\xd6\x5a\xc5\xee\x52\x5b\x5c\x8c\x64\xaf\x3f\xba\xd5\x9e\x1e\x5d\x6a\x6f\xa6\x8d\xaa\x70\xcc\xfa\xe5\x6a\xdc\xd7\xc4\x57\x21\xba\x8a\xf2\x1f\x75\xf9\x9c\xd7\x80\xc0\xd3\x95\x5a\x1f\x2a\x06\x85\x2c\x5f\xff\xac\xa2\xf5\x90\x16\x14\x28\x90\x02\xad\x0a\x29\x4f\xc4\x69\xbd\x40\x65\xba\xa5\x29\xc8\x07\x81\x93\xff\x9c\x4d\xc9\x9b\x0a\x25\xbd\xb1\xe0\x0d\x1d\x4d\xb5\x8a\xe4\x59\x85\xec\x0b\x3a\xea\xa9\x8c\x74\xfc\xfc\x95\x1a\x5a\x84\xce\x2d\x0d\x64\x04\x30\xac\xa8\x36\x15\xa1\x8a\x5c\xbb\xac\x5a\xc3\xe7\x75\x1b\x31\xc8\x9e\x61\x57\xff\x51\xe1\xef\x29\x6b\x76\x2e\x39\x53\x6e\x70\xce\xd5\x8b\x78\x2c\x9e\x69\x92\xd0\x21\xdf\xdb\xd9\xd9\x7c\xba\x3b\x9f\xef\xec\x6e\x0d\x9e\xee\xf1\x11\xc9\x54\xba\x0f\x56\xa9\xa3\x60\xd4\x3c\xaf\xfe\xb6\xa7\x4e\x92\xde\xc0\x16\xb2\x4d\x9a\x16\x8c\xe9\x22\x8e\x24\x71\x9c\x26\x0a\x2b\xd1\x3c\x39\x85\x9a\x1a\x66\xb5\xdd\x02\x41\xc3\x38\x82\x25\x3c\x93\x5e\x0f\x82\x3a\xae\xc1\x7c\x4e\x78\xcf\x36\x30\x48\x82\x41\x8f\x53\x6a\xe4\x29\x72\x48\x5e\x60\xa6\x2b\x98\x0d\xff\x23\x25\x3c\x47\x4b\x5b\xb4\xf4\x6f\xa3\xa5\x0b\xb4\xac\xea\x6d\x50\x33\x7b\xaf\x94\x67\x48\x4c\x1f\x57\x6a\x58\x39\x3a\x46\x85\xcf\x50\x49\x18\x2a\xf1\xbc\x8e\x8a\xc0\x95\xdc\xdd\xda\xec\xcf\xe7\x3b\x8f\xb7\xb6\xb7\xf6\xf8\x7c\x6e\xf4\xd9\x93\x8d\x0d\x71\x6a\x54\xd7\x1c\x8b\x64\x01\x0b\x78\xdf\x46\x8b\xca\x9d\x5e\x4f\x22\xc3\xe3\x53\x0a\x5f\xdb\x6b\xe1\xd4\x62\xa5\xb7\x0d\x83\x69\xd4\xce\x7f\x83\x88\xad\x4e\x9b\x2b\xed\x46\xad\x4d\xea\x44\xa1\xa9\xd9\x9e\x49\x7d\xd4\xc9\x7c\x4e\x4c\xf5\x8d\x0d\x7d\xda\x13\x96\x24\x04\x2d\x44\x50\x3f\xcd\x65\x51\x36\xfd\x9f\x57\x58\xb0\xff\xbd\x98\xac\x2f\xa0\x32\x48\x0b\x9c\x28\x7c\x69\x99\xdd\x8d\xc1\x9e\x72\x23\x39\x16\x77\x1f\x42\x3b\xc5\xdf\xda\xd6\xa1\xcf\xd8\x42\xd5\x4f\xad\x4c\x26\xb7\x79\x8a\x21\x1a\xf9\x36\xe1\x53\xbd\x5f\xb4\x67\x45\xd9\x46\x5e\x3d\xa5\xf0\xf7\x12\x48\x3b\x55\x85\x21\x12\x85\x44\xef\x0d\x72\x7e\xd9\xa9\xb0\xc6\x3e\xa0\x52\xbf\x31\xd8\x33\xd3\x52\x62\x8a\xfa\x4f\xae\xcb\x0b\x0a\xa2\xc7\x74\x5d\x83\xc7\x85\xfa\x73\x25\xc7\x84\xbf\x5a\x25\xa7\xdc\x58\xa1\x3a\xca\x3f\xd0\x04\xfe\xde\xde\xfa\xd1\xaa\xd6\x8f\xd4\xbc\x8f\xc5\xef\xb9\x3e\x77\xaf\xe3\xdb\x76\xf5\xf5\xbf\x64\xab\xd4\x55\xff\x25\x87\xe5\x22\x32\x39\x3a\x24\x83\x01\xf5\xfa\x7b\xba\xdb\x95\x7b\xfd\xf9\x5c\x1b\x7d\xab\xbf\x27\x47\xba\x27\x3d\x6d\xb5\x70\xec\x91\x6b\x2e\x37\xed\xfc\x48\xc9\xf0\x55\x20\xa2\x09\xa8\xec\x47\x38\x89\x63\x05\x3a\xfb\xa5\xe2\x44\x8e\x41\x64\xbf\x26\xf1\x59\xab\x9c\xe9\x76\x57\x8d\x7a\x3e\x5f\x55\xba\xce\x58\xce\xdb\x12\xc9\x7e\x65\x7c\xe5\x84\x63\x38\x7e\x8f\xef\xb1\x24\xff\x1d\x19\x7b\xba\xdb\x8d\xf6\x78\xb6\xf5\x62\x96\x54\xf7\x9c\xa2\xc3\x80\xc9\x93\xa8\xd7\x3b\x65\x8c\x25\x27\xaa\xd7\x3b\xed\x76\xc9\xc0\xcc\x60\x3c\x22\xba\xd7\x03\xc1\x06\x46\x70\xf5\x7a\x80\xfc\x99\x31\xb2\xbb\xb5\xfd\xe4\x49\x37\xa6\xa3\x85\x86\xde\x80\x16\x2c\xf1\x07\x09\x46\xca\xdb\x18\xa0\xee\x9d\x52\xe0\xb2\x9d\xa9\xa9\xbd\x9c\x41\x8f\xea\x5d\xe8\x3a\xaa\x74\x64\x36\xbf\x76\xa7\x89\x3f\xd5\x8a\x28\xd8\xa4\x94\x8e\x54\x6f\xd3\xdb\x18\x78\x58\x74\xa2\x4e\x29\x1d\x39\xff\x18\xfd\x9b\x99\x5f\xa3\x8d\x4d\x4f\xf5\x06\xa6\xc2\x86\xd1\xfa\x82\x15\x68\x2c\xf4\x66\x68\x28\xa5\x10\xcb\x46\xde\x36\x94\x7b\x05\x63\x93\xbd\x5e\x41\x84\x55\x18\x92\xda\x8d\xbc\xfd\xc4\x70\xb3\xd2\xf2\x90\x69\xf1\x40\x21\x6c\xc2\xa8\xb2\xdf\x87\xe5\xec\x0c\x55\xde\x51\xc2\x16\x90\xdd\xd8\x7e\x62\x99\x67\x7f\x3e\x97\x7b\x2c\xa1\xbe\x12\xfc\x72\x28\x98\xfc\x43\xf4\x92\xbc\xbf\x7b\xa2\xec\x6a\xf8\xcd\x83\xb2\x63\xe8\x37\x8e\x4d\x34\x8d\x6d\xfb\xc9\xbf\xc5\x7c\x2e\xfe\xbd\xf3\xd8\x18\x2d\xbb\x3b\xf6\xd7\xe3\x3e\xea\x84\x62\xef\xe9\xe3\xf9\x7c\xd0\xdf\xdc\x13\x19\x3a\x9a\x0d\x76\xff\xd0\x3d\xb1\xf1\xe4\x71\x2a\x26\x53\xb1\x56\xbc\xd8\xd9\x19\xd6\x5f\x6c\x3f\x29\x91\x96\xa0\x51\x15\x92\x8c\xfc\x6a\x23\x24\x15\x8e\xa8\x28\x04\x8c\xef\xf5\x47\xf9\x6e\xf0\x78\xaf\xe0\xb0\x6a\x2f\xc8\x76\x44\xb4\xb0\x23\x7a\x3d\x3a\x44\xfa\x8f\x46\x44\xb0\x01\x68\xab\xb8\x2d\xd1\x7f\x44\xbb\x5d\x53\xb9\xa4\x78\x9e\x13\x7b\x33\x83\x72\xce\x9c\xa1\x74\xf9\x17\x63\xc5\xf6\x98\x73\xe5\x50\x90\x2e\x57\xd9\xcf\xc8\xa1\x43\xad\x66\x39\x31\x5e\x68\x72\x28\xce\x5e\xdd\x5d\xa3\x6f\x9f\xa6\x01\xd7\xc1\x79\x45\xc9\x3f\xd0\xa9\x61\xb9\x37\xb2\x9d\xe7\x26\x93\x89\xe1\x22\xee\x55\xd6\x74\xb5\x3f\x11\xe5\x0a\x70\xd6\x37\xea\x19\x44\xac\x22\xc9\x20\x66\x1b\x83\x21\xef\xf5\xf6\x64\xb7\x8b\x62\x47\xdc\x89\x80\x04\x46\x47\x8c\xd7\xab\x35\x87\x25\xc0\x90\x89\xc2\x7f\x0a\x7e\xa6\x49\x87\x74\xd8\xdf\x0b\xb3\x89\x9f\x32\x71\x12\x9e\x0e\xfd\x93\x8d\x8d\xf0\x94\x4d\x47\x17\x9a\x4c\xa9\x77\xa0\xd3\x24\x77\x0e\x7d\x49\x40\x9c\xf4\x4f\x41\xd8\x55\x05\x0e\x67\xc4\xa7\x94\x42\x5c\xed\xb4\xd0\xc2\xca\x57\x2c\x82\xcc\x6d\x55\xf1\xa3\x24\x20\x81\xe7\xcb\x11\x98\x9d\x95\xb7\x53\xe2\x7a\xc2\x51\xab\xaa\x9e\xcf\x44\x21\x09\x7a\xbd\x7f\xb3\xa4\xd8\xb7\xc3\xd2\xf1\xc7\xd5\x59\x72\x25\xa4\x9e\xe6\x83\xdc\x82\xdc\x59\xaf\xcc\x20\x55\xa1\xea\x14\x35\x4f\xd4\xe9\xd0\x28\x92\xea\x94\x09\x33\x58\x81\x83\xcd\x3d\x9b\x76\xb8\x12\xca\xea\x4b\x5d\x6c\x9e\x42\x00\x67\x44\x53\x4a\x53\x6a\x56\x7f\xb2\x9a\x77\xe8\x7c\x4d\xab\x6b\x19\xd4\xd6\x4b\x16\x3a\x59\x94\x2f\xab\xc0\x9d\xbd\x1e\x65\x7b\x36\x57\x29\x32\xc5\x93\x43\x64\x17\x83\xd2\x3a\xe0\x7c\x20\x8b\xf5\x29\x85\xea\xc2\x04\x50\xd1\x46\xc6\xcb\x6c\xa8\x74\xe3\xf6\x61\x9c\x1b\xc3\x6d\xa6\x9c\xa9\x36\x00\x51\x56\x2b\x2c\xd3\xce\x52\xbd\x2d\x08\x3d\x09\x67\xb9\x5b\xf8\x7c\x55\xd7\xdb\x68\x61\x9f\x7b\x32\xcd\x10\xbd\x6a\xab\x6d\x3b\x32\x62\x27\xa5\x70\xb6\x42\xb8\x64\xf5\x40\x63\xcd\x6b\xd9\xec\xb8\x5d\xac\x0c\xe2\xb4\xdd\xf7\xba\x5c\x19\x92\xd3\x55\x1e\xd3\xa6\x06\xc0\xb1\x09\x6f\x6c\x52\x39\x73\x5b\x68\x04\xc1\x29\x52\xe0\x4c\x32\x12\xb4\xb4\xad\x9c\xb0\x2d\xb5\x86\x08\xbb\x8d\x5b\x9b\x42\xbc\xaa\x31\xc4\xa7\x4d\x7c\xb6\xc2\x3f\xef\xcc\xab\xb7\x47\x1f\x0e\xdc\x6b\xae\xa6\x02\x5d\xaf\x8b\x3c\x74\x3f\x21\x33\x72\x15\x80\x73\x7c\x1e\x4d\xd7\xa2\xe9\x9a\x8c\xf5\xda\x0d\x9f\x44\xe3\x35\xd3\x72\x7d\xcd\xe9\x49\xf7\x4a\x4c\xa7\xfc\x4c\xc0\x85\x34\x30\x28\x72\xdd\xdb\x56\x72\xc0\x6e\x0f\xa4\xf5\xf4\x96\xe4\x78\x97\xd5\x9a\xde\x46\x88\x82\xdb\xa1\x0f\x01\x9f\x8a\xb5\x2d\x2f\x73\x1c\xfa\x71\x3c\x11\xbc\xe2\x37\x54\xa3\x97\x09\x51\xd4\x7b\x21\x89\xc3\xd7\x9e\x7f\xf8\xf0\xce\x01\xa3\xad\x99\x56\x9b\x79\x2b\x99\x5c\xf9\x42\x95\xde\x3b\x35\xc2\xea\x72\x6d\xff\xe0\xd8\x54\xf7\x36\x36\x07\xdb\x8f\xb7\x9f\x6c\xed\x6e\x3f\xde\x53\xdd\xae\xda\x2b\x7f\x77\xbb\xa4\x3f\x47\x35\x27\xef\x6a\x3d\x9a\xbe\x8e\x64\xa4\xcd\x6c\xcd\xe7\xea\xbf\x06\x8b\xd0\xb0\x9a\x45\x61\x7b\x01\x85\x16\xbc\x5f\xbf\xfb\xf0\xec\xb8\x44\x7c\x37\x6f\xb5\xe8\x2e\xca\x5b\xa9\xb5\x48\x4e\x35\x97\x81\x79\x79\x84\x95\xb0\xa4\xe7\x38\x39\xc8\xa3\xe3\xc3\xfd\x83\x3f\x4b\x98\x4f\xbd\x8a\xc0\xcb\x47\x23\xdd\xc0\xd6\x37\x2f\xcb\xba\x3b\x79\xdd\x97\x09\xb1\x0b\x6a\xdf\x3f\xce\xdf\x23\x07\x77\xa3\x69\xce\xc9\x47\x97\xd2\x3a\x35\xe1\x2c\xef\xff\xdd\xfe\x51\x65\x44\x4f\x7e\xdd\xf2\x99\xcc\x9a\xca\xb5\x67\x87\x87\xcf\xbe\x95\x8d\x07\x7d\x2f\x37\xfc\xc6\x8d\xbe\x66\x55\x7a\x98\xe7\xf3\x75\xa2\xad\x77\x2e\x97\x47\x19\xd0\x0f\xcf\xdf\xbe\x7a\x71\xbc\x76\x1b\xe9\xf3\x35\xbe\x16\x46\x62\x32\x5e\x93\xfc\x4a\x8c\xd7\xfe\x1f\xa7\xa7\x7b\xce\xff\x83\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\x3f\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\x39\xcd\xbf\x18\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\x8b\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\x63\x85\x09\xb0\x85\xb5\xc7\x68\x55\xc0\x87\x15\x15\xb7\x2b\x15\x71\x24\x3f\x65\xf5\x74\xef\x39\x22\x61\x4d\x46\x1c\x82\xf0\x7e\xca\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\xfb\xfd\xbb\x37\x5a\x5f\x1f\x8a\x9f\x89\x98\xea\xe1\x7a\x9d\xa0\xcd\x54\x7d\x09\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\xd3\x93\xae\x8e\x35\x9f\x60\x88\x4a\x4a\x24\x24\xe8\x02\x5b\xea\x47\x28\x15\xab\x4a\x27\xf4\x41\x91\x63\x49\xfe\x0a\x30\xb4\xa5\xa9\x85\x8e\xae\x44\x9c\xe8\xe5\x36\xdf\xdb\xdb\x18\xb4\x16\x1a\x34\xb9\xed\x88\x60\x12\x1e\x82\x7d\x4f\xb8\x4a\x4c\xaf\x63\x39\x15\x9f\x0f\xdf\x81\x7f\xe9\x3d\xf8\x6f\x3d\xe1\x4e\x35\xd7\xc9\x14\x02\x51\x3c\x1f\x8b\x3b\x9d\x82\xdf\xf1\xaa\xb3\x64\x79\x40\x9c\xd8\xc3\xf0\xf2\x28\xbc\xf4\xbb\xca\xec\xa0\xd0\xf9\x47\xfd\x23\x1d\x0a\xab\xcf\x2d\x4b\x4f\xa7\xe3\xad\x39\x48\x80\xfd\x3d\x9e\xab\x28\x49\xe6\x24\x8f\xe4\x19\xe9\x03\xa7\x10\xd5\x5e\xf1\xde\x26\x1d\x2a\x76\x4b\xa6\xbc\x1a\x57\x5f\x32\xf1\x0b\x4d\xbe\x04\x44\xd2\x51\xd4\x73\x00\xed\x60\xee\x45\x34\x05\x45\xd3\xf2\xd0\x93\x08\xf7\x4c\xe8\x67\x93\xc9\x61\x36\x2f\x6f\x04\x1f\x0b\x35\x25\x94\x82\xff\xb2\x32\x5f\x19\xdf\x10\x56\xb9\xb0\x93\xb4\xb7\xd9\xef\xcf\xe7\x5b\xfd\xfe\x1e\xcb\x5f\xd1\xc2\x11\xef\xc7\xe3\x19\x93\x45\x7b\x33\xa1\x70\x2c\xc9\xdf\x01\xd1\x34\x3b\x14\x61\x8a\xe8\xaa\x22\x9a\xd0\xd1\x3b\x49\x12\x97\x53\x8f\xb4\x02\x98\x91\x4f\x01\x86\x77\xa1\x0f\x8d\x48\x10\xae\x7f\x64\xf4\xb4\xd4\x3a\x5f\xa5\x1b\x5f\x0b\x49\x84\x1b\x84\x20\xdc\x60\x1f\xd6\xfb\xcb\x6e\x03\xa4\xab\x3f\x03\x53\x6b\xdf\x80\x59\x6f\x3f\xf9\xf4\x3b\x43\xed\xfa\x43\x1b\xcf\x27\xdd\xa9\xd0\xd9\xf6\xb3\x33\x45\xb4\xcb\x6d\xdc\x99\xd1\x19\x2a\xe8\xce\xae\x8d\x32\xea\x1f\xb9\x3e\x48\xd7\x18\x76\x2f\x94\x18\x0b\xa9\x23\x3e\x99\x1a\x05\xe9\x2f\x30\x7b\xd5\x0d\x5e\xd2\x6e\x97\x48\x37\xa3\x7e\x53\xf2\xd2\x68\xb9\x78\x1c\x98\x05\x59\x08\xd7\x7f\x39\x2c\x94\x95\xa9\x90\x63\x22\x23\xa2\xe9\x88\x34\xe0\xe3\xbc\x88\xa5\x16\x52\x6f\x18\x0c\x1c\x0c\x39\x04\x83\xba\x87\x4f\x95\xad\x22\x5d\xee\xc7\x4a\x13\xbc\x17\x53\x73\xcf\x55\xfc\x58\x28\xf0\x7c\x4f\xb8\x3e\xf0\x86\xbd\x20\x5c\x6e\x24\x40\xa1\xf9\x7e\x33\xa6\xa7\xc2\x9b\x30\xc3\x15\xce\xb1\x6f\x46\x2c\x09\x90\xae\xbf\x0d\xd2\x0d\xde\x98\x7f\x9e\xd5\xb6\xb1\xad\x57\x79\x63\x91\x2c\x64\xcc\xb7\x05\xbf\x98\xdd\x32\x33\x72\x2b\xc1\xaa\xca\x23\xe5\x86\x13\x7e\x36\xf5\x8c\x04\x58\xeb\x53\x3a\x44\x1d\x7f\x3e\x3f\x24\xd9\x39\x61\xc4\x1e\x52\x88\x19\x09\x98\x26\xa8\xe8\xbb\x1c\x42\xc6\xc9\x14\x62\x0a\x3e\x6b\xe0\x23\xf5\x10\x9b\x4f\x32\xdf\xce\x9f\x30\xfe\x26\x71\x79\xb7\x4b\x88\x66\x7a\x3e\x7f\x48\xe9\x89\x38\x65\x89\xcb\x89\xc0\xd0\x34\x53\x83\xfd\x2d\x49\x52\x09\x39\xd0\x29\x89\x60\x5a\x19\xd4\xd4\xf6\x15\x64\x31\x82\x31\x85\x90\xc4\xc6\xf2\x00\xa3\x50\x28\x12\x41\xe0\xfa\x90\x90\xb8\x3c\xa3\xab\xbf\x05\x7f\xf4\x70\x1d\x2b\x3d\xf5\xfc\xd4\x7b\xb0\x62\xe6\x93\xc4\xa8\xa1\xbc\x8f\xbf\x2b\x03\x12\xec\xe1\x0c\x9d\xa4\x76\x8e\x52\x48\x98\x74\x03\xe0\x4c\xba\x63\x08\x98\x74\x05\xa0\x3d\x5a\x84\x33\xbb\xe7\xec\xb9\xd9\x81\x3f\x4a\x2f\xfb\x5a\xf5\xb6\x04\x96\x48\x78\xe8\x78\x3b\xe0\x37\x90\x8b\x74\x79\xed\x7c\xd7\xed\x8c\x6e\x09\x07\x81\xaa\xa5\x17\x74\xbb\xd1\xe8\x0e\xaf\x13\x29\x37\x02\xe5\x5e\x98\xb7\xb7\xf8\x22\x18\x29\xd7\xc8\x51\xf3\xca\x90\x82\xa1\x1d\x6a\x95\xa1\x3f\x7f\x57\x19\x52\xee\x19\x59\xd4\x85\x5a\x14\xea\x19\xf9\x28\x41\xba\xe7\x90\xe9\xac\xaa\x4e\x7d\x7f\xad\xbe\x0f\x82\x9a\xec\xa5\xa7\x60\x62\xb4\xd9\x52\x31\xfa\xbe\xa8\xce\x5e\x99\x72\x14\xef\x6a\x95\x1e\x2b\x3d\x09\xf1\x82\x77\x5c\xa9\x7a\x30\x77\x25\x32\x0c\x63\x13\xb5\x22\xeb\x7d\xc0\x5d\x66\x34\x72\x30\xbf\xf1\x24\x37\xfb\x2d\xa9\x51\x31\x4f\x92\x53\x33\x44\x27\xbc\x73\x80\x7b\xe2\x24\x39\x9d\xcf\x1f\x22\xaf\x03\x17\x5e\xa7\x7e\x9b\x4d\x95\x9b\x38\x33\x24\x55\x61\x48\xe6\xfe\x25\xe5\x5e\x02\x67\x24\x64\x09\xf8\x4c\xc0\x8c\xc8\xd1\x27\x79\x12\x9e\xba\xc2\xb3\x7f\xc3\x9a\x9c\x2a\x4f\x62\xfc\xa1\xc2\x30\xdf\x9f\xd4\xa8\x89\xd7\x15\x96\x22\x8d\xde\x34\x29\xe3\x42\x51\x9f\xd3\x27\xc9\x29\x23\x11\xe3\x66\xfb\xc6\x18\x5f\x44\x2b\x78\x83\x1c\xc5\x6e\xc4\xce\x49\x04\xb1\x1b\x51\x2f\x76\x2f\xb2\x1f\x17\x14\x62\x5a\x38\x60\xcb\xe8\x63\xe5\x5e\x0d\x03\xd7\x1f\x06\x2c\x70\x7d\x8a\x63\x35\xbb\xce\x8c\x36\xeb\x78\x58\x73\xf5\x22\x1a\xd9\x9c\xb8\x31\x68\x78\xb8\xf6\x94\x2b\xe1\xa7\x27\x52\x4b\x94\x11\xc4\x10\x82\x5f\xb9\x6f\xa8\xcc\x90\x3f\xc9\x13\x79\xda\xed\x1e\x92\x2d\x5b\x2d\x69\x5b\xf7\xb5\x5a\xac\x2e\x57\xf9\x1e\xd2\xc0\xd9\xc9\x29\x04\x0c\x21\xb9\x0a\x22\x46\x34\xeb\xc3\x02\xa9\xdb\x69\x9d\x0a\x7d\x6c\xc5\x0a\xa9\xf2\xfd\x9c\xfe\xa1\x14\xbe\x95\xe2\x60\x22\xb8\xca\x9b\x29\x74\x96\xe7\xb5\x6c\x9f\x3e\x8b\xc0\x3e\x05\x0b\xf6\x61\xa1\xcc\x67\x41\xdb\xb4\x94\xa3\x1c\x84\x31\x17\x8d\xc4\xe3\xb4\x88\xc5\xcb\x75\xa3\x04\xef\xc2\x24\xa7\xa4\x98\xef\xb5\x28\xa5\xf0\x60\xb4\x9d\x40\x45\xbe\xa8\xf1\x12\x9e\x1b\x27\x29\x24\xb2\xb9\x8a\x1d\x3f\xe1\x8c\x67\x67\x58\x94\x56\x22\x82\x86\x6a\xaf\x3f\x9f\x73\xd4\xd5\x02\x41\x14\x0c\x68\xa6\x93\x07\x6a\xd8\xc2\x4b\x9a\xfc\x38\x18\x13\x4e\x73\xab\x31\x52\xcc\x49\xe4\x58\x84\x91\x14\xe3\xd2\x31\x39\x8e\x03\x3c\x02\x1c\xe5\x0f\x5e\x95\x1d\xc7\x2a\xb7\xf3\xf8\xf5\xb5\x90\xe3\x17\xe7\xd1\x64\x6c\xa6\xbd\x49\x7a\xda\x5d\x26\x5c\x19\x8f\xc5\xb0\x3c\xab\xe3\x4a\x48\x7d\x10\x8f\x45\x7e\x08\x6a\x81\x1c\xaa\xea\x61\x28\x7d\x48\xa9\xd1\xd5\x1f\x6a\x5c\x24\x54\x4d\xe6\x39\x3a\xfc\x6a\x94\x59\x3d\x46\xfa\x45\x38\x63\xbf\xb2\xfe\x0f\x39\x5f\xe0\x43\xd1\x63\x89\xeb\xcf\xe7\x7d\xc8\x42\x12\x93\x32\x58\xb2\x57\x06\x1b\x22\xeb\x0c\xbc\x00\xc6\xde\x33\x85\x77\xa6\x3c\x0d\xa1\xc7\x8d\x0e\x82\x2a\x00\xc9\xe4\x39\x4c\xff\xaf\x20\xf8\x7b\x28\x6e\xfe\x16\x8a\x48\x15\x37\x2b\x38\xfb\x36\x5c\x78\x12\x05\x85\xef\x0d\x7a\x44\x61\xe7\xb4\xb6\x40\x13\xb5\xd0\x66\xc7\x08\x15\xb8\xf2\x14\x5c\xe6\x62\x3b\x6d\x61\x21\x13\x45\x4e\x24\xa8\xd3\x06\xc5\xca\x9a\xbc\xf9\x11\xae\x6a\xf7\xf3\x64\x30\x40\x37\x41\xc9\xaf\x33\x1a\x48\xd0\x51\x6c\x85\xc6\x57\xc0\x01\xd1\x04\xa9\xbc\xe6\x88\xb0\xce\x55\x5b\x98\xc8\x32\x38\x48\x9a\x00\x56\xaf\x3f\xa6\xbf\x71\xa0\x5a\x03\x08\xbc\x09\x64\xfd\x46\x64\xfa\x5b\x47\xae\x0b\x60\x21\x68\x02\xbc\x78\x47\x12\x41\xff\xc6\x89\xec\x12\x70\x88\x9a\xc0\x2f\x5f\x9a\x4c\x17\xce\x6d\x43\xf0\x61\x0a\x37\x30\x81\x31\x74\xe0\x1c\xae\x6a\x5d\x2c\x95\x36\x75\xa2\x98\x0f\x9a\x4d\x41\xb0\x1b\x48\xd8\x04\x38\x33\x1a\x64\x07\x22\x76\x0e\x31\xbb\x82\x27\x8c\x31\x22\x59\x48\x9b\xee\x68\x42\xdc\x76\x4b\x93\xc4\x59\x4c\xdf\xe2\xc9\x72\xda\x1e\xdd\x6f\xf4\x19\xde\x77\x2a\x5a\x13\x85\xab\x15\xbb\xd0\xe1\x83\x6a\x65\x38\x5b\x59\x77\xb3\x56\xf7\x7a\x65\xdd\xad\x6a\xdd\x86\x60\xeb\x4a\xd5\x6d\x53\x55\x41\xec\x3d\x84\xd8\x42\xa7\x35\x36\x30\xab\xf0\x69\xc7\xc8\xbb\x6b\xed\x30\x26\x47\xce\xb5\xe3\xc9\x96\xfd\x6f\x26\x01\x9d\x58\x9d\xd1\x8c\x9c\x2b\x30\x0a\x0a\xd1\x4c\x42\xc2\xbe\x47\x18\x02\x14\xe3\x4d\x3c\xe1\x76\x80\x7b\xc9\xe8\x96\xfc\x15\x41\xb2\xb7\x35\xba\x53\xde\xa5\x82\x1f\xc6\x50\xc7\x83\x2b\x6f\x46\x5e\xe7\x47\x8a\x29\xa5\x5e\x16\xfb\x6f\x96\x23\xe3\x20\xb7\x0a\xee\x5a\x35\x99\x7b\x82\x8e\x24\x8a\x5e\xf5\x94\xc2\x65\xeb\x9c\x05\xc2\x90\x81\x1b\x08\x0a\xfc\xcc\x53\x2e\x3f\x03\xee\x9b\xbf\x7e\x6d\x32\x90\xeb\x56\xb4\xc7\x87\xb4\x72\xd7\xa0\xf0\xc4\x73\x74\xbe\x74\x20\x61\xda\x95\x18\x24\x1e\xe3\xf9\x2c\xdf\x74\xd6\x19\x13\xb9\xc9\xa8\x4e\xc4\xe9\x7c\x4e\xcc\x1f\xf6\x90\xd2\xa1\x59\x35\xc6\x98\xe8\x76\x9d\x60\xc2\xa7\x53\xf3\x23\x19\xbd\x50\x24\xb0\x57\x9d\x03\xa3\x7b\x72\xf4\xf8\xd9\x0a\x07\xfc\x4a\x14\x95\x14\x24\x70\x20\x09\x37\xb3\x64\x2a\xe2\x73\xe9\x6d\x29\x8f\x7c\x16\xb4\x77\x79\xa2\x4e\x87\xe6\x1f\x26\x46\xa2\xe7\xac\x39\x3d\xed\x55\xf2\x5e\x1c\xaa\xfa\x29\x43\x27\xf7\x55\x16\xf1\x88\xa6\x86\x7b\x89\x17\x6e\x2e\x99\x74\xaf\x08\xa5\xd9\xa9\x5c\xbf\x5a\x2d\x52\x6e\xa0\x04\xd7\xe8\x4d\x31\x2a\x83\xbd\xe9\x18\x85\x64\x1b\xab\x55\x0e\xd2\xa4\x7b\x89\xf6\xe0\xc5\xd0\x14\x09\xb7\x33\xa4\x4b\x87\xae\xc9\x28\x61\x27\x09\x08\xf7\xe2\xd4\x2b\x82\x86\x2e\x28\x5e\xd3\xbb\xcc\xce\x56\x1f\x2e\xbc\x04\xae\x3d\x95\xfb\xc7\x49\xc0\x0e\x15\x11\x60\x0c\x6e\x31\xb9\xfa\x21\x6e\x84\xd4\x3f\x8c\x4a\xf3\x43\x89\x90\x71\x08\xd2\x28\x24\x5b\x55\xac\x5f\x29\x62\xac\xd1\x73\x22\xdd\x33\x0a\x0a\xa4\x3b\xa6\x10\x0c\xed\x02\x4a\x37\x1c\x15\xc3\x7a\x35\x11\x46\xc5\x3a\x38\x22\xd2\x0d\x01\x23\x08\x16\xcb\x30\xae\x60\x18\xa8\x6e\xd7\xe1\x66\x0f\xb9\x41\xb7\x1b\x34\xb8\x16\x83\x49\x14\x5c\x3a\x10\x28\x12\x50\x0a\x06\x85\xac\xe7\x61\xf5\xac\x56\x40\xcc\xfa\xc3\x78\x2f\xca\x55\xd9\xb8\xd7\xa3\xb1\xa9\x7c\xa8\xc8\xc0\x0c\x62\x14\x9d\xc4\xa7\x9e\xf9\x07\xcf\x5d\x0b\x05\x37\xa8\x1c\x22\xa9\xa5\x73\x4c\x34\xe1\xaa\xee\xc2\xa1\x61\x53\x66\x21\x46\x47\x0a\xbd\xae\x5e\xb6\xbf\xc5\x68\xdf\x36\xc7\x57\x96\x78\x47\x17\x45\x9d\x6d\xfb\xe2\x20\x7b\x41\x9c\x1b\x3e\x49\x04\x6e\x81\xf9\xdc\x09\xce\x45\x70\x89\xda\xaa\xf9\x29\x4f\xc4\xe9\x3a\x63\x09\x7a\xa4\xd0\x7f\x51\x3d\xea\x3a\x5a\x20\xc2\xa9\x9e\x4d\x44\xeb\xad\xa3\xb2\xdd\x85\x5a\x50\xc3\x6c\xcd\xca\x2d\x82\xa1\x18\xa1\x23\xeb\x99\xd6\x2a\xf2\x13\x2d\x88\x4d\x6b\xe0\x2a\x71\x15\xdf\x88\xca\xeb\x2a\x3e\x07\xbf\x84\x0b\x46\x59\x0e\x81\x33\xe1\xc6\x43\xbe\xd0\xc7\xc1\x11\x49\x40\x63\xf6\x82\xc5\x7e\x6c\x51\xb5\xaf\xfd\xc5\xfd\x6a\x48\xf7\xf5\x14\xf7\x1b\x3e\x21\xef\xa8\x1b\xe0\x0b\xf7\x65\x8c\x71\x6d\x36\x1a\xb7\x51\x89\xf6\x5f\xf7\xa7\xdb\x61\x8c\x71\x34\xa5\xdd\x9f\x8c\x0f\x83\x58\xea\x48\x26\x22\xcd\xb1\xaa\x93\x65\x62\xf4\x83\x80\xbd\x34\xac\x86\x37\xfa\xc4\x13\x08\xe0\x56\x75\xbb\x0f\xd7\x7c\x3a\x8d\x6e\x84\xf7\x3d\x22\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\x41\xb3\x3b\x94\x29\x20\xf3\xc0\x03\x4d\xeb\x71\xb0\xdf\x23\xa2\x28\x72\x7d\x0e\x01\x4b\x46\x46\xae\x71\x97\x7b\xdc\x0d\x84\xc7\x21\x62\x03\xc3\xb1\xb9\xeb\x7b\x5b\x8c\x25\xdd\x2e\x37\xc2\x26\x66\x24\xea\x76\x0d\x65\xc7\xd7\x66\x14\xfc\x8c\x5b\x6c\x81\x6c\x2e\x55\xf7\xa9\xa9\x7a\xad\x90\x7f\xbd\x14\x21\x4f\x26\x9a\x50\xf0\xe9\x50\xb0\xd8\xbd\x18\xda\x3b\x75\xf9\x08\xca\x30\x29\x41\x8d\xd9\x1c\x50\x1b\x2c\xbd\x1c\x6a\x3b\x0c\x37\x36\x86\xa6\xce\x49\x78\x6a\xaa\xc5\x2c\x76\xaf\xd3\x98\xa0\xe2\x96\x8b\x92\xa9\xfb\x93\x49\x98\x96\x33\xf6\xae\xb6\x39\x4f\x8a\x4b\x7f\xf7\xb9\xdf\xa6\x4f\xab\x89\x94\x8e\xd5\xa2\x55\xf9\xd0\xf1\x14\x28\x4f\xc3\xd4\x13\xa0\x33\xd3\x02\x92\xdc\xc6\x28\xdd\xcf\x99\x65\x04\x95\x1b\xba\xf7\x15\x68\x51\x48\xf0\xe2\x43\x0e\x57\x1a\xed\xc2\x28\x21\x18\xdb\xbe\xce\x98\xa5\xff\x81\xe1\x33\xf3\xf9\x26\xbe\xa8\x3a\x55\x8e\x15\xd1\xd0\x07\x81\x21\x2a\xac\xd9\x5d\x64\xd8\xee\x6f\x26\x64\x30\x52\xb8\xc8\xac\x91\x19\x97\xd2\x35\xb6\x9b\x74\xc7\x20\x3c\x01\xa1\x67\x44\x85\xef\x49\xd7\x4f\x53\x4b\x34\x83\x34\x73\x71\xf1\xcc\xc1\xb5\x53\xf1\x15\x49\x77\x62\x43\xab\x21\x66\x41\x11\xe5\xc1\x62\xc6\x58\x21\x04\xc2\x6e\x37\x36\xab\x18\xb2\xe0\x24\x3e\x35\x25\x27\x31\x6e\xfe\x70\xe1\x5c\xd2\xc8\xea\x4b\x3a\x34\x0f\xca\x08\xed\xa1\x8d\xb5\xa9\xaf\x9f\x7b\x09\xca\xbd\x04\xdf\xac\x21\xb6\xeb\xef\xf9\xc5\x6d\x25\x9c\xaf\x01\x08\xf0\x69\x11\xd6\x97\x23\x3b\x35\xe2\x1b\x6e\x98\x72\x2f\x60\xc2\xd6\x07\x30\x36\xdd\xa1\x3c\x1f\x1b\x79\x3e\x61\xeb\x7d\x58\x12\xea\xd3\xd1\x94\x9d\x4c\x61\x6c\x84\xfa\xd4\x2e\xf7\xd8\x08\xf5\x31\x1b\xbb\x97\x05\x8f\xeb\x30\x95\x81\xea\xb4\x83\xba\x19\xdd\xb0\x93\x1b\xe8\x18\x50\x37\x16\x54\xc7\x80\xea\xb0\x8e\x7b\x99\x0f\x71\xd2\xed\xe6\xe1\xd1\xeb\x8c\xdd\xe4\xd7\x48\x16\xa9\xc1\x23\x64\x32\x6a\x33\xec\xfb\x43\xbd\x57\xa6\x80\xb0\x31\x15\xf2\x44\x1b\x69\x86\x71\x72\xcb\x01\x15\x64\x0a\x37\xd4\x9b\x32\xc6\x6e\xe8\x7c\x8e\xfd\x6c\x82\x80\x1b\x3b\xc5\x66\xde\x8d\xb5\xa3\x41\xf4\x06\x4b\x91\x48\xb8\x08\xd2\xe5\x18\xe1\xc1\xb3\x35\xd8\x42\xb7\x35\x5f\x0a\x6c\x42\x70\x3f\x8a\x1d\x02\x3f\x17\x23\x40\x97\x6a\x3c\xcf\x6b\x6c\x79\x78\xd8\x76\x8e\xfd\x9c\xb7\x6e\x13\x8c\x85\x66\x1f\x0c\xa5\x8c\x41\x19\x0d\x25\xa7\x8b\x6d\x10\x70\x9e\x85\x3f\x33\xe5\x46\x65\x08\x4c\x75\x24\x57\x59\xed\x1d\x10\x70\x45\x69\xd5\x63\x5d\xc1\x2a\xb1\x7b\x3b\x8f\xef\x31\xcc\x2f\x0b\xae\xc9\x05\x5d\x15\x03\x5e\xc1\x80\x1b\xeb\xbb\xb0\xef\x91\xed\x55\xd0\xaf\x5c\x80\xae\x0b\x59\xa3\x6f\xd7\xe3\xf2\xf0\x5a\xbd\xd1\x83\xd6\x19\x0b\x8c\xfe\xd6\x2f\x9e\xb6\x8a\xa7\x6d\x7c\x32\x35\x83\x8a\x42\x10\x31\x79\x12\x9c\x42\x6c\xd3\x94\x44\x8c\xb1\xb8\xdb\x2d\x75\x21\xd3\xb2\xa2\x0b\x05\xf3\x79\xa6\x5d\xe9\x6e\x97\x90\x84\x45\xd4\xc8\x69\xc2\x59\x4c\xdd\x0e\x86\x09\x15\x09\x26\xe6\x73\x42\x84\xd1\x9e\x1e\x52\x7a\x12\x9c\xb2\xd8\x0e\xb1\xf6\x4e\x8f\x32\xed\x4d\x8f\x1c\x27\x57\xdc\xb4\xe9\x64\xcb\xbe\xb5\x5c\x16\x8d\xbf\x93\xe0\xd4\x0d\x21\xce\x19\xaf\xb7\x7c\x2d\xfb\x24\x38\x35\x60\x8c\xe4\x45\x21\xf2\x60\x05\x88\x99\x3e\x33\x46\x33\x42\xd3\x33\x04\xd4\x30\xa2\x3a\x76\x21\x4d\x8b\x90\x3e\x3b\x3d\xf8\x47\xd6\x46\xe1\x1b\xbe\xe9\x57\xd3\xd8\x14\x6b\xf4\x73\x49\x70\x18\x66\x6c\x18\xbc\x30\x72\xb6\xbc\xb3\xc6\x8b\x50\xa8\xbd\x60\x84\xcb\xbd\x0b\x02\x1e\x6e\xbc\x08\x22\x2f\xd8\x88\x52\xea\x05\x7b\x51\x46\x25\x8f\x6d\x51\x00\xc2\xe3\x15\x3d\x2a\x66\xc1\x5e\x34\x0a\xbc\x28\x0f\x85\xb4\x31\x90\x96\x47\x26\x27\xe1\xe9\xf0\xde\x28\x0a\xfc\x24\x3c\x05\x0d\xbd\x9e\xbd\x33\x69\x7d\x78\x15\x22\x7e\x5e\xc1\xb9\x9a\x56\x05\x38\x33\xb3\x64\x9e\x72\x55\xde\x0c\x23\x2c\xf8\x38\xf8\x2c\x8f\xbe\x84\x29\xeb\xc3\x0d\xeb\xc3\x84\x89\xe1\x74\x2f\xec\x76\x6f\xf6\xfc\xec\x3c\x7f\xcc\xc8\x21\x8b\x4e\xa6\xa7\xd4\xe5\xd0\x61\xe4\x15\x8b\x4f\x6e\xf0\xc7\x39\x3b\x74\x7d\xb8\x62\xaf\x5c\xdf\x70\xff\xf1\x3a\x63\x1d\xdb\xe6\xcc\x34\xe8\x0d\x4e\xe1\xda\x54\xee\x0d\x50\x3a\x9c\x51\x53\x34\x63\x67\x2e\x87\x5b\x76\xe6\xfa\x70\xc7\x8c\x7a\x38\x33\x85\xd7\x58\x78\xc9\xae\x5d\x0e\xcf\xd8\xb5\xeb\xc3\x0b\x36\x66\x8c\x5d\x9a\xc2\x17\xdd\xee\x1d\xbd\x57\xe4\x1c\x9e\x41\x02\xbd\xde\x84\xc2\x6b\x85\x89\xef\xc6\x70\x05\x37\x46\xab\x9b\xf4\xd8\xb9\xf5\x6e\x7e\xcc\x4b\x6e\x6d\xcd\x49\x8f\xdd\xda\x92\x69\x8f\x6d\xc2\x4d\x8f\x6d\x5a\xe5\xc4\x00\xa6\x93\x5e\x2f\x87\xd5\xc9\x61\x15\x3d\x4d\xaa\x70\xa7\x3d\x36\xa8\xb7\xbe\xa3\x45\x5f\xe7\x45\x5f\x59\xed\x7b\x45\x6e\xe1\x2a\xc7\x76\x19\x87\xc1\x30\x0f\xe8\x59\x3f\x9b\xcf\x67\xeb\x8c\x5d\x66\xd7\x59\x16\x61\x2e\x62\xb7\xd0\xc7\xb3\xf6\x3e\x36\x53\xcb\x8e\x70\x3c\x55\x5c\x8a\x11\xf5\xe0\xa6\xd7\xc3\x2d\x63\x56\x3d\x5b\xf0\xc3\x1c\x85\xca\xba\xdb\xa5\x5e\x6e\x6f\xdb\x96\xc4\xf2\x0a\x8e\xd8\xd1\x7c\x7e\x72\x3a\xcc\xd0\xae\x90\xcb\x2b\xd7\x87\x4c\xf1\x3a\xa2\xd8\x31\xe9\xef\xe5\x7b\x6a\x3e\xef\xef\x05\xc5\xf3\x11\xcd\xb6\xce\x13\xb3\x75\x6e\xbd\x04\xee\xbc\x00\x66\xde\x51\x76\xfe\xf4\x46\x31\xe7\x87\x98\x5c\x7d\xdd\x7d\xfe\xae\x92\x67\xf3\xb5\x6a\x3a\x36\x37\x92\x12\x63\x5a\x82\x5c\xc6\x64\x47\x2c\x0f\xca\x4b\xe0\x99\x17\xb0\x87\xc0\xeb\xc3\xbd\x27\xc0\xbc\x98\x16\x8e\xe7\x4c\x1f\x31\xed\x59\x80\xaa\xb8\x31\x79\x03\x37\x28\x0e\x69\x72\x08\x29\x85\xc0\x0d\xd8\x66\x76\xf2\x5e\x53\x70\x02\xf7\x1e\x04\x44\x10\xb8\xca\xd4\x52\x2c\xb1\x60\x03\x77\xea\x4e\xd9\xc3\xad\x17\x59\x08\x69\x8e\x7d\xef\x8d\xca\xbd\xb0\xc5\xc8\x3e\xd6\x24\x95\x15\x48\xf9\xb8\x78\x11\xd1\xc5\x2d\x6a\x39\x22\x41\x1d\x11\x01\xdc\xbd\x87\x00\x92\x4c\x09\x38\x36\x56\xd6\x53\x48\xcc\x04\x07\xf0\xcc\xf0\xa6\xf4\x63\x1d\x07\xcb\xec\x33\x11\x53\xd4\xcf\x0f\x00\x70\x62\x1e\x02\x6f\x50\x99\xbb\xa8\x2a\x5f\xdf\x57\x58\xd3\x7a\xe5\x48\x7d\xc1\xe1\x6b\x99\x21\x5a\x90\x96\xd7\xc7\xae\x8d\x3a\x1a\x1a\x11\x9c\xdf\x0b\x36\xdc\xaa\x93\x2f\x82\x4f\xdf\x1b\x6c\xb4\x7b\x09\xb1\x3b\x85\x88\x16\x9b\xf2\x09\x96\x3e\xc4\xae\x66\x0a\x62\x37\x61\xd1\xd0\x2a\x8b\xb1\x3b\x75\x6f\x87\xfd\xbd\x69\xa1\x5c\x5a\x44\xa6\xd0\xcf\x1d\xc7\x39\x8c\xa7\xcd\x30\x6e\x0c\x0c\x83\xc1\x0d\x7d\xb8\x71\x9f\xb9\x53\xa6\x32\xd8\x37\xbf\x82\x6c\x41\x57\x01\x1a\x82\x24\x66\xd4\xbd\x1e\x9e\xef\x12\x1c\x36\xfd\x77\x41\xa4\x09\x52\xfa\x84\x69\x3b\x6a\xa3\x8b\x4e\x4a\x0e\x3f\x66\xba\xaa\xeb\x5a\xed\xb5\x3c\xfe\x80\xb1\x9d\xe0\xde\x00\x02\x50\x0d\x9e\x28\xbb\x8f\x3a\x4c\xbb\x22\xd3\xb0\x94\x1b\x9c\x47\x93\xf1\x41\x3c\x16\xd3\x42\x46\x5d\xb1\xfe\xf0\x6a\xaf\x93\x4b\xbb\xab\x5c\x40\x9d\x19\x0b\x93\x4d\x46\x9d\x93\xab\x53\xcf\xfc\xe3\xfa\x70\xcd\x7a\x3d\xde\x23\x67\xf6\x9c\x07\x29\x73\x8f\x85\xdd\x6e\xb8\xc7\xae\x31\xe7\x9a\x24\xe7\x27\x57\xa7\x70\x96\xad\xfd\x35\x44\x14\xec\x1c\x2c\xcc\x40\x31\x05\x43\xce\xae\x8b\x6b\x7b\x69\x6e\xeb\x41\x1f\x94\xeb\x43\x35\x1f\xe4\x57\xb5\x74\x26\x83\x9e\xc1\x5c\xdd\x96\x1e\xa9\x10\x23\xbc\x55\x78\x65\xb7\x02\xe0\xed\xa2\xbb\x05\x95\x6e\x55\x55\xba\x17\x5d\x2f\x1a\x38\xfb\xac\x48\x82\x89\x9f\x18\x63\x12\x73\x25\x95\x0e\xd1\x4a\xf8\xf1\x67\x55\xbb\x5d\xa5\x2a\x41\xea\x4b\x07\xb0\x75\x47\x4c\x79\xfc\x09\x09\x3b\x44\x9a\xa7\xc3\xa4\x61\x41\xe7\x73\xd2\xf4\xda\xfa\x72\x16\x17\x7f\x28\xba\x5d\x63\xad\xca\x6e\x77\xe1\x58\x35\x01\x59\xc9\x52\x85\x11\x00\x53\x50\x6e\xb2\x70\xa9\x2a\x73\xea\xb9\x89\x29\xa7\xb0\x18\x40\x20\x73\xa0\x2f\xb9\xe6\xa4\x0f\xc5\xed\xff\x6a\xed\xc2\x86\xb0\x73\xef\x4e\x17\x2d\x87\x26\xd4\x47\x4d\x2f\xdd\x0b\xa6\xdc\xa9\xd7\x54\xc4\x1e\x2e\x3c\x33\x84\x6b\x4f\xb9\x49\x9a\x77\xbd\xeb\x55\x63\xe0\xa6\x59\xea\x4a\xed\x46\x18\xb1\x9e\x3b\x8f\xec\x8c\xc8\xca\xbe\x38\xd1\xee\x4d\xa9\x38\xca\xfc\x16\x40\xa9\x76\x11\x84\x47\x51\x69\xac\x35\x14\xcc\x34\x1d\x8a\x42\xe0\x65\x3d\x45\x72\x2a\x94\x7e\x2e\xc2\x58\x09\x72\xa8\x48\x82\x61\xf2\x6e\x42\x81\x2f\xf6\xf3\xd4\x43\x9e\x61\x7b\xa0\xa5\xc7\xa2\x7a\x40\x5e\x41\xdb\xcc\xb3\x95\x02\xda\x7d\x56\xb5\x88\xd6\xfa\xc6\x06\x70\x15\x3a\x78\x5a\x1b\x07\xee\x94\xd9\x6d\xe2\xde\x16\x4b\xf6\xa4\x89\x5c\xcb\xcc\x02\x66\x22\x97\x83\x76\xf3\x50\xd2\x4a\x20\x69\xe1\xb5\x7e\x99\x45\x0d\xbc\x56\xfc\x0c\xdd\xd7\x45\x1a\xd1\xea\x34\xe5\xba\x78\x1e\x57\xfa\x6c\x18\xa3\x45\x6b\x45\xde\x88\xbb\x53\xef\x50\x11\x23\xdd\xcc\xcc\x55\x23\xd0\xb4\x3b\xb3\xe9\x9b\x8a\xa1\x94\x6e\x4c\xa6\xdd\xbb\xec\xf2\x4c\xb1\x28\x95\x3b\x34\xc9\x09\x37\x9a\x73\xe0\x3e\x83\x98\x6d\xa2\xff\x23\x18\x45\xb6\xab\x28\xeb\x6a\xb8\xb0\x80\x31\xd4\x16\x3d\x70\xd5\x29\x4d\x45\xb7\x8b\x71\x10\xa2\x12\xf6\x83\xb3\xb3\x70\xe3\x4f\xb9\x53\x22\xe9\x70\x6c\x9d\x6d\xde\x21\x19\xf4\xab\x4e\xda\x2f\x2a\x0b\x5f\xb7\x29\x72\x0d\x81\x1f\xcf\xae\x45\x4e\x08\xa1\x31\x4f\xb5\xb8\xd3\x59\x80\xa4\xd5\x57\xd6\x5b\xaa\x3a\x0e\x1d\x2e\xa6\x98\xe4\xb9\x83\x78\xba\x2a\xb0\x77\xa8\xd8\x39\x99\x91\x6b\x05\x89\x2b\xf9\x95\x80\xc4\x45\x3b\x13\xb3\x0d\x65\x8a\x89\xab\xf9\xd9\x01\xbf\x12\xae\x8e\xdf\xc5\xb7\x42\xbd\xe0\x53\x41\x68\x76\x62\x2a\x17\xe5\x8c\x28\x3d\x4b\xc2\x3a\x07\xcf\xc9\x17\x45\xa2\x13\x71\x4a\x8d\x95\x57\x1c\xa2\xfb\x0a\x38\x28\x08\x6a\xe1\x23\x0a\x24\xe8\xca\xb1\x31\x86\x4e\x46\x46\x40\x6c\x83\x72\x83\x37\xe6\x9f\x4a\xf0\x25\xe6\x32\xcc\xc3\x22\x82\xb7\xc0\x59\x84\xf3\x03\x01\xfb\xa2\x48\xb9\xe7\xfe\x56\x0b\x77\xed\xed\x4c\x25\x98\x26\x91\xbd\xc3\xf3\x12\x3a\xe4\xec\xab\x51\x73\x03\x2b\x55\x02\x86\x81\x74\xd9\xa9\xe1\xb7\x5a\xc4\x80\x45\x53\xd4\xd1\x14\xad\x68\x26\x39\x9a\xc6\xf6\x7c\xdf\xed\x2a\xf7\x3d\xc1\xb4\xa4\x88\x74\x64\x36\x90\x8e\xf4\xc4\x18\x75\x91\xc2\x58\x62\x08\xcd\x00\xe2\xf6\x01\x04\x8a\xf1\xa1\x1d\x45\x60\x47\xe1\x2b\xe2\x98\xa6\x0e\x25\x1d\x4a\x94\xeb\xbf\x34\xbb\xef\x9d\x22\xa1\x11\x32\xb1\x19\x5b\x0c\x21\xea\x81\x10\x32\x0d\x81\x62\x7d\x88\xd0\x5d\x13\xbc\xea\x76\x49\x8e\x04\x8b\xf0\x0d\xb5\x83\x87\x4f\xcd\x91\x42\xca\xc6\xf1\x3e\x93\xd1\x15\xfa\x9d\x5f\x2b\x7e\x25\x46\x8d\x6f\x6b\xc1\x4e\x95\x30\x2f\x09\x03\xb1\xf5\x68\xb7\x4f\xab\x11\x9f\xca\x06\xf4\x0a\xa2\xf3\xb8\xeb\xca\xed\x16\x4e\xe8\x43\x82\xba\x4a\x32\xea\x7b\xe4\x93\x59\x62\x30\x55\x61\x50\xb0\x89\x3a\xc7\xd2\x4c\x82\x1a\x11\xac\x63\x76\xbd\x4d\x17\x3b\xa0\xd4\x43\x15\x3b\xe9\x76\x2d\x90\x84\x6d\x56\x77\xe7\x9f\xaa\x12\xd7\x1b\x9b\xa9\x99\xc4\x01\x8e\xc8\x3d\x37\x12\xd7\xe5\xf3\xf9\x21\x19\xd0\xb6\x68\x96\x19\xf9\x33\x82\xbf\xa3\x5a\xa4\x1b\x7d\x50\xdd\xee\x79\x34\xd5\xb1\x9a\xb9\x67\x31\xde\x7a\x22\x36\x3f\x27\x8e\xf4\xaf\xd6\x43\xe9\x66\x68\x39\x28\x63\xba\x1c\x69\xae\x05\x9e\x61\x38\x50\x81\x0b\xdf\x55\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\xbb\xaa\x45\x2c\xd4\x35\xc7\x37\x92\xd4\xc7\x58\x31\x5d\x24\x7d\x78\x2e\x89\xc0\xc8\xb8\x82\x6f\x2f\x1d\x1d\x69\x90\xf5\x53\x2a\x4c\xfe\x55\x5d\xd8\xc6\xf3\x29\x6d\x3f\xe3\xd0\x9e\xa0\x25\xbb\xa5\x5f\xb9\x54\xa0\xe9\xe8\x42\x13\xed\x72\x4c\xd5\x51\x8d\xa0\xd5\xd5\x40\xf7\xc5\x4b\x37\x9f\x54\x75\x7c\x18\x83\xc2\xf2\xe9\x73\xcf\x84\xce\x4e\x93\x9f\xcf\xf6\xc7\x78\x89\x81\xc8\xd1\xbb\x6c\xd8\xde\xb1\x24\x9f\xa2\x22\xc7\x07\xf2\x7c\xad\xeb\x41\xca\x95\x28\x42\xbd\xc0\x86\x72\x11\x78\xa2\x4e\x09\x85\xe3\x55\x61\xca\x9a\x35\x84\x76\x69\x77\x1a\xa8\x78\x32\xb1\xe9\x73\x8e\xd3\xc5\xd8\xd0\xfa\xc8\x30\x1a\x54\x13\x5a\xb9\x1b\xa6\x57\x04\xab\xb4\xa3\x9b\xf5\xfa\x4e\x84\xc6\x84\xcb\x7f\x1e\xc7\xd7\x4c\xaf\x1e\x84\x5c\x9d\x62\x6b\x55\xe1\xff\x5c\x91\x22\x52\xed\xed\x35\x25\x1a\xcb\x4b\xff\xfd\xef\xd5\xa5\xa6\xb8\x2d\x16\xb4\x4e\xfb\x96\x36\xa6\x42\xef\x4b\x2d\xd4\x0d\x9f\x54\x0b\x9f\x4b\xa2\xf1\xce\x4d\x5b\xa4\x6d\xd1\x48\x66\xf7\x30\xd0\xae\xd1\x90\x68\xe0\x1a\x02\x0d\x91\x86\x58\x43\xa8\xc1\xd7\x30\xd5\x6c\x79\xea\xcb\xb8\x4d\xb8\x69\x29\xdf\xcc\xca\x27\x2d\xe5\x5b\x59\xf9\xb8\xa5\x7c\x3b\x2b\xef\xb4\x94\xef\x64\xe5\xe7\x9a\x3d\x74\xbc\xdd\x14\xae\x74\x4b\xbe\xb3\xac\xc9\x37\x4f\x01\x0f\x3c\x0d\x7c\xec\x25\xc0\x85\x27\x20\x78\x81\xb9\x5a\xe0\x4c\xaf\xc8\x32\x46\xcc\x74\x62\xf6\x15\xcd\xc6\x30\xd3\x8c\x88\xea\xb5\x95\xca\xcd\x06\xe5\x06\x98\x9c\x70\x0c\xbc\x4d\x06\xdc\x92\x6b\x0d\xd2\xed\x8c\xb4\xc7\x31\xb6\x83\x9b\xf9\xaf\x16\x72\xc0\x3f\x06\x70\x42\x6d\x5e\xa8\x01\x85\x5b\xcd\xfa\x70\xa7\xd9\x15\x5c\x6a\xb6\x09\xcf\x9a\x10\x46\xe7\x8c\x3d\x03\xde\xd8\x44\x3b\xbb\x53\x4f\x9d\x6a\x14\xc8\x31\x24\x4c\x02\x67\xb7\xa8\x79\xfb\xa0\xdd\x00\x6e\xc9\x33\x1c\x07\x68\x57\x60\x5e\xdd\x04\x14\xe3\xa0\x99\x30\x93\xf3\xa2\x69\x01\xd6\xb0\x4d\xeb\xa4\xcd\xc8\x9d\x06\x9b\xa2\xd6\x26\xe1\xea\x18\x26\x0a\x87\xff\xbb\xa0\x64\x15\xca\xab\x46\x28\x87\x98\x2a\x13\x8e\x34\x3b\x80\x8b\x5f\xd0\xec\x01\xd2\xcc\x20\x85\xfd\x7a\x45\x3c\x6c\xf2\xab\xb7\xd9\x64\x25\xaf\xc1\x81\x4e\xe1\xa5\x6e\xcf\xc4\xd9\x19\x1d\x68\xcf\xb4\xb1\x01\xe7\x29\x85\x77\x8d\x98\xca\xba\x06\x9e\xc2\x71\x2b\x50\x1b\x33\x0b\xf7\xcd\x70\x52\xf8\xa1\xd9\x3b\xf8\xb0\xdc\x5c\x7a\x8b\xc4\x50\x5e\xcb\x5f\x3b\xd0\xc3\xdc\x36\x0c\x30\x17\xec\x18\xa9\x56\xe4\xb7\xf5\x67\xe4\x07\x92\x83\xeb\xd3\xc2\x21\x22\x8d\x02\xc6\x44\x11\x2a\xb2\xb6\xe8\x2e\xb8\xc0\x44\x9c\xb9\x99\x64\xab\x27\x95\xea\xa9\x21\xa5\x9f\x2b\x67\x4f\x7a\xca\xe5\x29\x85\xe7\xba\xed\x72\x4d\xc3\x24\x68\x32\x23\x3f\x35\x74\x60\x46\x3e\xd8\x8f\xa0\x60\x74\x3c\xbc\x69\x9c\xb2\x19\x79\x6e\x86\x36\x23\x67\x1a\xf6\x35\xbc\x34\xad\xcf\x34\xbc\xd3\x70\xa4\x89\x13\xf2\xc9\x54\x38\xd4\xfc\x5f\x0a\xaf\xdb\x71\xb5\x49\xd1\x3e\x6a\xf6\x27\xbc\xff\xc5\x46\x5c\xd7\x8b\xf9\x8b\x05\x26\x95\xb7\x9b\x10\x3f\x0a\x91\xe7\x32\xae\x6d\xba\xaf\x2d\x3b\xe5\xbd\x86\x3b\x9d\xed\x83\xb7\xba\x31\xfa\x39\x0a\x89\x28\xc3\xcc\x85\xcb\x31\x18\x09\x0f\x83\x78\xfe\x3e\x60\xdc\xe5\x78\x62\x86\xef\xa3\xfc\x7d\xcc\x22\xbc\x91\x16\xd9\xf7\x61\xfe\xde\x67\x61\xf9\xad\x10\x83\x75\x02\xe6\xdf\x00\xff\x8d\xf1\xdf\xd0\xe5\xb0\xd3\xef\xef\xe9\x11\x62\x69\xd0\xb1\x59\x37\xbc\x3b\xf2\x36\x63\x2f\xbd\x01\xf8\x76\x7a\x5b\x41\xa9\x96\x52\xb5\xf8\xba\x9e\x46\xf7\xf3\x0a\x0e\x5e\xf4\xdf\xb7\x5c\xe4\x4b\x6d\x65\xab\x29\xf9\x6f\xc9\x67\xdd\x26\x9f\x91\x0f\xd9\x94\xeb\x05\x2b\xa2\xf0\xed\x17\x42\x27\xf1\x04\xdc\x7a\x1a\xb4\xa7\xc0\x57\x78\x64\x82\x12\xe7\x53\x2b\x75\x5d\x92\x6f\x1a\x94\x7b\x07\xca\x35\x7f\x6f\xd1\x9f\x67\x58\x8a\x8f\xc9\xa1\xe0\x6f\x5d\xbf\x83\x20\x8b\x13\x95\x25\x71\x5f\xb9\x03\x77\x87\xce\x04\x0d\x82\x49\xf7\x16\x63\x2c\x93\x72\x39\xbf\x68\xf8\x64\x58\x9d\xaf\x28\x04\xc4\x22\x50\x9c\xd7\xd8\xed\xf4\xe7\x8a\x9d\xeb\x8f\x70\xde\xee\xec\xf6\xf3\x8c\x8e\xf3\x57\x6b\x75\xcd\xb0\x3f\x94\x0c\xd8\xec\x4f\x43\xce\xba\xd0\x02\xe1\xfb\x72\xd3\x2c\xfa\xcf\xf0\xaa\xa6\x31\x16\xe3\xf8\xcb\xe0\x9c\xdf\x8f\x01\x29\xda\x0d\xb1\xef\x06\x03\x62\x94\xc6\xa6\xc9\xba\x2d\x33\xe0\x9e\xe0\x6c\x98\xf9\x33\xb3\x67\x04\x76\x02\xe8\x3a\xf5\x15\x25\x98\x5c\x94\x62\x46\xb3\x02\x7d\x25\xd8\x05\xe8\x8a\xc7\xad\xe1\x4b\x52\xab\xd7\x05\x9d\x94\x3e\x66\x3f\xd7\xe5\x7e\xd5\xb8\x5f\x75\xb9\x0b\x5f\x91\x00\x62\x3a\xca\x51\x44\xf2\x34\xdb\x04\xa2\x6c\xe1\x4e\xa9\xd7\xc9\xb7\x48\x27\x4d\x41\x88\x15\x1c\xb1\x51\x4c\xf9\xdd\xee\xba\x74\x7d\xd7\x1f\x65\x92\x10\xad\x99\x14\x12\xc1\x66\xe4\x6f\x0d\x57\xa6\x5b\x29\x1a\xff\xd1\x82\x38\x7c\x22\x94\x9e\x3a\x14\x84\x20\x4e\x18\x4d\xb4\x50\x0e\xb5\xbf\xce\x54\x9c\x5c\xe7\x3f\x94\x08\x44\x74\x63\x0b\xdf\x68\xe2\x4c\xa3\x89\x90\x81\x18\xe7\xbf\x23\x79\x1e\xf9\x91\xc6\x17\x14\xb8\xe9\xbd\xb6\xb2\xfe\x7f\xf3\x14\x43\xcc\x7c\x62\xcf\x16\xe3\x52\x6c\x76\x8a\x73\x30\xbe\x48\x1f\x4b\x93\x4f\x42\xa4\x8b\x72\xf6\x29\x38\x79\x02\xb2\x0b\x4d\x21\x30\x63\xf8\xae\x71\x96\xb2\xd1\x9a\x79\xc2\x77\xdc\x4e\x9e\x18\x47\x1a\xc7\x1b\x89\x56\xd6\xf6\xe0\x3f\xf5\x24\xf0\x6f\x96\xb9\x68\xd3\x4d\x5c\x5f\xe5\x7c\x12\x2a\x99\x4a\xfb\xe5\x57\x66\xea\xa9\xd3\xd5\x48\x79\x83\xfe\xe6\xf6\x1f\x44\x6d\x60\x01\xed\xd5\x1a\x0e\xe8\x06\xe6\xd8\xee\xed\xee\xec\x6c\xed\xa6\x10\x36\x75\x15\x8b\xca\x4d\x4a\xb5\xc7\x76\x1e\x77\xbb\xdb\x4f\xf6\x98\x4a\xc1\xff\x65\xfd\xa7\x8f\xf7\x18\xa6\x9b\x63\x83\xcd\xcd\x14\xa6\xbf\xd3\xc1\xd3\x7e\xb7\xbb\xbb\x83\x1d\xdc\x34\x52\xb8\x6f\x1a\xcc\xe7\x53\xfb\xc7\xf9\xe1\xd8\x54\x20\xa1\x40\x7d\x71\x22\xd8\x19\x39\xb9\x27\x0e\xfb\x5f\x0e\x6c\x52\xb8\x27\xce\xfa\xff\x72\x60\x0b\x9f\x98\x03\x7d\xfb\x8a\x39\x30\xa0\xa7\x14\xc6\x82\xbd\x86\x4e\xcb\x4e\x1a\x0b\x90\xe0\x38\x34\x85\xf3\xa6\x1a\x65\xb2\x19\xb8\x6a\x29\xcf\x15\xd4\x33\x81\x0a\xea\x20\x85\xeb\x36\x2e\x56\xff\x64\x11\x85\xd9\x0a\x32\xc9\x00\x97\x1f\x80\xa0\x70\xfb\xbb\x70\xef\xc4\x8a\x3b\x56\x0f\x3c\x31\xb4\xf7\x97\x27\x80\x0f\x3c\x0d\xbe\x6f\xc5\xdb\x25\xe2\xdf\x4f\xe1\xd9\x0a\x26\x7c\x2b\xe0\x52\xc0\x1d\xb9\xc3\x5b\xf9\xbe\x31\x86\x12\x64\xb1\x36\xf7\xc6\x0b\xc1\xb8\x84\x43\xc1\x9a\xb3\x04\x34\xec\xf5\x5b\xf2\x42\x18\xc3\x09\xd3\x1f\x94\x5e\xe3\x57\x44\xc1\xc6\x80\x8e\x66\xe4\x5a\xc0\xfa\x00\x66\xe4\x99\x59\x28\x41\xa9\x87\x45\x9b\x74\x74\x4b\x66\x02\xd6\xfb\xd0\x07\x33\xa2\x7a\xc0\x26\x86\x69\x1a\xcd\x05\x1f\xcc\x13\xf7\xa4\x51\x54\xbd\x7a\x2b\x83\x7e\x6f\xb1\xa9\xca\x9b\xe5\x8d\xcc\xec\xbc\x6a\xa1\x9f\x43\x83\xd6\x99\x30\x56\x4c\x7d\xda\x2a\x2a\x3f\x85\x8b\xda\x42\x47\xa5\x01\x1a\x33\x09\x61\xb3\x88\xcc\xb6\x4e\x96\x7e\x79\x50\xb7\x07\x70\x5e\xf0\x8b\x70\xae\x4f\x0b\xd3\x80\xa3\x69\x60\x34\xd5\x90\xe0\xd7\x58\xb2\x86\x89\xdb\xc9\x9d\xe0\x49\xc9\x09\x11\x86\x9e\xcf\x39\x24\xae\x4f\x53\x5b\x96\x1d\xd9\xb8\x41\x69\xe0\xce\xb2\x5a\x33\x82\x9c\xd2\xf5\x29\x04\x38\x27\x07\xad\x84\x72\x4b\x2e\x04\x1c\xd9\x0f\x18\xa5\x14\xf6\x05\x3b\x10\xf0\x72\x05\xf9\x6e\x56\xc9\xf7\x5d\xd3\xb6\xa8\x99\x47\x85\x04\xc8\x35\x73\xd2\xc7\x0c\x16\xd9\x64\x95\xe3\x35\xbf\x08\x67\x09\x75\x8b\xf0\x61\x3e\xb4\x96\xce\x8c\xbc\x14\xa0\xc0\xe8\xd7\x46\x83\xaf\xda\x3d\x79\x4d\x96\xa4\xd5\xb9\x5a\x1f\x60\xce\x0a\x0a\xc7\x15\x62\x58\xf9\xc1\xc7\x5b\xf2\xce\x4c\xc2\x25\x06\x30\xa6\x70\x2f\xd8\xb1\x80\x1f\xbf\xdf\x7a\x66\x3b\x45\x6f\x26\x7c\x10\xec\x87\x80\x9f\x2b\x66\xb1\x5f\x9d\xc5\xe7\x2d\x14\xfb\x53\xd8\xd4\x0b\x96\x6f\xd1\x14\xde\x34\x55\x5c\x97\x29\xbc\x6e\x2a\x70\x90\x17\xa7\xf0\x51\xb0\x44\xc2\xfb\x65\x76\xcf\xf1\x52\x55\x80\x1f\xfa\x89\xd8\xfa\x6b\x51\x39\x0c\x5a\xa6\xef\x4b\xf2\x51\x00\xcf\xf6\x7f\xce\x50\x24\x26\x23\xa9\x11\xb4\x2a\x29\xf2\x15\xd1\x4d\xbc\x21\xa0\xd9\xee\x8e\xb2\xcd\x9d\x2c\xec\x6b\x64\x75\xa2\xdc\xd4\xf0\xb5\x71\x86\xde\x0b\xf2\xdc\xba\xa5\xe1\x6d\xe3\x4a\xdd\x0b\x72\x46\x4e\x66\x64\x5f\xc0\x07\x41\xce\x05\xe9\x53\x0a\x5f\x05\xe9\x60\xea\x59\xa3\x11\xec\x0b\xc8\x8b\xaf\xf0\x25\xbc\x12\x0d\xac\xc1\xf9\xe7\x1f\x3b\x99\x0b\x15\x8a\x35\xe8\xa7\x39\xb8\xdf\x80\x64\xa3\x10\x8a\x8f\x40\xd1\x53\x33\x82\xcf\x82\xbd\x84\x2f\x8d\xe3\x2c\x3e\x52\x01\xdf\x04\x7b\x0b\x9f\x5a\x37\xb3\xdc\x1b\x8c\x94\x77\x4b\xbe\x99\x59\xfe\x22\x30\x6b\x19\x5a\x35\xbf\xd3\xa2\x0f\x1b\x19\x13\xf8\xb3\x56\xbd\x72\x2e\xb7\xc2\x08\xe2\xff\x09\xf7\xf3\x91\x58\xea\x8c\xcb\x54\x9a\x91\x04\x2c\xf6\xa6\x4a\x26\x68\x40\xa3\xa3\xce\xd8\x3d\x2d\xfb\xe4\x4f\xcb\xc1\x68\x0a\xdf\x05\x5b\xfc\x88\x5b\x76\x8e\xde\x8e\x79\x92\x61\xfe\x4b\xac\x97\xf1\x15\xc6\x70\xa4\x36\x81\x09\xc8\x84\x7d\x17\xa0\x92\xd5\xba\x89\x6e\x29\xcf\x75\x13\xd1\x54\xbe\x26\xdd\xce\x48\xd9\x6c\x99\x9e\xce\xb2\x66\x42\x92\x34\xea\x0e\x39\xf3\xcd\xce\xaf\x89\xa2\x59\xf6\x70\xe4\xb5\xcb\x72\x45\x16\x72\xa5\x90\x3b\x18\xf8\xeb\x63\x7a\xaa\x60\x88\xb7\x9a\x8a\xa9\xc1\xb1\x63\x93\xc0\x28\xf4\xf8\x99\x28\xf3\x4b\x61\x56\x1b\xcd\x8c\x25\x10\x99\xe9\xe0\xc9\x7f\xe0\x67\xba\x23\x49\x62\xf9\x67\x76\x1e\x04\x41\xd2\xae\xda\x18\xbe\xd3\x64\x53\xcd\x88\x4c\x40\x24\xa0\x90\x27\x60\x8e\x6e\xbc\x06\xb3\xb1\x99\x42\x9c\xb0\x28\x81\x30\x61\x71\x02\x7e\x2b\x6c\x94\x86\xc7\x3a\x97\x86\xd3\xc6\xc5\xa8\xab\xbc\x99\xa6\x7b\xd3\x58\xd5\xc8\xae\x9c\x8b\x3f\xb5\x5c\x1c\x0f\xb4\x0b\x7e\xcb\x54\x2d\x87\xd3\x7f\x03\xb3\x9d\xcf\xfb\x7b\x56\x57\x6b\xc0\x67\x9a\x54\xd5\xf4\x14\xd5\x39\xfe\x7f\xcc\x9f\xed\x11\xbb\x8d\xfb\x4b\x61\x82\x73\xfe\x38\x85\x71\xdb\x34\xaf\xa3\x37\xd1\xbc\x70\x3b\x29\x85\xce\x8a\xa5\x1e\x27\xf9\x5a\x9c\x27\xac\xfd\x72\x7e\x95\xe6\x23\x3b\x7a\x7b\x81\xd2\x50\xef\x2b\x12\x99\x89\xa1\xa5\x52\x2d\xb2\x6c\x0f\x3c\xd7\x21\x35\x70\x2f\x49\x8b\xca\x9b\x94\x5a\xcd\x43\xf5\x06\x86\xa6\x7b\x03\x10\x6c\x00\x09\x33\xb6\xad\xd9\x1d\x81\x8d\xbd\xb4\x95\xa2\x8c\xec\x45\xaf\x56\xc5\x50\xf1\x55\xc2\x66\xc4\x4f\xa0\xfc\xe7\x83\x20\x91\xa0\x40\xb8\x66\x0f\xfc\xb9\x37\x49\xc0\xdf\xf1\x48\xa2\xd9\x83\xbf\xe3\xdd\x08\x08\x62\x2f\x4c\xc0\x8f\xbc\x1b\x91\x52\xd7\xdf\x31\x2f\x12\xed\x06\xb1\x79\x97\x68\xd7\x8f\xd2\x06\x72\xc1\x11\x73\x53\x5a\xea\xe7\x38\x18\x55\x19\xf9\xda\xc2\x32\x73\xed\xf2\xe7\xb9\x73\x85\xe5\xca\xba\x4f\xce\x13\x04\xb5\x03\x56\x33\xcf\xd4\xf2\x01\x26\xf2\x35\xeb\x8f\x97\x70\x2b\xd5\x54\x49\xa2\xbd\x7a\x2d\x10\xac\x60\xe7\x7a\xc1\x6e\x98\x91\x4e\x02\x88\x74\x10\x2f\x51\x60\x86\x5a\x61\x03\x08\xf4\x2d\x52\xb8\x17\x04\x1d\x5c\x4d\x46\x78\x85\xab\x59\x31\x2c\x0d\x6f\xbe\x49\x30\xed\x3b\x4c\x84\x11\xf8\x44\x68\xf6\x2f\xe7\x5f\x80\x9c\x02\x9d\xd3\x9f\x04\x19\x18\x01\x49\x06\xd4\x08\x18\x52\x53\x09\xfa\xb9\xb6\x20\xb4\x55\x17\x82\x04\x84\x86\xb7\x02\xdd\xac\x14\xce\x12\x46\x02\x7b\xda\xd1\x4f\x9b\xf6\xdb\x2b\xf2\xc5\x5e\xc8\xc6\xec\x56\xa3\x5c\x4d\xec\x83\xa4\xde\xe2\xa6\xcb\x8e\xc1\x6a\x9b\x21\xc8\x25\x58\xb4\x4a\x82\x45\xff\xb9\xe5\x11\x40\xc2\x02\x94\x5e\x99\x70\xf8\x0f\x8d\x8f\x25\x93\xc3\xc8\x8b\xc4\xb5\xd6\xc6\xac\x75\x43\x2b\x63\x1b\xaf\xe6\xbe\xb3\x62\xc7\xdf\x25\x2b\xbd\xbf\xc6\xc6\x35\x16\xed\x71\xa6\xe4\xdd\x1a\x72\xca\xde\xcd\xc8\xf7\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\xd5\xb5\x30\x30\x67\xe4\x40\x20\xa2\x07\x02\x8f\x4c\x0e\xd0\xb6\xa6\xbf\x44\x08\x1b\xff\x40\x4d\xf6\x14\x71\x7a\xd6\x36\x4b\x76\x21\x7f\x67\x74\xc3\x5f\x4f\xe8\xef\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\x9b\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\x0b\x8b\xe4\xe5\x2f\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\xb1\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\x7e\x24\xf5\xef\x88\xe7\x70\xbe\x68\x38\x4e\xec\xa7\xe6\x2d\x20\xfc\x04\xfb\x4f\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\xcf\x84\xc2\x4f\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\x5b\xc3\x58\xc3\xeb\xc4\xa0\xfc\xb7\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\x4e\xd8\x23\xf7\x7f\x3e\x82\x3f\x13\x36\x91\xf0\x57\x2b\x76\x67\x64\x46\xde\x23\xb1\x62\x00\x6d\x0b\x1f\xf2\xbb\x5d\xe2\xa0\xb7\xcb\xe5\xf3\x39\x9e\x75\x1a\x4d\xff\x0e\xad\x4e\xf8\x9e\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\x6a\x13\x2c\x60\x91\x19\x88\x60\xe8\x3c\x31\x58\xc4\x35\x0a\x0c\x11\x91\xe2\x20\x0e\xf8\xff\xd1\x3c\x8e\xf3\x79\x1c\x2f\xcf\xa3\x99\x06\xcc\xf7\x84\x3b\xd9\x87\x29\x33\x48\xdf\x98\xbd\x0d\x93\xa5\xbd\x3d\xc0\x69\xf1\xed\xdd\xb6\xc5\x19\xd5\x36\xc1\x40\x31\xa3\x59\x5a\xc5\x6c\x46\xab\x0d\x03\xec\x3c\x62\x81\x3b\xc6\x2c\x33\x02\xf0\x9a\x22\x60\xe8\x17\x4c\x59\x88\x28\x84\x88\x42\xb8\x34\xb3\x81\xeb\x43\x50\xce\x6c\x64\x96\xc6\x0d\x20\x32\x20\x2b\x3b\xd9\xd0\x7c\xbc\x84\x4b\x75\x56\x03\xbe\xc2\x89\x96\x4f\x1f\x37\x53\xc7\xcd\xb4\xd5\x03\x1d\xed\x4d\xf0\x4e\xb7\x6b\x1f\x78\xf5\xed\x38\x9b\xff\xfc\x57\x69\xda\x71\x6e\x04\x1f\xde\xf3\xaf\x9c\xd7\x35\xbd\x54\x69\x75\xd4\xba\xc6\x45\x73\x12\x33\xb8\x1a\xf2\x44\x6e\x15\xfd\x16\x8d\x54\x3c\x44\xb8\x8b\x7c\x5c\xfd\xa0\x20\xf7\x24\x4f\x8d\x5e\xba\x41\x78\xd3\x64\x58\x37\x4c\x92\x1f\x74\x60\x07\x51\x0e\x3e\x66\x51\x75\xd5\x14\x87\xc8\xe5\xe5\x42\x71\x12\x99\xbd\x13\x17\x6b\x11\x25\xb5\xc1\xda\x75\x88\x38\x5e\x78\xa2\xbf\x51\x14\x25\x29\xc4\xcb\x71\xd0\x0d\xf1\xa8\x51\xd2\x70\xe8\xac\x30\x29\xbc\xc2\x91\x2b\x3b\xf2\x7d\xbc\xae\xb7\xd7\x2f\xe7\x91\xe7\x6b\x5d\x19\x3e\xb7\xdf\xc4\xc3\xa9\x89\xcc\xd4\x44\x79\x59\x6c\xa6\x46\x95\x53\x13\xe7\x53\x13\xb2\x78\x61\x6a\x62\xd7\xfc\xcf\x87\xd8\x0d\x60\x46\x62\xc3\x76\x63\x64\x2d\x6d\xd3\x63\x89\x34\xab\xca\x97\xa6\xa8\xbd\x78\x46\x42\xf3\xce\x27\x41\x45\x98\x23\xb5\x1b\xfa\x09\x9b\x27\x30\x77\xa3\x3d\xfc\xd6\xbc\xbd\xb2\x9f\x79\xcf\xe6\xa7\x4a\x8f\xb5\xbd\x83\x6c\xa9\x93\x29\x1c\x96\x2e\xf3\x6d\x89\xf6\xc8\x38\x4d\x49\x71\xf1\x2f\xa7\xad\x11\x4e\x97\x2e\xe8\x88\x1b\x3a\x08\x28\xf5\xaa\xf3\xa3\x78\x31\xac\x6c\x0a\x02\x5a\x9d\x48\x0a\xfe\xf2\x38\x73\x93\x03\xeb\xab\x52\xe2\x69\x83\xa3\x2e\x25\x9e\x5e\x60\x86\x79\x50\xbb\x11\x3d\xda\x4a\xbc\x69\xbb\x4c\x55\x24\xf3\xf4\xeb\x32\x4b\xa2\xc0\xec\xa5\x3e\xc7\xb7\xde\x2d\x11\xe6\x49\xe0\xd7\x3f\x52\x0a\x37\xf5\x2d\x5d\xff\xf6\xf2\x58\x04\xf1\x58\x7c\x3e\xdc\x7f\x11\x5f\x5d\xc7\x12\x53\x3f\xb6\x7c\x85\x19\x26\xad\x97\x04\x2e\x74\xee\x28\x1d\x59\x4d\xde\xcb\x7c\x57\x79\x5c\xf9\xb8\x7d\xba\xfe\x4a\xc0\x61\x4e\x96\xa4\x4e\x1b\x05\x57\x1b\xad\xb6\xdb\x5d\xc7\xbf\xb5\x58\x07\x54\x85\x6e\x38\x9a\x6b\x55\x0f\x6b\x61\xc6\x56\x8f\xdb\x6e\x78\x25\x53\x7a\xc6\x68\xf1\x60\x76\xca\x81\xc3\x84\xe3\xf7\x2c\x16\xa2\x72\x3b\x2d\x78\x82\x68\x72\x15\xd7\x78\x79\x91\x57\x35\x67\x8b\xca\xd5\x45\xbc\x5e\x14\x5a\xad\x5d\x1b\x05\x59\xdb\x51\x61\x2a\xd6\x86\xc0\x8b\x0b\x6d\x63\x67\xdb\x7e\x9b\xb5\x20\xd2\x46\xbd\x76\x80\x88\x6c\x0e\x1f\x39\x66\xb6\xb9\x31\x1d\x88\x30\xf3\x87\xb1\x0a\xc2\xe5\x23\xe1\xfa\x9e\xa0\x14\xcc\x1c\xe0\xbd\xef\xe0\x8a\xba\x9d\x51\x9c\x78\x18\xcf\x3a\xe6\x10\x9b\xad\x6e\x80\x74\xed\xb7\x50\xa8\x01\xb5\x0f\xf7\xf6\x76\x16\x9c\xf3\x86\xb0\xb6\x22\x8a\xfd\xa5\x31\x79\xff\x4c\x60\x00\xf8\xea\xef\x04\x3e\x25\xc4\xf9\xe7\x9f\x11\x1a\x9d\xd2\xe5\xfb\xd4\x1e\xb1\xf9\xa3\x7b\x92\xf9\xce\x6d\x84\xe6\x8c\x7c\x4e\xf0\x86\x1f\xda\x2c\x07\x9a\x7a\xf7\xc4\x8c\xe3\x40\x53\x30\xc3\xea\x70\xf8\x9a\xc0\x4f\x22\xe1\x81\xef\x7b\x07\x1a\x38\xf7\x30\x57\xe1\x95\xa7\x5d\x3f\xad\x6f\x80\xb7\x89\x27\x5c\x9e\xc2\x15\xcf\xae\xd7\x9c\xf1\x22\x24\xcd\x3e\xed\xa4\x30\x6b\x1a\xc9\x39\xca\x9f\xa5\xa4\x0a\x79\x92\x02\xfb\x8d\x66\x8e\xb1\xfe\xf5\xbb\xd6\xc6\x9c\xad\x15\x6c\x96\x05\x4f\x6a\x05\x5b\x65\xc1\xd3\x5a\x41\xbf\x2c\xd8\xa9\x15\xe4\x5f\x90\x5d\x3b\xe3\x0b\x9f\x6e\xbd\xe6\x8b\xfa\xf9\x15\x4f\x53\xb8\xe5\xab\xaf\x35\xdd\xb5\x94\xe7\xd7\x9a\x2e\x5b\xca\x73\x9f\xd6\xb3\x96\xf2\xfc\xda\xd3\x0b\x9e\x19\xe0\x87\xab\x14\xa2\xdc\xbc\x9e\x19\xc3\xf3\x87\xc7\xc1\x1f\x78\x01\xf8\x8f\x3d\x01\x01\x37\x86\x68\x62\xac\xed\x99\x35\x43\x5f\xb5\x32\x1c\x65\xfd\x38\xd9\xc5\x15\xfc\x5e\xaf\x75\xc2\x1c\x71\x76\x9d\xc0\x05\x67\xef\x05\x1c\x34\x61\xbc\x76\xc1\x49\x79\x80\xfc\xc4\x1e\x20\xd3\x14\xf6\x39\x7b\x0e\x2f\x39\xfb\x0b\xde\x71\xa6\x25\x1c\x37\x36\x96\x3d\xc7\x49\xe1\x7e\x49\x49\xb2\x1f\x6a\xc9\xf3\x0e\x3d\x3a\xf9\x67\x7a\xe7\xc7\xa7\x8f\x5c\x2d\xa6\xc8\x50\x8b\xad\x9b\x5d\x9d\xee\x15\x47\x4f\x8a\x31\x65\xf6\x82\xc2\x58\x65\xf8\xc1\xd9\xab\x04\x3e\x34\x76\x8e\x5f\xd6\x1b\xd8\xf5\x6c\x3e\xab\xaf\x9d\x7e\x29\x9a\x1f\x23\xa7\xf0\x93\xb3\x19\x39\xe2\x8b\x9f\x7d\x7f\xba\xf7\x45\x54\xd0\xfb\xc0\x49\xf6\x3d\x4d\x31\x5e\xe3\x7a\xed\x2a\x9e\xea\xb5\xa7\x6b\xe3\xe8\x2c\xd2\x53\xc0\xaf\xd5\x9e\xc5\x7a\xcd\xe9\x1d\x73\x62\x1b\xd2\x6c\x3c\xf7\x9c\x38\x7d\xd7\xe9\x55\x02\x5d\xdd\xce\xe8\x03\x27\xff\xda\x97\xf6\x43\xd3\xe1\x24\xe6\xda\x5b\x73\xfe\xd5\x93\xbd\x7f\x39\xff\xa2\xde\x07\x41\xde\x71\x32\x10\x5b\x7f\x58\x21\x01\x7f\x09\xf2\x83\x93\x10\x0f\x15\x9f\x73\x76\xaf\xe1\x0d\x67\xbf\xc8\x48\xff\x9c\x13\xd9\xdb\xed\xff\xa1\xfe\xd8\xed\xff\x31\x10\x5b\xe6\x99\xe8\x0d\x4e\xf1\x87\x01\x2e\x7a\xf8\x79\xfc\xd7\xbc\x25\x4d\x66\x1f\x15\xd8\x5a\xb4\x31\x08\xb6\xbd\x85\xa9\xe7\xb6\x77\x18\xd3\xa3\x81\xd7\x87\x84\x89\x61\x52\xa6\x93\xe8\xf5\xca\xfc\x49\xd5\xc6\x49\x96\xb0\x66\xfb\xc9\x7c\xbe\xf3\x78\x8f\x57\x16\x5e\xb1\x41\xff\x0f\xd5\xe3\x1b\xdb\x4f\x8a\x5c\x34\x98\x74\x18\xfd\xca\xb6\xa7\x0d\xe5\x29\x9a\xc2\xc7\x0a\xb2\xd5\x7b\x65\xcb\x0b\x68\x0f\x43\xa9\x51\x06\x32\x66\xf6\xba\xfa\xad\xa9\xc5\x45\x88\xa4\x16\x67\x42\x2d\x2c\x83\xaa\x5c\x19\xab\x91\x00\x2e\xb4\xa6\x3d\x67\x25\x09\xd4\x56\x2e\x85\xf7\x8d\xb4\x6b\xe0\xe6\x58\x8c\xf9\xcc\xb3\x10\x30\xce\xec\x2b\x67\xdf\xe1\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\x41\xc4\xc6\xe0\xe9\xe3\xbe\x11\x80\x4f\x76\xb7\xc5\xce\x1f\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\x0f\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\x3f\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\x93\x53\x1b\x73\x72\x4a\x2b\xb5\x65\xd2\x70\xae\xdc\x4f\xb1\xd9\x77\x8b\xc7\xe2\x5c\x7f\xe3\xbf\x68\x3e\xb0\xcd\x7b\xb6\x79\x53\x95\x8d\xac\x8a\x99\xed\xd3\x5f\x0c\xac\x2c\xff\x20\xc8\x0d\x79\x63\xec\xb9\x7e\xfe\xff\xf6\xa8\x12\x03\x5c\xbf\x70\x0a\x7f\x37\xf2\xdb\x19\xf9\x90\xc0\x27\x8e\x27\x10\x7f\x36\xd5\xb0\x91\xcc\x46\x89\x72\x8e\xce\xe3\x64\x32\x5e\x93\xb1\x5e\xf3\xc5\x9a\xb8\xba\xd6\x33\xc7\x58\x70\xaf\x38\x1c\x09\xe2\x7c\x55\xb1\x3c\x5b\xdb\x3f\xfa\xf0\x64\xb7\x3f\x58\x0b\x63\x75\xc5\xb5\x63\xfa\xb5\xec\xfb\x2f\xbe\xea\x1c\x65\xe1\x22\x07\x8c\xed\x39\xca\x77\xce\xa4\x04\x19\xb4\xe9\x77\x42\x12\x45\x1f\x09\x69\x2f\xae\xaa\xa0\xe5\x36\xb1\x0e\xd8\x77\xa3\xce\xc9\x00\x36\x61\xcb\x50\x84\xc0\x4c\xa5\x49\xc0\xee\xc8\x5f\x1c\xfa\xa0\x03\x10\xe6\x3f\x0a\x3c\x60\x13\x08\x96\x7b\xac\x06\x0b\x18\x7b\x94\x07\xb0\xb5\x09\xd2\x7e\x96\xd4\x87\xc4\x9e\x80\x66\x03\xd1\xc6\xc2\xc8\x3e\x2a\x2f\xca\x8b\xb2\x18\xf7\x31\x94\x4c\x80\xb2\xa7\xfb\x51\x33\xc6\xa6\x75\xfc\x2b\x14\xbe\x73\xa2\x1e\x6d\x6d\x16\x06\xae\x2e\x83\x8f\x72\xdc\x5c\x3e\x94\x6c\x46\x82\x00\x24\x74\x28\x28\x86\x37\x64\xc2\x80\x29\x09\x7e\xeb\xa4\xf6\xf7\xf6\xf1\xf7\x48\x7a\x98\x2f\xa2\x05\xc7\x3c\x30\xfa\x66\x19\x10\x86\xf4\x8a\x1c\xd1\xad\xcd\x3f\x94\x2b\x40\xb0\x30\xb0\x6b\xb0\xb5\x09\x7a\x63\x80\x5f\x2e\x93\xa3\xaf\xc6\x6c\x3d\xa3\x9e\x72\xcf\xf0\xe2\x70\x1c\x40\x82\xbe\xf2\x5c\xb6\xe1\x0a\x4d\x03\xa2\xdc\x90\xf6\x8c\x0d\xe9\x07\xb0\x03\xe2\x0f\x6d\x16\x0b\xcc\xdb\xb4\xa1\x66\xb6\xa2\x58\x4c\x61\x12\xb0\x10\xc6\xc1\x2f\xe2\x40\x0c\xda\xa5\xe0\x9e\x91\x9b\xc0\xa8\xc9\x0f\x67\x78\xe0\xa5\x1f\x6d\x6d\xce\xfb\x10\x7a\xf9\x77\x5a\xac\x1d\x03\xdc\xbb\x25\x13\x1c\x13\xde\x40\xc8\xee\x4d\xa8\x0d\x33\x48\x0c\xe6\x40\xba\xe0\x20\x68\x1e\xd2\xd1\x69\x9c\xb0\xfe\x9e\x2c\xce\xba\xff\x6b\x6b\x13\xe3\xf7\x26\x01\x68\x90\x1b\xba\x72\x32\x7d\x49\xc6\xf8\xed\x8c\x0d\x6d\x7a\x90\xd0\x01\x51\x8c\x3f\x09\x8c\x11\xde\xb4\x5c\xeb\xd2\xed\xa4\x70\xd5\xb6\xe4\xb9\x79\x97\xdf\x8a\x38\x5b\x51\xb1\x76\x7d\xe2\x7a\x45\xc5\xfa\x25\xae\x26\xac\x2a\x56\xe7\x6d\x23\x91\xe1\x85\xeb\x36\xd3\xae\x37\x48\x29\x86\xf3\xa5\x70\x17\xb0\x67\x70\xb9\xf8\x05\xbd\x85\x1b\xeb\x83\x3d\x66\xe9\xba\x74\xb0\x65\xfa\x1b\x24\x4c\x6d\x0c\x90\xfa\xf0\xae\xaf\x2e\xf6\x28\x68\xc6\x0d\xfa\xcf\x5a\x37\xcb\x2d\xb9\x0c\xd0\xbf\xd9\xc1\x60\xab\x15\xf5\xee\x02\x8c\x36\x7b\x16\x40\x1f\x6e\x03\xa2\xe8\xc6\x20\xbb\x23\x70\x18\xb0\xcf\xf0\x2a\xf8\x0f\xee\x37\xa2\x25\xb8\x78\xc9\xf1\x9e\x7c\x20\xf2\xa4\x7f\x4a\x41\x66\x1f\xea\x1b\x50\xea\xe5\x6f\x7b\xf2\x64\x50\x29\x32\x32\x1c\x2d\xc9\xa3\xc6\x99\xb7\x2e\x97\x7f\xe4\xda\xda\xda\x9a\x93\x39\x7d\xfe\x91\x8e\x55\xa3\x2f\x02\x76\x24\xe1\xa0\x6d\xac\xce\x3f\xf2\x1f\x49\xac\xe2\xde\x1b\xd0\x9e\x43\xd7\x9c\xde\x51\x40\xf6\x83\xec\x48\x7d\xbf\xa5\xcb\x97\x96\x4f\xa5\xf0\x72\x19\xf4\xaa\xe8\x94\xfc\xc4\xa7\x3c\x64\xa8\x48\x55\x9b\x51\xe6\x55\x90\xd9\x5c\xd9\x29\x45\x99\xc4\xde\x06\x50\x97\x1f\x39\xca\x0f\x72\x89\x2f\x88\x62\xda\xe5\x36\xde\x5c\x51\xda\xed\xce\xc8\x61\x00\xd3\xc4\x6c\x39\x82\x1f\xc4\x80\xc0\xd2\x8c\x18\x39\xae\xd3\x4b\x3c\xe7\xe4\x5f\x4e\x2f\xe9\x39\xff\x3a\x75\x6c\xee\x03\x8c\xce\x6f\x48\x2e\x61\x83\x67\xac\xe3\xda\x39\xb1\x73\xe5\x72\xda\x73\x4e\x9d\x61\x05\x6e\xb4\x0a\xca\xa6\x97\x5d\x8e\x73\xb9\xbd\xd1\x6b\x1d\x88\x71\xe9\x0c\x0d\x19\x51\xae\x3f\x72\x8e\xcf\xc5\xda\xdb\x69\x2c\xdd\x97\xe8\xc6\x75\x63\x29\x3e\x84\xc6\x72\xbf\x98\xc6\xd2\xe9\xe5\xfe\xb5\xaf\x78\xef\xdb\x73\x96\xaa\x3a\xc6\xb6\x0b\x79\x34\x11\x63\xfc\x1a\xcb\xb9\x58\x0b\xe3\xc9\x24\xbe\x8d\xe4\x99\xb5\xd0\x6e\x03\x12\x53\x53\xeb\x96\xcf\xa6\x9e\x33\x5c\x20\x23\x43\x3a\x38\xa0\x10\x66\xe4\x45\x00\x07\x01\xc4\xc6\x0a\x94\x8c\x33\xcd\x62\x0c\x09\x0a\x98\x5a\xf6\x72\x3a\x87\x5c\x1a\x73\x34\x5e\xe3\x0d\x23\xb8\x8d\xf4\xf9\x9a\x8c\xd7\xae\xe3\xe9\x34\xf2\xa3\x49\xa4\x23\x31\x75\x7a\x76\xd0\xed\xe3\x5b\x77\x68\x2d\x34\xc9\xc7\xc5\x9f\xe2\x92\x64\x8b\x1f\xa2\x1f\xd2\xf9\xa8\x62\x7f\x22\xae\x6c\x47\x66\xd8\x98\x7c\xb0\x0d\x72\xcf\xf1\xcc\x50\x71\xcf\x78\xcb\x6d\xcf\xa2\x1b\x21\x2d\x04\xac\xe7\xd0\x1e\x39\x32\x22\xf1\x22\x80\x6d\x98\x9a\xf6\xd9\x6b\x1f\x2f\xf8\x05\xec\x5c\xc2\x71\x0b\xe3\xcc\xdd\x6d\xf7\x41\xe6\xc6\xfc\xd1\x52\x31\x8f\x25\xfb\x60\x48\xea\x5d\xd0\x10\xbf\xfd\xe7\xa2\x2b\xe0\x38\x20\xce\x8b\x42\xd7\xb3\xae\xff\x35\x1d\x5d\x89\x35\xa7\x27\x7b\x8e\x31\xca\x95\xcb\xa9\xf7\xc3\x7e\x81\xd4\x20\x41\xe1\x67\xc0\xc6\x12\x9e\xaf\x60\x80\x9f\x35\xfc\x0c\xac\x94\xa4\xf0\xa6\x6d\x5c\x9b\x80\xe1\x6c\xf0\x3a\x60\x57\x12\x3e\xb6\x55\xdb\x81\x33\xac\xf6\xbe\x91\x97\x7c\x0c\xac\x0e\xfe\x3a\x80\x0b\x6d\x94\xb4\x1f\x01\x39\xd0\x56\x19\xfe\x1a\x30\x9f\x5c\x4b\x38\xe4\x80\x13\x82\x71\x58\x18\x80\x05\x3f\x02\x0a\xef\xcd\x8a\xfc\x0c\xc0\xe1\x52\xc6\x1a\x73\xea\x4d\x1d\x78\x13\x90\xfb\x20\x0b\x11\x36\x85\x13\xee\x8b\x49\xf9\xde\xb6\x7a\x1e\xc0\x19\x39\xc9\xa3\xa3\xa0\xb8\xee\xff\x7c\xe6\x80\xd3\x77\x4e\x29\x60\x5d\x44\xeb\x48\x1b\x84\x9a\xdb\x15\x69\x01\xea\x0d\xf3\xbe\xa7\x9a\x2b\x3d\x7d\xa6\x1d\xf8\x10\xe4\xef\xce\x84\x14\x8a\xeb\x58\x7d\x3e\x7c\xe7\xd8\x6e\xde\xb6\x4c\xdd\xe3\x6c\x82\x3f\x1b\x82\x30\x6d\xc7\x5c\x73\xc7\x62\xf5\x22\xb0\x79\x63\x8e\x39\xbc\xd6\x08\x83\x7c\xc5\x9e\xbf\xb4\x6b\x15\xdf\x5a\x97\x3c\xf3\xbe\x22\xad\xbc\x4c\x2a\xe9\x83\x3e\xad\x50\x1b\xb6\xab\x6a\xc3\xdf\x2d\x63\xc8\x9d\xd1\x7f\xfe\x82\xe8\xff\xc2\xdd\xb1\x99\xc2\xf7\x20\xf3\x3a\xcb\xa8\x89\x5e\x32\xa9\x90\x82\x6a\x2a\xce\xbe\xdb\xee\x68\x71\xa7\x9d\xfc\x32\x59\xc4\x66\x12\x44\xc4\xee\x35\x24\xd1\xea\x68\x79\x11\x91\x07\xff\xa5\x27\xc0\x3f\xf2\x08\x67\x09\xa8\x88\x34\x1d\x94\xe8\xc8\xde\x3b\x7a\x59\x3b\x8e\xca\x66\x71\x3f\x58\x74\x62\x53\xf0\x3b\xc6\x5c\x0a\x3d\x09\xc1\x4b\xef\x40\x43\xb0\xef\x69\x08\xfe\xf2\xd6\x07\xb9\x8e\x9a\x52\xe0\x51\x76\x65\x3d\x88\xda\x53\xb3\x24\x11\x38\x7f\xbe\x3a\x76\xa0\x03\x12\x78\x64\xf5\x92\x28\xb2\x61\x8e\x3a\xca\xb6\x84\x50\x2a\x56\x19\x79\x1d\x24\x14\xe2\x96\xd9\xca\xb5\xba\xb0\xa5\x3c\x5f\x3e\x3f\x5a\xe1\x43\x20\x2a\x4b\x4f\x36\x8d\xd8\x0f\x09\x37\x11\x7b\x27\x61\x12\xb1\x9b\x88\xf4\x29\x8c\xa3\xb6\x1c\x80\x33\x32\x8d\x9a\x9c\x0d\x37\x11\xb1\xb7\xd3\x2c\x03\xea\xd4\xfa\xb6\x97\x03\x9a\x41\xa8\xdf\x01\x3d\x23\x59\x92\xa6\xd4\x68\x07\xb6\x8b\xf3\x88\xfd\x29\xe1\x6a\x79\xda\xb3\xd3\xed\x7c\x95\xdf\x48\x82\x90\xcf\xa3\xcc\x47\x6b\x54\xf0\xc5\xa9\xa9\xde\xcc\x8a\x9a\x1d\x13\x24\xcb\x41\x73\x15\xd9\x6c\x3e\x36\x0f\x4d\x27\x22\x77\x9a\xc2\x4d\x64\x38\x9c\xa6\x95\x94\x2e\xd7\xb5\x3e\xaa\xa3\xe9\x1b\x14\x66\xad\xf4\x82\x28\xd8\xab\x22\xc3\x4f\xd2\x3d\xe6\xd3\x4b\xf6\xe0\x7b\x93\x08\x02\xef\x2c\x82\xb1\x77\x1d\x81\xf0\x66\x11\x84\x9e\xaf\xed\xe1\xc2\x6d\x04\x77\x11\x5c\x46\xf0\x2c\x82\x17\x11\xfb\x4b\x12\xc7\x34\x73\x28\x1c\x46\xec\x83\x84\x57\xad\x9d\xbd\x30\x93\x7b\x18\x19\xc3\x2f\xfb\xe7\x26\x32\x2c\x7d\x1f\xa3\x48\xa7\xcb\x05\x2f\x13\x6a\xb3\x2d\x51\x38\x5a\x31\x84\x57\x11\xea\xe3\x5f\x0c\xd9\x1d\xe0\xa4\x37\x25\x26\xc8\x38\xc3\x28\xae\x6f\xd9\x25\x2d\x34\xf7\xf7\x39\x59\xf6\xd8\x35\x71\x17\x08\x31\x16\x63\xa7\xee\x69\x75\x0e\x84\xbe\x8d\xd5\xe5\x9a\xdd\x4b\x0b\x2e\x55\x3c\x19\x3d\xe6\x84\xe0\xe1\x30\x75\xfd\x4b\xd7\x7f\x4b\xf1\x1b\x96\xca\xfc\x08\x04\x44\x91\xcd\x9d\x5b\x78\x5a\x73\x4b\x21\xd7\x5d\x9c\xcf\x52\xe4\x9e\x79\x25\xa6\xd7\xb1\x9c\x8a\xb5\x50\xc5\x57\x6b\xfc\x3a\x32\xb2\xdb\xe8\x8b\x75\xc7\xa2\xf3\x9e\x4f\xc2\x58\x5d\x89\xf1\x5a\xa2\x26\x59\x9d\x34\x45\x95\x94\x7a\x61\x64\xc3\xd9\x29\x5c\x34\x32\x4f\x39\x72\xb4\x4a\x84\xe3\x65\x79\xc6\x52\x38\x68\xae\xe7\x76\xe6\xf3\x3c\x28\x75\x24\xd1\xfa\xd8\x6f\xac\x29\x64\x43\xb4\x41\x0a\x2f\x1b\x2b\xe7\xb9\xce\xf6\x23\xd8\x37\x16\x87\xc3\x1c\x3c\x60\x78\xd7\xc4\x5c\x32\x8b\x8f\xa8\xda\x99\xb0\xb6\x71\x08\x45\x28\xc4\x71\x2b\xd9\xe0\x8e\x7a\x87\xfb\xab\x63\x99\xe4\x7d\xd4\x68\xb7\xf1\xc0\xda\x14\x36\xe0\x2d\x78\x81\x27\x04\xdf\xd0\xc6\x3c\x6e\xe4\x21\x33\xf2\x32\xca\x6e\xf0\xf9\x34\x05\x9b\xbb\xa5\x48\x18\x04\x17\x9a\x5c\x44\x36\x25\xdc\x3a\xde\xf4\xc3\x8b\x70\x70\x5f\x4d\x22\xb4\x50\x49\xe7\x35\xb2\xd8\x6e\x38\x88\x88\xb0\x6f\x8a\xc4\x44\xe6\x9d\xb2\xef\x6c\xe6\x22\x40\x97\xe1\xb0\x70\x05\xdd\x06\x84\xd3\x91\x33\xca\x75\xdd\xae\x03\x9c\x7a\x8e\x93\xc2\x8f\x36\xbe\x66\x2b\x3e\x72\xf0\xe6\x0e\xe4\xc9\x92\x7a\xf7\xa6\xa7\x0a\xec\x23\x83\x69\x10\x81\x86\xcf\x36\x26\xe8\x43\xab\xec\xb5\xd2\xe2\x67\x94\xc9\xf0\xe7\xbf\xa8\xf8\xe6\x17\x62\xe7\x75\x4b\x79\x7e\x44\xfd\xf1\x17\x62\xed\x7d\x2b\x79\xfc\x24\x0a\x1e\xf8\xa1\x57\x04\x3d\x3c\x4f\xe0\x67\x02\x86\x00\xb2\x6b\xd1\x5f\xa3\xff\x9d\x1c\x6d\x86\xfe\x47\x79\xac\x0c\x45\xb7\x5c\x96\xa7\xed\x6d\xcb\x56\xf3\x53\xf8\xdc\x4c\x99\xbe\x2a\xbf\x3f\xe8\x3f\xed\x59\x72\x71\x1c\x1b\xa1\x11\x05\xb0\x6f\xf6\xd3\xd7\xc8\xea\xc5\x6f\x23\x50\x78\x8d\xf2\x1b\xa5\xf6\x22\xa7\x3d\x69\xe8\x29\xf3\x27\x85\x2f\x6d\xdd\x8f\x9c\x87\x9c\x64\x00\x3d\x08\x5f\x34\x7c\x36\xec\x99\xf6\x9c\xd4\x41\x02\xfa\x86\xeb\xb9\x9d\xc2\x27\xd4\xa2\xfe\x6e\x0e\xe1\x92\x0c\x15\xbd\xd5\xe2\x21\x13\x47\x66\x42\xfe\x8a\xd8\x99\x84\xef\x75\x60\xed\x57\x5a\x96\xef\x10\x2d\x1c\x8c\x2d\x9e\xc1\x6c\xa5\x29\xc8\x98\x7d\x03\x15\xb3\xbf\x41\xc7\xab\xd2\x3b\x38\x4e\x9e\xdf\x21\xbb\x57\x29\x62\xf6\x05\x92\xf8\x17\xc7\xd5\x0f\x7c\xdf\xe3\xc0\x0f\x3c\x05\x9c\x7b\x02\x78\xdf\xd3\xc0\xb7\x8d\x9a\x77\x65\x23\x1e\x78\xdc\x1e\x78\xff\x5a\x90\x84\xce\xe7\x33\x22\x62\x70\xfe\x3f\x66\x43\x2f\x84\x15\x18\x1e\xa4\x62\x70\x3c\x27\xbb\xa5\xcd\x33\xcf\x01\x47\xcf\x41\xbd\x72\x9e\x50\xf1\x35\x27\x33\xf2\x49\x40\xd0\x1b\xe0\x1d\xbe\xcc\x95\x12\x2d\x65\xdf\x8c\x59\x94\xd3\xd7\x85\x26\x37\x24\x89\x51\xcc\xea\xd8\x7e\x0b\x28\xce\x1c\xff\xd5\xb0\xa5\xac\x52\x02\x07\xba\x28\xa5\x10\xc4\x6d\x59\x20\x5f\x0b\xc3\xc7\xea\xdd\x26\xd9\xa0\x1e\x39\x90\xa7\x5c\xf0\x1b\x6e\xd4\x5e\x12\x6e\xf1\xf9\x24\xac\x4f\x56\xe1\x35\x43\x1d\xe3\xaf\x4a\x6c\x23\x56\xc3\x60\xa9\xec\x4b\xfa\x10\xc5\xcd\x01\xfa\xaf\x85\xd1\x53\xeb\xd8\x88\x0c\x9b\x91\x93\xc5\xb4\xd7\x13\x57\x96\xae\xed\xc0\x74\x83\x21\x4e\x9f\x04\x24\x3d\x64\xda\x78\x37\x55\xc7\x90\xa0\x2a\x58\xaf\x6a\x67\x08\x3f\x39\xbf\x4c\x79\x16\x19\xb5\x88\x8c\xce\x90\xf9\x1f\x4e\x76\x24\x51\x4b\x0c\x54\xb9\x50\x1c\x55\x91\x11\xbd\x81\xd9\x51\x16\x15\x51\x4d\x53\x99\x55\x34\xa8\x60\x28\x67\xdc\xec\xcd\x93\x31\x38\xe7\x5a\x5f\x7b\x8f\x1e\x39\x80\xec\x2b\x8e\xa1\x6f\xa7\xfe\xb1\x61\x04\x5e\x59\x67\x5a\xab\x34\xb0\x95\x9e\x60\x25\xa3\x25\xf8\x31\xd3\x9a\x38\x61\x1c\xe0\xad\xa3\x69\xcc\xfe\x52\x70\x13\xb3\xef\x12\x26\x4d\xab\x62\xc7\x86\xcc\x38\x78\xe1\x5d\x68\xf2\x25\x22\xda\xe5\x87\xb4\x92\x93\xf8\x9e\xfc\x24\x1a\x99\x75\x07\x3f\xbd\x65\x1d\x06\xd3\x18\xb4\xeb\x3f\x85\x37\x44\xc2\x3d\x8a\x4b\x33\x03\xaf\x22\x38\x12\xe4\x5b\x44\xc1\x8f\x73\x71\xba\xe1\x73\xb5\x71\xc5\x75\x70\x8e\xd7\xa6\xb2\xdb\xb6\x9d\xe5\x55\xa9\x26\x4d\x55\xc5\xfe\xca\x3c\x8f\x18\xef\x66\xd6\x24\x33\x8e\xb3\xc2\x7e\x76\x8c\x80\xe7\x35\xe7\x71\xbb\xa9\xd3\x89\x9b\xef\xbe\x23\xbf\xb1\x12\xe2\x2a\x66\x37\xb1\xd1\xfd\xcf\x9a\x37\x54\xc6\x1b\xf5\x32\x6f\xbc\x25\x93\x18\x7d\xdb\x3f\x89\x80\x07\xfe\xc9\xd3\x2e\x37\x3c\x4d\xb8\xfc\x13\xa0\x94\x3b\x8f\xb3\x3b\x27\xc2\xcc\xee\xc8\xfc\xeb\xbd\x21\xe6\x8f\x11\xfe\x09\xde\xbf\xa5\xd5\x4b\x83\x49\x35\xd3\x63\x23\xfc\xcf\x11\x49\x68\xa5\x8b\xaf\x11\x1c\x69\x92\x50\xdb\x45\x01\xae\x50\x99\xcd\x3a\x16\xad\x71\xb8\x8b\xb1\x0d\x79\x8d\xab\x4a\x8d\x05\xa6\x7e\x4f\x84\x79\x8d\x47\x1a\xad\x1c\x1d\xe9\xc9\xff\xea\x2d\xc4\xd6\xd4\x3d\xca\x6b\x67\xe4\xc4\xaa\x3c\x92\x5f\x09\xe7\x34\x0f\xfd\xa8\x25\x49\xc8\xa5\xeb\x17\x01\x9f\x6d\x66\x24\xeb\x61\x07\x07\xf7\x19\x91\xee\x37\xab\x2d\xcc\x9a\xf6\xd6\x3a\x4a\xf7\xdb\x38\xcb\xf5\x71\xd7\xba\x03\x20\xb1\x7b\xe0\x9b\x47\xd0\xb3\xfd\x15\x66\x31\x11\x98\xc2\xdf\x71\xa8\xf7\x8a\x08\x58\xc4\x96\x66\x71\x46\x99\xe4\x36\xcc\xb4\xbe\x69\x74\xdb\x56\x49\xaa\x5b\xe5\x36\xb6\x5b\x05\x75\xca\x0d\x7f\xb6\x11\x46\x62\x32\x2e\xb7\xc9\x65\xeb\x24\xe3\x39\x49\x4b\xd9\x7d\x96\xb5\x29\x97\xa6\xcf\x96\xa1\xd4\x42\x6d\xf1\x48\x0d\xcf\x22\x6d\x18\xed\xc6\x00\x14\xee\xb7\xe5\x60\x5a\x55\x3e\xa4\x14\x5e\x34\x4d\x69\x3b\xe8\x2c\xe2\x1a\x4f\x5b\x8b\x4e\x40\x67\x47\x03\x46\x02\x2c\x77\xa8\xcb\x87\x94\xc2\x61\xeb\x7c\x7c\xd5\xe4\x96\xbc\x88\xb3\x23\x26\x33\xea\x57\x2d\x72\xa8\xbf\x57\xe4\x6b\xbf\xb7\x1f\xee\x2a\x31\x56\x55\xdc\xd7\x45\x55\xce\xeb\x61\xf1\x2a\x53\x03\x06\x36\x1e\x98\x66\x77\x44\x86\xf6\xaf\xca\xbf\xe3\x6c\x8a\x72\x9b\x37\xaf\x52\x39\x8f\x48\x30\x27\x73\xb9\x19\x12\x17\x33\x54\xb8\xfc\xb4\xfa\x21\xde\xac\xbf\x52\x46\x0b\xd7\xb7\x37\x9f\x2a\x4d\x8d\xe6\x11\xe0\xff\xb0\x79\x76\x69\x45\x15\x9b\xb7\x0a\xa7\xdb\x2d\x1e\x73\xa0\x11\x02\x8d\x59\xe4\xfa\x10\xb2\xd8\xf5\x8b\x2b\x3f\xbe\xcb\xe1\x86\xf9\xd5\xcc\xcf\x77\x1a\xaf\x8d\xe0\x43\x9c\x3f\x84\xf9\xc3\x14\x06\x62\x6b\x4f\x8e\x66\xe4\x30\x06\xb5\xb1\x0d\x37\xd4\xbb\x25\xaf\x62\x90\x46\x4a\xe2\x6f\xcc\xfe\x9c\x4f\xd5\xd2\x2a\x9f\x91\x13\x91\x8d\x22\x7b\x63\xa4\xce\xd1\x8a\x6d\xf0\x2a\x2e\xd5\xc6\x8b\x76\x21\xa7\x9b\xf8\x8a\xd5\xda\x8d\x98\x37\x5b\xf2\x28\x06\xd1\xc3\xa3\xc7\x18\xc4\x06\x12\xa8\xdd\x85\x07\xcb\xdd\x2f\xdc\xbb\x28\x38\x75\x60\x6d\x82\x46\x7b\x22\xff\x0e\xf4\x2b\x62\x73\x1a\x75\xbb\x86\xb3\x58\xf9\x83\xc7\x7d\x31\xfb\x08\x2f\x1b\xb5\x84\x5b\xb2\x1f\x97\x79\xbf\xdf\xb5\x4e\x87\x0d\x08\xc7\x64\xd1\x08\xf2\xb8\x51\xf9\x79\x55\x3b\xde\xcd\x04\x2c\x08\x66\xd3\xb1\x25\xd6\x39\xf6\x2e\x26\x31\xde\x33\xbe\x8c\xed\x69\xec\xc0\xa8\x81\x2f\x63\x9b\x96\x8e\x33\x1b\x28\x19\x30\x82\x81\x06\x46\x2b\x7c\xb4\x39\xef\xd3\x8d\x01\x44\x0c\x2f\x18\xcf\xc8\x45\xa6\xcb\xb6\xc1\xe3\x08\xcf\x66\x14\x89\xd9\x6d\x40\x22\x6a\x08\xf0\x11\x07\x9f\xc5\x8f\x04\x4c\x59\xee\xa9\xc3\xd5\x3a\x88\x09\x02\x3b\xd3\xa0\x02\x78\xc9\x89\xbb\x83\xe9\x71\x29\xe0\xf9\xf7\x47\x8d\xf9\xbd\x0b\x1e\x1c\x8f\x06\x8f\xb6\xfe\x20\x61\xcf\xef\x91\x78\x63\x4a\x1f\xc5\xd4\xeb\xa7\x14\xee\x9b\x88\xa4\x1a\x32\x62\xf8\x82\x2c\xa3\x52\xb8\xeb\xcf\xe7\x8b\xbc\xe0\xa6\x92\x5b\xbd\x9a\x8d\xac\xd8\x49\x79\x46\x8b\xc8\x68\x2b\x0f\x92\x05\xa0\x58\x0c\x9a\xbd\x21\xda\x08\x13\x6e\x44\x7e\xfe\xad\x59\xf4\x1e\xe8\xca\x79\xbb\x55\x6a\x4c\x75\x8d\x69\xf3\x7f\x34\x12\xc5\x35\x91\xd4\xbd\x88\x23\x49\x30\xe5\xec\x87\x36\xaa\x70\xf2\xa4\x15\xe6\xaf\x32\x8a\xc9\xab\x3c\x6e\xe5\x47\x4c\x6e\xc9\x7d\x6c\x97\xc1\x2e\x6e\xc6\x3d\x7f\xb6\x70\xcf\x3a\x30\x5a\x58\x87\x0d\x64\x95\x0f\xa7\xe7\x6e\xee\xfc\xf1\x45\x90\x19\xf9\x10\x5b\xf3\xf3\x0f\x32\xd8\x40\xe5\xfc\xf9\x6f\xe2\xdc\xcf\x51\x1e\x78\xb7\xe4\xa7\xe5\xf2\x33\x72\x1c\x17\xd6\xec\x9b\x98\xbd\x80\xd7\xff\xb9\xe2\x76\x57\x55\xac\x5e\x54\x14\xb7\x17\xe0\x7f\x45\x15\xcd\xff\x8a\x2a\x9a\xd1\x0b\x4e\x0d\xe1\x1f\x19\x3d\x78\x95\xae\xd6\x00\x32\x29\x20\xd6\xf4\x34\xff\xeb\x02\xbc\x25\x55\xec\x78\x51\x59\xdb\x5e\xac\xf1\x1a\x6f\x70\xf0\x63\xcc\xcc\x5d\xd6\xdb\x59\xac\xf7\x74\x11\xd2\x92\x62\x78\xb5\x58\x63\xb7\x5a\x83\xb3\x7c\x40\x66\xb8\x1c\xbf\x1d\x75\xe4\xbd\x16\x84\xbb\xfc\x05\x1d\x75\x3c\x6b\x47\xaf\x39\x60\x5f\x70\x97\x1f\x79\xc8\x53\x07\x7d\xf8\x6a\x14\xa5\x37\x31\x3c\x8f\x6d\x75\x28\x59\x70\xa3\x49\x74\x6e\xa6\x90\x9b\xf9\x49\xe1\x8d\xa0\xf0\x4a\x13\xee\x06\x81\x4d\x68\x53\x1d\x6b\x8b\x7a\x9a\x1f\xe9\x7c\x8c\xd9\x8d\x24\x83\x47\x7d\x0a\xef\xdb\x28\xed\x21\x38\xf7\x24\x04\xd2\x1e\xa4\x7d\x8d\x99\x54\xf0\x36\x66\x6d\xc8\xe5\xde\x38\xd9\x73\x1e\xe5\xde\xc1\xa9\x03\xd5\x13\xc2\xb7\x46\x08\xbc\x0e\x9a\x87\xf6\xde\x0c\x8d\x28\x26\x51\xef\x29\xef\xf7\x3c\x3a\xd9\x38\xf9\xe7\x9f\xd3\x87\x94\xd0\x3f\x7a\x23\x17\xfe\xf9\xe7\x9f\x7f\xfe\x67\x67\xfe\x3f\xfe\xf9\x67\x7a\xfa\xe8\xcc\xa1\x86\xc9\x7d\x8c\x41\xb7\xce\x9a\x74\x83\x71\x0a\xfb\x9c\x38\xff\xfc\xe3\x50\xeb\xd9\xcf\x83\x36\x52\x7b\x2e\x8a\xa7\xba\x71\x83\xf7\xbe\xf4\x09\x52\x0a\x9f\x73\x85\xf9\xcb\x7f\xba\x9d\xee\xf1\x23\x88\xda\xe5\x6e\x67\x64\xa9\x65\xd7\xd0\x14\xa6\x4a\x16\x2b\x0c\x8e\x17\x9e\xe3\x00\x92\xcb\x9d\x06\xb3\x1e\xce\xb3\xc9\xc4\x31\x6b\xe2\x38\x29\xe4\x44\x24\x5c\xbe\x4b\x29\xf8\xc2\x3b\xd0\xe0\x9f\xd9\x8f\x77\xe5\x8a\xf4\xe7\x4c\x91\xce\x97\xa4\x50\xa4\x7f\x7b\x3f\x94\x7b\x99\x0f\x97\xf0\x4b\x7e\x8d\x5e\x4e\xe3\x2b\xd6\xe7\x3c\x35\x3b\x20\xa1\x34\x1b\x0b\xa5\xad\xdb\x4d\xc0\x83\x19\xe2\x60\xd5\xde\xf7\xc5\xf2\x9e\xb6\x4a\x62\xc3\x18\x9e\x7a\xeb\x03\xc8\x41\xa2\x51\x22\x2a\x46\x89\xf5\xc7\x06\x1e\xb2\x5b\x9e\xd9\x36\x78\x76\x4a\x97\xf3\x50\x55\x8c\xc0\x6f\x2b\x14\x33\x61\xa3\x6c\x51\x31\xfb\xd4\xe6\x87\x43\x7c\xf1\xa6\x2a\x7f\x07\x91\xf9\xf3\x12\x2f\xac\xf3\x1d\x08\x59\xd2\x73\xfe\xc7\xa3\xcc\x2d\x3e\x6c\x89\x67\xf2\xab\x16\xe3\x7d\x36\x90\x89\xe7\x03\x7f\xe7\x19\x6a\xf4\x91\x16\x03\x78\x08\x02\x8f\x70\xab\x4d\x44\x01\xb4\xa6\x40\x71\x03\x9e\x82\x8f\x77\xf6\x50\xab\xf8\x16\x43\x88\x5f\xc1\x48\x29\x7e\x50\x7c\x81\x5e\xa6\x6c\x46\xae\xcd\xb6\x0c\x28\xdc\xb0\x19\x79\x1f\xe1\x67\x2f\x17\x11\x8a\xf0\xb6\xdd\xc4\xfb\x19\x01\x7f\xe9\xdd\x18\xe4\xa6\x15\x6f\xca\xd7\x8c\x6c\x9e\x47\xf0\x01\x73\x2e\xfd\x88\xd0\x1e\x42\x46\x99\x95\x7d\xb4\x65\x6f\x8d\x65\x8a\xe6\xe1\x12\x61\x2b\xbb\xae\xca\xae\x6b\x68\xd7\x55\xc3\x03\x17\x45\xa6\x25\xbb\x9e\x8b\xe4\xd6\xda\x70\xdc\xd4\xf0\x89\x57\x1f\x9c\x2f\x6d\x8e\xcd\x45\x32\x9c\xb0\x3b\x72\x16\x43\x68\x33\x78\x1a\x35\x6d\xcc\x26\xa5\xa0\xcc\xa7\xe6\xa5\x77\xc3\x26\x2e\x07\x5f\x7a\x76\x43\xe7\x03\x7e\x63\x07\x3c\xae\x9f\xe0\x75\xd8\x1d\x79\x5d\x42\x0d\xe8\x70\xcc\x3a\xcb\x50\xdf\x79\x53\xd6\x41\xac\x4a\x80\xaf\x17\x00\x5a\x3b\xec\x9c\xdd\x91\x2f\x25\x40\x23\x54\xd8\xf9\x32\xc0\x1d\xef\x7c\x01\xdc\xc7\x12\xdc\xd2\x06\xc9\x57\xbd\x98\x18\x0c\xd2\x68\xd2\xe2\x2a\x1f\x32\xfb\xb3\x55\x44\x75\xbc\xdd\x6a\xb4\xc7\x5f\x31\xbb\x90\xf0\xbd\x51\x29\xbc\x90\x64\x55\x34\xe8\x2d\xd9\x97\xf9\xe9\x99\xdd\x9a\x0f\xd6\xfc\x00\x19\x1a\xa0\x2a\x6c\x02\xfa\x1d\xe9\xf4\x9e\x38\xe8\xfd\x00\x19\xe2\xe7\x97\xed\x71\x18\xc6\x69\x65\xef\xfc\xec\x88\x2c\x9a\x1e\x8a\x33\x71\xe7\xc0\x5f\xb1\x21\x9f\x8f\x59\xfe\x68\x1d\xb6\x5e\x78\xce\xb0\x26\x9a\xc9\xd6\x40\x56\xfb\x71\xff\x03\x49\xf0\x0a\x20\x05\x65\xa4\xd5\xc9\xa9\x91\x74\xc5\x51\xbd\x58\x8d\xff\x54\x73\x2d\x9c\xa6\x04\x7e\x4b\x49\xd3\x64\x48\x1c\x71\x77\x1d\x29\x31\x76\x16\xf3\xbb\x98\x32\x1e\xe8\xe8\x46\x38\x4b\x8b\x6f\xca\xae\x85\x1c\x47\xf2\xcc\xa1\x78\x36\xec\x5f\x64\xe3\x4f\x5a\xc7\x1f\x06\x44\x3e\xc2\xe5\xe0\x8d\x03\x90\x29\x04\xe1\x7f\xf0\xa1\xa9\x9e\x5c\xcc\x76\x63\xf3\x27\x08\xd7\x8f\x30\x2b\x5f\x59\x53\xd8\x6c\x63\xa0\x98\x02\x6d\x03\xaf\xe3\x65\x3c\xcb\x44\x66\x05\x21\x05\x21\x12\xd2\x8c\x24\x21\xf0\xd0\x58\x0e\xbb\x62\x3b\xfb\xda\x5b\x18\x36\xde\x70\x4e\x42\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\xb1\xac\xed\xeb\xc7\x7f\x68\x48\x18\x11\x1b\x44\x60\x29\xde\x38\x13\x8f\xb6\x76\x77\x36\xed\x3d\x34\xfb\xfa\xe9\xee\xbc\x4f\xa9\x79\x3d\xef\x03\x67\x62\x83\x6c\xed\xee\xfc\x91\xf4\x48\x92\x5d\x57\x4b\xb2\xeb\x6a\x68\xb6\xee\xfc\xc1\x7b\x9b\xf4\xd1\x60\x67\x6b\xde\x87\x88\x05\x3d\x12\xec\x0d\xfa\xa3\x2d\x6f\xe3\x69\xce\xbe\x1f\xf8\xcc\xe3\x1b\x84\x0c\x76\xb6\xfe\x08\x4c\xe5\x1d\xd3\xf3\x00\xf8\x67\x2f\x02\xff\xc6\x4b\x7a\xdb\xfd\xfe\x1f\xba\x47\x36\xf7\xa2\x51\xdf\x1b\xd0\x34\x05\xbf\x7d\x8d\x43\x32\x23\x71\x68\x4d\x16\x97\xcf\x52\x0a\xd3\xd6\xca\x78\x1f\x6f\x73\xdb\xce\x6e\xd1\x0c\x76\xfb\xa8\x33\xdc\xac\x6e\x37\x10\x5b\x76\x45\x30\xa4\x7f\x75\xdd\xdd\x7e\x09\x1e\x33\x0b\x2c\x57\xcf\x76\xc8\x02\xfe\x9f\x17\x2f\xce\xf5\x17\xb4\xbb\xc1\x82\x9d\xb1\xb9\x78\xe5\x6d\x41\x80\x6d\x2f\xc8\xa5\x9d\x85\x6b\x6b\xbb\x0b\xe2\xe7\xf1\xc2\x65\xb4\x27\x8b\xf7\xce\x9e\x2e\x5e\x31\x1b\xf4\x17\x37\xeb\x60\x80\x17\x0d\x7e\x63\x8a\x0a\x22\x1f\x88\x2d\x7b\x89\xff\x37\x17\xda\xbf\x31\x12\xa0\xad\xf2\xe2\x45\x81\xb3\x90\xcd\xc8\x55\x08\x7d\xe8\x50\xb8\x6e\xda\xf2\xf9\x6c\xef\xc9\xd1\x2d\xb9\x0e\x41\xfe\xfb\xdf\x03\x78\x43\x94\x21\x8f\x41\x57\x8e\xde\x10\x0d\x8a\x7a\x9a\x7a\x86\x1f\xce\x5a\xb1\xb4\x8d\x41\xe1\xf7\x6a\x28\xdc\xae\xe8\xeb\x0d\x99\x91\x59\x08\x72\xe3\x0b\x7e\x7f\xd9\x7e\x9a\xc0\x6e\xf4\xbb\x15\xf0\x6f\x0d\x7c\xa7\xef\xc0\x31\xcf\x68\xf1\xb2\x91\xb9\xcd\xc8\x5d\x08\x86\xd4\xcf\x43\x38\x0b\xed\xd1\xf7\x86\xd3\xc3\xd7\x9b\xbf\xc5\xab\x07\x0b\xfc\x79\x73\x81\x14\xb7\x16\x48\x71\x7b\x81\x14\x77\x16\x48\x71\x77\x81\x14\x1f\x2f\x90\xe2\x93\x05\x52\x7c\xba\x40\x8a\x83\xfe\x22\x2d\x0e\x96\x72\x6e\x0e\x36\xd3\x94\xcc\xc8\x38\x1f\x73\x6d\xd0\x33\xe2\x97\x73\x71\x5c\x79\x3d\x2d\x5f\x7b\x95\xd7\x93\xe6\xd7\x9d\xf2\xb5\x9b\xbd\xde\x82\x19\xb9\x29\x5f\x7f\x77\x52\x78\x66\x68\xce\x8f\x40\x86\x70\x19\x52\x78\x11\xb2\x97\x12\x0e\x57\x0b\xd2\x68\xec\xd8\xf4\x14\x2f\x42\x1b\x10\x21\x8d\x34\xf0\x07\x59\x24\x4d\x76\xde\x37\x75\xc0\x46\x68\x1d\xc2\x8c\xe8\x10\x54\x88\x66\x29\x58\x49\x9c\x05\xe7\x3e\x43\x6d\x62\x66\x5f\x0b\x39\x2e\x5f\xf2\x7b\xfb\x32\xb9\x1e\x73\x2d\xc6\xe6\x7d\xad\xcf\x67\xd8\xe7\x75\x06\x31\x50\x82\x67\xb1\xc0\xa8\x8c\xf0\xbb\xec\x7d\x7c\x75\x25\xa4\xce\xdf\xde\x14\xfd\x63\x10\x71\x0d\xa0\x40\x80\x97\xf8\x4d\x37\x9a\xdf\xf5\x7f\x65\xa6\x27\x0f\x3d\xb6\x71\x46\xfb\x2f\xb3\x58\x63\x38\x5a\xb1\x6d\x6c\xb4\xe8\xc7\x0f\x47\x59\xb8\x68\x76\x20\x7d\xb1\x82\x17\xd4\xee\x02\x1d\xb4\x88\x61\xbc\x2b\x55\x0b\x1d\x2a\xb2\x4f\x9e\xe2\x65\x31\xa2\xd9\x21\xf2\xaa\x19\xb9\x08\xc1\xe1\xd7\xd7\x93\xc8\x7e\xf5\xfc\x11\x86\xe3\x03\x86\xd2\xf7\x6d\x90\x63\xe9\xd7\xb8\x25\x47\xf8\x59\x79\x78\x65\x33\xed\xed\x87\xec\xaf\x88\xbc\xd6\x14\x5e\x86\xec\x56\xc2\xbb\x26\x92\xc0\x0c\x1c\x01\xea\xaf\xc7\x21\x33\xda\x6c\x0a\xf7\xb5\x49\xa9\x65\xaa\x58\x6b\x89\xad\x9f\x91\x97\x21\x24\xb0\xf4\x99\x8b\x1f\x01\x09\xea\x89\xc1\xb1\xa6\x8d\x5b\xe7\xf0\x2e\x24\x81\x59\x2b\xd0\xb5\x38\xb5\x63\xbc\x44\x23\x30\x2a\xef\x87\x7d\x30\xe8\x99\x41\xfd\x08\x57\xe5\xc7\x9e\x91\xfd\x10\x6e\xc9\x7d\x68\x1d\x3a\xd2\x34\xc2\x75\xb3\xa1\x0d\x1f\x56\xac\x36\x36\xcd\x5a\xe5\x1f\xbd\xfd\xd9\x5e\xff\x81\x7f\xf4\x34\xa0\xef\xc9\x57\xd9\x37\x76\x70\xfe\xb6\x52\x78\x13\xb2\x5b\xf2\x21\x84\x52\x8f\x7e\x6e\xb0\x32\x6f\x32\x6d\xfb\x3e\xc8\x7e\x5b\x85\xfc\x3e\x80\x1f\x01\xf9\x19\xda\x4c\xa7\x21\x7b\x1b\x90\x37\x21\x85\x8f\x21\x0b\x5a\x32\x87\x40\x54\x22\x72\xe3\x05\xc0\xef\x3c\x0e\xfc\xde\x13\xe0\x0f\x3c\x09\xfc\xd0\x53\x10\xcc\x3c\x0d\xfe\xa5\xd1\x75\xae\x6d\x38\xcd\xfb\x1c\xb1\x4c\x8f\x5e\x5a\xcc\x3a\x83\x2e\xf4\x67\xaf\x5c\xcd\xec\x46\x7d\xae\x3e\x57\x4a\x06\x59\x49\xae\x3c\x57\x8a\x36\x97\xb4\xec\xe3\x80\x38\x9f\xe5\xa5\x8c\x6f\xe5\x9a\x9e\x5d\x0b\x8c\xc5\xc4\xaf\x22\x05\x78\x89\xa1\x81\x50\xfd\x8b\xcc\xc1\xf5\x35\x6c\xbb\xe1\xf1\x77\xd3\x0d\x8f\x32\xcd\x82\xce\xba\xa9\x5f\xe8\x78\xdb\xc8\x29\x2d\x85\xbe\x0b\xf1\xf6\x42\x79\xc1\xc2\x7e\x47\x27\x64\x77\xe4\x47\x36\x8d\x86\x09\xbd\x0d\xc9\xfb\x90\xc2\x81\xce\x56\xb5\x60\x59\xc5\x3a\x57\x98\xdb\x7d\x00\xb6\x75\x85\x2d\xbe\x0d\xc9\xd7\x2a\x80\x9c\x8d\x7e\xcd\xe9\xa6\x64\xb7\xc5\xab\x92\x47\xbf\x0e\x33\x88\x86\xab\xbf\x0d\x89\x19\xd5\x81\x36\xd3\xf8\x31\xa4\xf9\xff\xc1\x97\x26\x62\xce\x83\x78\x9a\xd8\x91\x03\xaa\x12\xc6\x88\x86\xb3\x86\xdc\x7f\x2a\xe0\x73\x68\x1d\x60\xdf\x5a\xd8\xca\xe0\x69\x66\x17\x7f\x0a\xd9\xc3\x37\x74\xa0\x04\xf8\xef\x18\xff\x45\x37\x60\xf0\x02\xe3\x5e\xfe\x6e\xd1\x2b\x3e\x63\x1e\xe7\x8f\x23\x87\xfd\x2f\xc7\x73\x98\xc5\xcf\x0d\xce\xf1\xf3\x9d\xb8\x14\x7f\xb6\xb7\x74\x20\x0b\xc7\xfb\x3b\xb4\x16\xf2\x5f\x61\x76\x41\xe0\x7b\x0b\xc6\x79\xdc\xa4\xf4\x57\x7d\x89\xef\xf1\xe2\x97\xf8\x94\x9f\x5d\xbe\xd0\x7e\x1b\x83\xcd\x3e\xbc\xd3\x52\xfe\x24\x2b\x4f\xfc\x36\x65\xec\x39\x27\xa8\xbd\xf6\xde\xd9\x5b\xe6\xff\x5f\xee\xbe\x85\xb9\x6d\x1c\xf9\xf3\xab\x28\x5c\xdd\x2e\x50\x69\x31\x52\x5e\x33\x61\x96\xe5\x4a\x6c\xc7\x76\x1e\x4e\x62\xe7\xbd\x97\x4b\x01\x7c\x58\x8c\x29\x52\x06\x41\x4a\x72\xa2\xcf\x71\x1f\xe8\xbe\xd8\x15\x1a\xe0\x4b\x22\x15\xcf\xfc\x67\xff\xb7\x75\x35\x53\x8e\x48\x82\x00\x08\x34\x1a\xdd\x8d\xee\x5f\x53\x60\xdc\xa4\x3d\x5c\x58\xf0\x70\x7c\xff\xf7\xe0\x01\x6e\x8b\xbe\x05\x88\xab\x81\x17\x53\x0b\xee\x3d\x34\xbf\x67\x96\x56\xef\xd4\xd6\x69\xa1\x10\xfc\x95\x82\xd7\xd5\xa1\x41\x62\x4b\x11\xcd\x08\x5d\x43\xd4\xfd\xfc\x9f\x63\x63\x61\xf4\x78\xb7\xb1\xa2\xd4\x36\x19\x3a\x05\x6b\x54\x3b\x86\xa8\x76\x0d\xbb\x0c\xbb\x13\xfc\x1c\xef\xe5\xb7\xc9\x3b\xa6\x7f\xd3\xdb\x44\xde\xb6\x06\x16\xa5\x4e\x0e\x28\xb9\x07\xda\x70\xa7\x3a\x6d\x81\xfe\x74\x60\x9c\x6a\x7c\x9c\x94\xbb\x97\x21\x84\xdc\x4c\x2a\xef\x1c\xdc\x0f\x4e\xc8\x15\x83\x56\xc3\x9b\x71\x57\x31\x4b\xce\x89\x65\x51\xc5\x31\xcd\xaf\x55\x75\xeb\xba\xfc\xc5\x27\x48\xa3\x67\xce\x50\x71\x51\x7d\x73\x0d\x85\xaa\xe0\x8d\x73\x6b\xa2\xf8\x7e\x59\x52\x54\x8f\x63\xde\xed\x87\xfa\x48\x7b\x48\x7f\xd6\x83\x21\xea\x05\x75\xd0\x69\xc2\x5c\x90\xab\x10\x04\xe8\x6c\x53\xd5\xf3\xda\x6e\xbf\x29\x3c\x7f\x97\xe4\xd6\x64\xd3\x34\xaf\x6e\x8e\xb7\xb8\x2e\x42\xa5\xa9\xb1\xf3\x7b\xba\x2a\x1e\xd7\xbb\x9b\x5a\x79\xe6\x43\xd1\x5a\x64\x3e\x15\xf3\x11\x0c\xfb\x57\xc8\xe0\x8a\x64\x1c\x7e\xe8\xe1\x4d\xcc\xe8\x96\xbe\xb7\x11\x27\x08\x1e\x42\xcb\xc1\x4e\xd5\xb3\x9c\x83\xba\xab\x73\x65\xb0\x33\x67\x95\x12\x81\x89\x71\x0b\x8e\xd0\x79\xef\xcc\x59\x53\xcc\xe1\x40\x12\x9f\xe3\xe9\x88\x99\x98\x94\xeb\xe8\x19\xa5\xd1\xf5\x2e\x1f\x5c\x3b\x23\x16\x6a\xf8\x84\x19\x2e\x1d\x1c\x66\xcb\x52\xff\xdf\xc2\xcc\xa0\x17\x9a\x3c\x2c\x4b\x91\x86\xfa\x7b\xed\x3c\x65\x64\xdc\x20\x86\x19\x57\x8d\x9a\x9b\x97\x78\x8c\x31\x47\xfe\x35\xef\x5c\x27\xcf\x02\xb5\x40\x12\x4a\x77\xa0\x4a\x1c\xe4\xe8\xf1\xbf\xea\x1a\xcf\xed\x74\x2b\x26\xc8\xec\x71\xed\x88\x53\x2a\x23\x1a\x3b\x59\x35\x24\x4d\x14\xda\x8a\x24\x10\x68\xf4\x3a\xa5\x1e\x6e\x4f\x38\x12\xe5\x1b\xd0\xc1\xd7\x5b\xb4\xb9\xe2\xb0\x54\xbb\xd1\x8a\xf7\x9b\x22\xaf\xc2\x5a\x2a\x9e\x73\x8d\xca\x07\x07\x08\xb7\x87\x9e\x17\xb0\xdc\x9e\x11\xdd\xf2\x35\xc1\x60\x4c\x38\x42\xcd\x52\xfb\x6a\x32\x8d\x0b\xc9\xeb\xcf\x95\x26\x74\xd8\x60\x1d\xd6\xce\xfa\x27\x8a\x1b\xe2\xc9\x14\x55\x5a\x7d\x60\x86\x78\x9f\x25\xff\xc0\xd1\x35\xb1\xbb\x73\x96\x49\x3d\xc6\x28\xfd\x5d\xf2\x5e\x7f\xe4\xdd\x43\x8d\xc7\x1b\x15\xfc\x44\xab\x8c\x2c\xcb\x44\x78\x68\x53\x79\x15\x35\xcb\x04\x65\x99\x14\x7d\x62\xb7\x71\x1a\x4f\x72\x92\x97\x65\xc2\xa6\x17\xaf\x81\x48\x55\x1f\xc7\xcc\xb4\x5e\x92\xa4\x84\xd3\x06\x66\x26\xf7\xc9\xf6\xe4\x62\x7e\xe4\x09\x4e\x2e\x2b\x34\xff\x39\xc3\x39\x66\x4b\x8c\xd0\xf0\x56\x08\x48\xcb\xae\xcb\xa6\x4e\x73\x52\x90\x4b\x0e\x3b\x03\xfc\xae\xc8\x85\x5a\xda\x85\x92\x30\x97\x8e\x54\x4b\x24\x57\xcb\x83\x55\x02\x67\xb0\x6e\x11\x03\xfa\xfa\x2f\xb8\x22\x0a\x0c\xca\x52\x4f\x90\x3a\xd4\xcc\xe7\xf8\x63\x45\x96\x1c\xd4\x4f\xf0\x4a\xb2\xd9\xe7\x46\x11\x39\xe3\x6e\x98\xc0\x21\x77\x79\x02\xe7\x7d\xab\x1b\x33\x44\xd8\x2c\xbf\x4d\x92\x11\xe6\xca\xf3\x1c\x81\x89\x4a\x84\xce\xfd\x0a\x9c\x3b\x42\x27\x70\x15\x36\xa2\x1c\x7c\xe7\x6e\x9a\xc0\x29\x77\xbd\x04\x4e\xb6\xab\x8d\x42\xb2\x20\xa7\x1c\x26\xe3\x09\xea\x02\x3f\x7f\xe2\xe5\xc3\x47\xda\x22\x54\x2e\x1e\x4c\x6d\x82\x4f\xee\xdf\xc3\x8c\x10\xa6\xdc\xfd\x07\x78\xb5\x27\x6f\x4f\x1c\x89\xde\x38\xdf\xb9\x4e\x01\x61\x46\xf1\x90\xa8\x31\xdd\x1b\xe5\x4e\x5e\xe3\x26\x53\x38\xe8\x65\x5f\xba\xda\x87\xd8\xfc\xde\x8a\x9c\x70\xc0\x3a\xd1\x27\x4b\xb1\x42\x07\xef\x19\x1f\xaa\x97\x7c\x67\xb2\x9e\x00\x9d\x5d\x02\x6d\x50\xee\xca\xe6\x74\x6b\xac\x01\xf3\x72\x0d\x56\x6a\x88\xbb\xc1\x6b\x0e\x89\x84\x32\xa1\x9b\x4e\x13\x23\xe9\x3f\xab\x97\x92\x46\x4a\xad\x88\x60\xdc\xee\x39\x07\x86\x88\xf4\x14\xde\xf1\xdd\xda\x5b\x33\xa3\x70\xc3\x45\xfe\xba\x7f\xe5\x96\x28\xf7\x0c\xdd\x96\x0e\x38\x78\xb8\x2c\xd4\xd7\x45\x4d\x8c\x13\xfd\x65\x4b\xf2\x8e\x03\x43\x62\xb0\x59\x3e\x22\xd1\x6d\xcc\xf8\x9a\x00\xb3\x3d\x5a\x66\xb1\xb1\x39\x44\xdd\x09\xcd\x18\x88\xb2\x94\xd7\x28\x73\x49\x5e\xaa\xe1\xd7\x70\xd2\xaa\x57\x4d\x3e\xf0\xa3\x6b\x70\x19\x4a\xa4\x15\x4f\x80\xd0\xbd\x66\x04\x43\x28\xb0\x75\xbd\xb2\x9b\x5c\x20\x44\x48\xdb\xcd\x1a\xaa\x91\x4e\x49\xa8\x78\x21\x8e\x75\x64\x84\xa6\x6f\x7c\x33\xcd\x7a\x03\x4f\xc8\xfd\xc1\x12\x47\xf1\x38\x0a\xec\xa9\x5a\xce\x87\x8a\xb9\x5c\x4b\x0a\xec\x55\x79\xff\x35\x86\xe0\x7a\x14\xf8\x43\x47\x00\xfb\xa8\xef\xaf\x37\x31\xf7\x34\x75\xfe\x5e\x65\x85\x6b\x88\x13\x98\x03\x48\xdc\x9e\x3c\x6e\x12\xf2\xe4\xee\x18\xf3\xf7\x30\xba\x87\x03\x17\xd8\xfc\x21\x04\x36\x7b\x85\xce\x11\x87\xdc\x64\x0c\x84\x44\x7d\x9e\x2a\x3f\x99\x74\x96\xff\x08\x6a\x7f\x3a\xe3\xf0\xfb\xe6\x1b\x8f\x7e\xef\x7c\x21\x29\x5f\xb8\xdb\x78\xa1\x20\xd7\x75\x89\xa7\xea\xcf\x6b\xf5\xe7\x10\xae\x89\x80\xb1\x2a\x52\xae\xd1\xde\x92\x58\xe7\x64\x5c\x0d\x00\xc2\xe3\xe0\xbe\xb5\xa6\xb0\xcf\x61\x9f\x53\x78\xcd\xdd\x16\x80\xd6\x01\x53\x13\xf4\x67\xb2\xcd\x9d\x6a\x63\xac\x92\x83\x29\x85\x2b\xbe\x9d\xbd\xc8\xfc\xf1\x72\x18\x77\x05\xf7\x36\x40\xc2\x5e\x77\xa5\x8f\x1d\xcc\x10\x64\x0f\xdd\xb2\xb1\x61\x0e\xe7\x39\xa5\x26\xbd\xad\x28\x93\x82\x9d\xe7\x26\x45\xd0\x53\x5e\x25\x89\xb9\xe2\x14\x0e\x19\xa9\x51\xb2\xfc\x5c\xa0\xdd\xaa\x82\xc9\xa2\x14\x8e\xb9\x09\x6f\x7b\xd6\xcb\xf0\xf0\xf8\xf5\x83\x43\xa4\x9b\x98\x8d\x44\x09\x37\x26\x32\x4d\xda\x6c\xed\x1c\x73\xba\xae\x4f\x0d\xdf\xfc\x01\x71\x76\x45\x9e\x71\x98\x63\xde\x00\x2d\xd3\x8a\xf5\x1a\x5e\xf5\x54\x30\xd1\x5b\xe7\x52\x07\x37\xae\x70\xeb\x64\xd7\x88\x7f\x68\x36\xd0\xb3\xc7\xb5\x19\xa6\xae\x9a\x15\xa8\x60\x94\x37\xd4\xcc\xe8\x8b\xa7\x1c\x18\xca\xbe\x78\xb5\x2c\x77\xc3\x1c\xa5\x4c\xa1\x23\x01\x3e\x48\x78\xc3\xc1\x43\x09\x17\x8b\x1d\x31\xcc\x4e\x0b\x1f\xb9\x4b\x96\x91\x9b\x84\x10\x08\xb2\x88\x5c\x6b\x1e\x88\x2c\xca\xe4\x81\x96\xf2\xf7\x45\xc0\x64\x2a\x2c\x0a\x6f\x93\x7f\x2d\xa2\xaf\xee\x8f\xc0\xc9\x05\x08\x67\x19\x01\x73\x98\x58\xc3\x8b\x84\x2c\x22\x4a\xe1\xf9\xaf\x46\xbe\x54\x9a\xd4\x44\xbf\xe7\xed\x00\xf2\xa0\x15\x98\xb1\xdf\xeb\xc5\x8e\x6e\xb2\x74\x4f\x91\x0c\x06\xf2\xa1\xec\xfd\x61\xa3\x65\xb9\x2b\x66\xad\x0c\x5c\x39\xc6\xa0\x16\x30\x0a\x81\x9a\xf8\xc6\xf9\x7f\xe0\x1e\x31\x82\x69\xa6\x29\xe4\xea\xb7\xb4\xd9\x35\x0e\xaa\xd8\x86\xc7\x41\x79\x76\xca\x75\xbe\x15\x04\xa9\x6e\x08\x9b\x2b\x45\x30\x7a\xea\x23\x4e\x9a\x89\x24\x85\x3d\xdc\xd3\xcf\x51\x84\x20\xd5\x03\xec\xa1\x9a\xa5\xe7\x5c\x6d\x4a\xf6\xca\x4c\xda\x73\xb5\xe5\x49\xdb\x5b\x55\x9d\x2d\x5d\x7b\xd4\xb2\x0e\x74\x37\xbd\x95\x9e\x7b\xfc\x80\xff\x57\xdd\x45\x52\x34\xdd\x65\xd7\x55\x77\xef\x3b\xcc\xe8\xef\x8d\xae\x1a\x61\xf8\x29\x57\xdd\x8d\x5c\x12\xeb\x0e\xe6\x6a\xd3\x0d\x28\xc5\x56\x71\xec\x9d\x94\x93\xb8\xd1\xa1\x66\xbb\xac\xdd\x6e\xd4\x6e\xf7\x81\xb3\xf9\x8a\x5e\x34\xf5\x3b\x7a\xd9\x54\xa3\x87\x6f\x37\x57\x4a\x6b\xd4\x1f\xb6\x49\x69\xa9\xdb\x44\x04\x25\x9b\x2d\xab\x62\xbf\x6d\x17\x33\x0b\xb7\x59\xea\xf7\x76\xa9\xa2\x55\x59\x51\x15\x7b\xb4\x5d\xac\xaa\xac\x2e\x35\xd9\x26\x72\xf4\x44\xcb\x5c\x53\xe1\x19\xd5\x9e\xec\x99\xda\x44\xcb\x98\xae\xf2\x54\xaa\x04\x44\xe2\x10\xba\x0b\xf2\x9e\x9b\xd7\x3a\x98\x39\xa2\x85\x23\xdb\x7b\xce\x21\xd5\x5c\x6f\x4d\xd7\xba\xca\xc7\x1b\x7d\x08\xd7\x35\xac\xe7\xcd\x2b\x6e\xf0\xd3\x1b\xd4\x7c\xb7\x72\xfb\xe2\x8f\x6f\xd4\x06\x17\xba\xf3\x98\xef\x4f\xdc\xa4\x89\x7b\x37\xeb\xbc\xe2\x70\x36\x17\x3b\x2b\x6c\xc2\x27\x65\x50\xdc\xbc\xd7\xec\x8d\x53\xec\xaa\x19\x85\xbf\x78\x4d\xe1\x33\x77\xc9\x65\xe4\x3e\x65\x70\x9d\xb4\x76\xe3\x84\xbc\x4c\xc8\x65\x44\x0e\x98\x0c\xec\x24\x5d\x10\xed\x70\x48\xe1\x6d\xb7\x10\xdd\x01\xd5\xa0\x3d\x22\x9f\x28\x6d\x8c\x1d\x57\x09\xba\x2b\x0b\x9c\xf6\x72\x3a\x76\x5e\x99\x02\xe0\xe5\x4e\x1a\x35\x31\x91\xb2\x9c\xcf\x22\x69\x80\xb0\xc4\x0c\x06\xe7\xda\x34\x3c\x88\x32\x7c\xbe\x0a\xe4\x00\xad\xeb\xb6\x55\xfa\x42\x6e\x85\xa2\x9a\x76\xbc\xdc\xb9\x8a\x3a\x7c\xe6\x24\x87\x05\x8a\xae\xa7\xa1\xb6\xf7\xc1\x47\xae\xb4\xdd\xa5\xba\x77\x14\xc1\xe7\x10\x8a\x48\xdf\x68\xb8\xcd\x3d\x72\x34\x2f\xba\xe7\xba\x2e\x89\x34\x88\x84\x92\x90\x4b\x37\x38\x79\xdb\xfa\xdb\x9d\xf2\x58\xed\x8e\x75\x3b\x52\xea\xf3\x2c\xdd\xee\x93\xea\x92\xd7\xed\x52\x77\x64\xcc\x4e\x2b\x92\xf0\x0a\xb1\x00\x3b\xfb\x99\xd3\x4d\xce\x71\x4d\x7e\xb0\xa9\xf1\x12\x7c\x11\x02\x3b\x76\x16\x64\x58\xbd\xa6\x53\x15\xf3\x47\x0e\x76\xce\xcb\x9d\x17\xe1\xba\xe9\xec\x8d\x4a\xd6\xe3\x46\xeb\x0b\xf2\x41\x0d\x07\x7e\x99\xee\x45\x80\xe3\xb4\xe5\xc4\x77\x0f\xa3\xf2\x98\x3d\xdc\xab\xe7\x93\x84\x2e\x72\x6f\x9b\xe9\x48\xa0\x09\x66\xff\x61\x4b\x4c\xff\xe3\xad\x30\xff\x0f\xbb\x06\x5f\xfd\x73\x06\xc6\x26\x1a\x96\x42\x0b\xe7\x24\xdb\x36\xdb\xad\xc8\x94\x9b\x64\x3f\x0d\xdb\x5d\x4c\x51\x70\xe1\x95\xe0\xe2\x73\xf0\x1b\xa6\xb9\xc2\x98\xe6\x70\x30\xaf\xa5\x9a\xc9\x05\x23\x42\x89\xae\xd4\x51\xdf\xd9\x70\x2a\xd6\x3c\xad\x49\xac\xe9\x36\xb1\xc6\x9a\x40\x59\xa2\x21\xbb\xa2\x6c\x1e\xb3\xd5\x80\x85\xa1\xc6\x01\x79\x82\xce\xa6\x3b\xc9\x14\x1a\x04\x6f\x48\x96\xb9\x69\x97\x0f\x2a\x92\x6b\x4d\xa8\x5f\x42\x43\xa8\xe8\xdc\x79\x45\xde\x86\x65\xd4\xed\x51\xa8\xe8\x13\x39\x34\xed\x8c\xdb\xd4\xf5\x25\x3b\x42\x01\x54\x89\x69\xa3\xc4\x96\x47\xa2\x7a\x2c\x6c\x36\xad\xe9\x6b\x45\x3e\x68\xfa\xd2\x6b\x77\x9b\xb8\x90\xc5\x84\x65\x96\x26\xf0\xd7\x14\x3e\x71\x73\x44\x79\xc4\xdd\x4d\x3c\x2e\x73\x22\xfe\xa2\x57\x36\xd4\xe7\xe1\x07\x87\x2f\x0f\xdf\x1d\xb6\x01\x94\xbe\x74\x99\x2f\x77\x1f\x2d\x95\xa4\x25\x6c\x3e\xa1\x3d\xc7\x4c\x2f\x94\xe4\x73\xc4\xf5\x31\x53\x92\xb9\xcf\x3d\xf2\x3e\xa4\x20\xb2\x3f\xd8\x5a\x07\x28\xc7\xd6\x69\x56\x92\xe9\x66\x64\xd6\xe7\x3f\x55\x67\xc2\xa8\xe6\x36\x8c\xca\x78\xe6\x76\xf6\x8a\xc1\x8b\x70\x73\x97\x8f\x36\xa7\x34\x8d\xf4\x19\xe4\x9a\x42\x90\xed\xc6\xe9\xc8\x7b\x9e\x97\x38\x1d\x6c\xbb\xcf\x55\xcc\xf5\x65\x19\xb5\x26\xed\xe1\xdf\xff\x7e\x88\x56\x53\xfe\x5d\x0b\xe3\x5e\x57\xbd\x83\x8f\x11\x61\x99\x06\x90\x8a\xfa\x2a\x5e\x11\x2f\x43\x18\xa8\x52\xfb\xe1\x2f\x1d\x8c\x81\x02\x16\x3a\x12\xb8\x89\xc6\x48\x33\xf7\x82\xfc\x6b\x02\x77\x61\xfc\x95\x42\x98\xf5\x58\xa6\xb6\x76\xae\xbb\x9b\x4b\x23\x74\x56\x44\x66\xdd\x11\x19\x1f\x24\x44\xaa\xbf\x90\x66\x74\x0d\x06\xc1\xa7\x3b\x4c\x46\xfb\x2b\x1b\x2f\x6f\x61\xb3\x03\x0a\x3c\x44\xa6\x1d\xea\xd5\xbe\x20\x22\x83\x1c\x24\xe4\x59\x3d\xa7\x95\x3d\x75\x83\x45\xf0\xd0\x21\x9e\xc1\x2f\x9a\x6c\xbb\x96\xe3\xa3\xc7\x3d\x2f\x36\xda\xd4\x1b\xe2\x82\x7c\xe1\x90\x83\x07\xe7\x01\xf9\xc4\x15\x8f\x6d\xec\x66\x41\x73\x37\xb3\xd4\x46\x56\xef\x84\xda\xad\x3a\xd2\xce\xda\xed\x82\xc6\x25\x5a\x7f\xa8\x8e\x6a\xdb\x1a\x8c\xa8\xf6\x8a\x0e\x32\x48\x7b\x9d\xa1\x9b\x5e\xe2\x6a\x6a\x79\x0f\x4d\x96\x67\xa8\x59\xcf\xf3\x12\xcf\xb1\xe8\x5a\xc4\xfd\xaa\x60\xb5\x27\xea\x4f\xca\xb2\x9b\xf3\xd9\x2d\x62\x9a\x6e\x96\x78\x50\x25\xee\xdd\xdc\x05\x78\xa8\xc3\x54\x1a\x53\xdb\xbb\xef\x62\x74\x00\x9f\x3a\x61\x44\x02\xbd\xfb\xd2\x72\x64\x79\xa6\xb7\x0d\x69\xb6\x0d\xed\xd1\x7f\x6b\x4c\xa1\xda\x40\x82\x7a\x03\x71\xea\x1a\x5f\x84\xaa\x46\xac\xae\xbd\x75\x54\x50\xb0\x1d\x1d\x9e\x20\x21\xe3\x58\xe5\x7a\xa4\xca\x29\xdd\xf5\x46\x4d\x6d\x6d\xc9\x29\xd7\x69\x2d\xe3\xcc\x58\x6d\xfc\xcc\xf8\x90\xa4\x22\xba\x88\x12\x16\x97\xee\x2b\x1d\xd3\xcd\xbe\x18\x97\x8d\x61\xb6\x0b\x14\x9d\x49\x27\x01\xb6\x50\x8c\xe3\xca\x09\x80\x4b\xcd\x3d\xa6\x5d\x24\x62\x5e\x41\xc7\x1b\xf6\x4d\x3b\xb8\x60\xe9\xd9\x36\xaf\x2a\xab\xbf\x74\x04\x7a\xea\xa0\x83\x66\xd9\x7d\xe6\xfb\x22\xc8\xb2\x1e\x5f\x9c\x99\xda\x0e\x60\x5e\x16\x9e\x07\xe8\x68\xf1\xdc\x23\x17\x19\xad\x5d\x32\xd0\xf9\xa3\xf3\xfd\x69\xa6\x41\x34\xb3\x5f\x42\xe0\xa4\x8e\x04\x36\x77\x72\x60\xea\xdb\xd9\x0b\x87\x01\x67\x8e\x00\x9e\xe9\x0e\x2f\xca\x3e\xe4\x73\x19\xa9\x06\x2a\x07\x10\x2f\x4d\xc2\xe8\xc2\x02\x3f\x2b\x9d\x8b\x02\x91\x45\x69\x72\x92\x84\xa9\x65\x6e\x5d\xa4\x1f\xf4\xcd\x46\x3f\x79\x1e\xc5\xfe\x01\x3a\x00\xb5\xef\xbd\xcf\x02\xd1\xbc\x27\x58\xe2\x4d\x1b\x37\x44\x50\x44\x1b\x75\x15\x8d\xda\xbf\x79\x64\x95\x95\xde\x26\xa6\x8b\x71\x9e\x21\x24\xd7\x3c\x53\x8f\x87\xfa\x31\x2c\xfb\xf7\x95\xf6\xfe\x5d\x4a\x26\x3a\xff\x15\x82\x68\x2d\xb2\xf6\x26\x2e\xd4\x26\xae\x8f\x09\x2e\x7b\x78\x4e\x89\x97\xf5\x64\x93\xa0\x9a\x90\x6d\x7b\x5a\xe8\x5f\x66\x60\xdd\x61\xf3\xe8\x4e\x71\xf7\x8e\xa5\x05\xbf\xcb\x0c\x9e\xb0\xc6\xba\xe4\x97\xce\x0f\xae\xd9\x8c\xe1\x87\x14\xf6\x3b\xb7\x52\x14\x7b\x3f\x45\x2d\xcd\x4e\x67\x9c\x4b\xa4\x1d\xa7\xda\xa7\xcf\x4d\xea\xf4\x72\x91\xa8\x6e\xdb\x22\x88\x53\xe6\x93\x5b\x13\xb5\xfe\xe8\x1a\xce\x76\xec\xf2\xfb\x3a\x8c\xfd\x7a\x3b\xca\xea\x81\x61\x15\x97\xe4\x6d\x0a\xfb\x98\x6c\x6c\xa9\x2d\x97\x18\xa1\x84\xe1\xcf\x5b\xfb\xd3\xd2\xc9\x95\xee\xf0\xc9\xf1\xc0\xbb\x72\x32\x49\x3c\x74\x39\x69\xdb\x1f\x3c\x88\xdc\x4b\x12\x66\xf0\x09\x33\x95\x16\xa6\x56\xb5\xb0\x71\xb3\x51\x7b\xdf\xf6\x96\x53\x56\xea\xab\x4a\xc1\x2b\x9c\xb4\x64\x92\x4b\x06\x95\x20\x55\xfb\x7c\x97\x9a\xda\x95\x33\x95\x6d\x45\xe2\x09\x23\x71\x56\x0b\xdc\xbf\x39\xfa\xf8\x34\x41\xad\x67\x41\x8a\x0c\x8c\x08\x15\xae\x55\xff\x16\xaa\x5f\x08\x89\xf0\x98\x35\x21\x11\xea\x06\x86\x92\x84\x14\xbc\x05\x86\x76\x61\x97\x2e\x1b\x5d\xd2\x1a\x67\xd1\xc1\x41\xbd\x2b\x27\x96\xa4\xa8\xf4\x1c\x24\x9a\xa3\x94\x08\x9b\x9f\x6a\x7d\xb1\x88\x94\x26\x54\xa9\x6e\x3a\xba\xaa\xb3\xa2\x42\x92\x78\x5b\x61\xfa\x94\x92\xb8\x3b\xf4\xab\x7c\xef\x79\xde\xda\xa5\xee\x76\x07\x87\x25\xb5\xa8\x3a\xb9\xd7\x2c\xb2\x9f\x91\xe6\xb3\x9e\xa0\x34\xd9\x88\xe7\xab\xca\x3e\xc4\xcf\xf1\x71\xdc\x87\x2e\x06\x20\x7a\x9c\xf8\x25\xc0\x8a\xbf\x19\x4b\xc7\x3f\x39\x57\x6a\x68\x3e\xa1\xf6\x34\x5c\xb7\xa4\xb5\xc9\xfd\x66\xcb\xdb\xaa\xd2\x82\x3c\xc9\xb4\x4c\x03\x41\x4b\x3e\x9b\x6a\x02\xd7\xe2\x0e\x5f\x02\x36\x80\x90\x24\xac\x23\x1a\x8c\x2f\x4d\x34\x18\x6b\x59\x67\x67\x9a\x9e\x75\x25\x5e\xa1\x2b\x51\xf4\xfc\x98\xb9\xb3\x6d\x8a\x29\x9c\xd4\x9d\xd5\xe2\x53\x8b\x7e\xb1\xbe\x0b\x4d\x86\xa6\xbe\x85\xae\xe8\x62\xbb\xa2\x85\x93\xb9\x17\x75\x45\x4d\xaa\xd3\x6a\xf1\xdc\x5d\x92\xb7\xa5\xb2\xe7\xc9\xb2\x4f\xf3\xed\xaa\xa4\x33\x6f\x7d\xd8\xe4\xb7\x4d\x39\xee\x70\x53\xfa\x99\x6c\x05\x04\x7e\xd9\xa5\x88\xea\x22\xa7\x6d\x69\xf0\x30\x73\xdf\xc2\x79\x17\x0f\x24\x2b\x72\x98\x21\x4b\x47\xd4\xab\x4f\x01\x4c\x20\xa1\x4e\x42\x6f\x1b\x36\x3b\xb1\xd6\xf0\xbd\x93\x71\xb3\x19\xc6\xbc\x3e\x52\x3b\xfd\x5b\xf4\xc8\x39\x73\x86\xeb\x35\x9c\x76\x97\x8e\x1a\xd6\x97\x03\xe7\x3b\xaa\x04\xec\x25\x1e\x22\x81\xa9\x4b\x47\x2a\xf3\x8f\xce\x10\xd8\x33\x53\xb9\x04\xcf\x73\x42\x0c\x10\x1e\xea\xd8\x74\xc0\x60\xdb\x35\x35\x4d\x3f\x70\x30\xdc\xdb\x84\x39\x2b\x35\xdb\x94\x7d\xa8\xfe\xe8\xb8\xdc\x2a\xa6\x19\x5f\x4b\x9c\xf1\xba\x0e\xdd\x3e\xc9\x5c\xb5\x5d\x28\xa5\xfc\xa0\x4f\x46\x41\x93\x7d\x82\xd6\x7a\x0a\x2f\x7b\xf5\xdb\xd2\xf7\xd7\x9d\x32\x22\x14\x97\x5d\x91\x83\x4c\x9f\x4e\x1f\x18\xe7\x65\x6b\x2e\x52\x3f\xc7\x57\x2d\x78\x1a\x52\x48\x28\x82\x72\xec\x09\x9b\x31\x47\xcd\x03\x77\xb7\x9d\xca\xa2\x86\xc4\xdd\x5e\x71\xd1\x16\x88\xea\xe0\x6d\xb8\x5e\x13\xc5\x4b\xb1\x75\x8d\xa8\x58\xb6\xee\xb7\x8f\xa2\xd0\xa2\xa0\x7a\x50\xb8\xe7\x19\x29\x3b\x61\xd0\xd2\xd4\x4e\x17\x4f\xd3\x4c\x3a\x8f\xc6\x8f\xee\xdd\xb1\x1a\xfb\xfa\x59\x06\x2b\xfc\x44\xc2\xdc\x1f\x7a\x36\x3d\x57\xe2\x8c\x78\xb5\xca\xa6\xa4\xe3\x44\xc9\xa4\xb9\xdb\x32\xbe\xe1\xac\xa2\x5c\xab\xa4\x67\x35\xf0\x81\xbb\x69\x9d\xcb\xb8\x99\x7c\x6d\x2e\x51\x2c\xe1\x34\x53\x0a\x2c\xbf\x76\x0a\xe0\xfb\x6a\x2e\x18\xf0\x43\x14\xea\x4f\x9d\x4c\xed\x86\x1c\xf8\x17\xbc\xc6\x17\xb9\x13\xaa\x8d\x2c\x02\x4f\x3a\x81\xda\xc9\x98\xda\x3b\x72\x25\x90\x9e\x64\x6b\xed\xee\x90\xb9\x5c\x10\xcb\x8f\x0a\x8b\xc2\xb5\xbe\xc8\xe6\x2c\xb1\x28\x7c\xcb\xdc\x50\xc0\x6b\x35\x88\xef\x32\x18\x02\xda\x44\xaf\xcd\xaf\x6f\x19\xb1\x5e\xa6\xcc\x8f\x92\x0b\xdb\xb6\x2d\xfa\x15\x4d\x9f\x70\xd5\x29\x64\xbc\x26\x89\x2d\xd3\xf7\xf3\x79\x20\xf6\x59\x16\xa0\x7f\xdf\xd3\xac\xe3\x3c\xf3\xd0\x33\x79\xa5\x37\xdc\x3e\x92\x96\x7f\xbe\x6c\xa2\x05\xf9\x01\x5c\x65\xe8\xe4\x84\x68\xcf\xc7\xbd\xf4\xbb\x22\x17\x02\x12\x48\xca\xa8\xb5\x67\x99\x7b\x9c\x11\xcb\x8b\x59\x96\x9d\x2a\xb9\x98\xc2\x9b\x1e\x11\xe9\x5d\xa6\x3e\xf9\x59\x46\x34\x40\xd7\x00\xff\x8e\x16\x4c\x24\x18\x82\xf9\x95\x9a\x11\x79\x8a\x46\x09\xf4\xfa\x7d\xa5\x87\x92\xe7\x52\xa6\x6a\x30\x3f\xea\xeb\x38\xb2\x28\x3c\xcf\xdc\x99\x80\xf7\x99\x3b\x15\xf0\x61\x47\x7f\xdf\x67\x3a\xe5\x25\xa6\x32\xc5\x5d\xe8\x73\x4f\x07\x3f\x64\x4a\x90\x8d\xbc\x4b\x4b\xc9\xb0\x68\x18\x79\xbb\x4b\x9f\x51\x72\x69\xf5\x4d\x09\x2b\x46\x91\x0c\x66\xe5\x87\x18\x1c\x14\x9c\xeb\x46\x91\x38\x4a\x2e\x07\x65\x48\xea\x57\x35\xda\xce\x8a\xbc\xca\x34\x59\x3c\xcf\xc0\xe2\xcc\xbb\xbc\x10\x69\x9e\xf8\x16\x58\x52\xb0\x24\x9b\x33\x11\x24\xd2\x52\x9b\x86\x2a\x10\xa6\x89\xd4\x98\xfa\x81\x88\xea\xdb\x5e\x2e\x32\xb5\x10\xad\x79\x1a\x25\x4a\x14\x2f\x1f\xa4\xb9\x8c\xa3\x24\xb0\xc0\x4a\xd2\x44\xcd\x4f\xb3\x2b\x96\x1a\x0d\x1d\xa7\x8b\x9d\xd1\x47\xfe\x9f\x7a\xe4\xeb\xd2\x7f\xf9\xa8\xe7\xf9\xc3\x12\xa5\xbe\xe7\x79\x19\x40\xfd\x25\xfb\x33\x98\xb1\x98\xc0\x58\xa2\xab\xa9\x12\xbc\x0e\x24\x59\x62\xc7\xab\x84\x07\x3a\x05\x33\x85\xef\x88\x39\x89\x98\x92\xb9\x36\x80\x25\xc5\x0d\xc3\xfa\x44\xd1\xb9\xf2\x22\x72\x1c\x91\x15\x49\x0a\xcc\x9f\xa4\xb6\x0b\x9b\x01\xfb\xec\x8c\x41\x9f\x2d\xad\xd1\x9d\x4d\x16\xb8\x16\x64\x24\x63\x35\xce\x41\xd1\x0d\xa4\x0c\xad\xf8\xdc\xe6\xba\xe0\x32\x19\x21\xc2\xdc\x60\x26\x46\x77\x07\x33\x3e\xba\x5b\x92\x53\x93\x8e\xb8\x4c\x06\xaa\x68\x36\x1b\xf0\x54\xf8\x81\x18\x89\xe8\x62\x2a\x47\xe3\x81\x0c\x96\x72\x34\xcb\x65\xe0\x57\xd3\x9f\x67\x81\x18\x65\x41\x1c\x78\x9a\x6a\x22\x19\xb1\xb8\x7a\x3a\x9a\xa5\xd7\xa3\x5f\x14\x59\x04\xfc\x32\x92\xbf\x28\x65\x3a\xe2\xa5\x31\x12\xe1\xdf\x3c\xcf\x6b\x2c\x69\x71\xfb\x1f\xae\xf5\x8f\xdb\x12\xa1\x76\xbf\xe2\x94\xbd\xea\xfc\x9c\x8b\x51\xc8\xfc\xc0\xc7\x6b\x43\xb8\xa3\x2c\xf0\xd2\xc4\x67\x62\xa5\x89\x55\x14\x44\xc3\xc1\x51\x0a\xb2\x20\xd6\x33\x44\xaf\x1c\xf0\xd5\x40\x4e\xa3\x6c\x80\x89\x2c\x1a\x4d\x5b\xb7\x4b\xb6\xba\x86\xbc\x6b\x76\x9b\x56\x90\x24\x58\xec\x69\x34\x4c\xd7\xba\x7d\x12\x91\x0f\xd1\xb6\xd7\x4e\x45\x8d\x51\x80\x82\xda\xd8\x00\x5c\xef\xeb\x68\x77\xba\x06\xd6\x49\x44\xbb\xa3\xfd\x03\xd6\x8e\xf6\xd7\x94\x0b\x5e\x81\x0c\x8f\x59\x14\x22\xfd\x53\xb1\xbe\xb4\xb3\x81\x15\x39\xce\xc0\x9a\x8a\x20\xb4\xe0\xce\xff\xfa\xce\x0a\x96\x79\x22\x9a\x4b\xe7\x4e\xa4\xf3\xf1\x2a\xf1\x86\xda\x22\x98\xc7\xcc\x0b\xc8\x9d\xff\x99\xdd\xb9\x00\xcb\xa2\x74\xcf\xb2\x1c\x51\x85\xd1\x85\x85\x76\xf3\xe9\x65\xa8\x49\x5a\xe6\x3c\xe9\x2d\x32\x2c\x8b\xa8\x35\x59\x83\xa6\xd6\xd0\xa8\x98\xe8\x8f\x6f\xaf\xca\x16\x26\xe1\xad\xa4\x11\x29\xff\x78\x23\xd6\x40\xed\x6f\x61\x41\x24\xad\x61\x0b\xab\x1d\x8f\x95\x19\xf7\x31\x1e\xa1\x8a\x48\xd0\x39\xb0\x10\x1d\xe6\x20\x27\xe8\x45\xb5\x94\x70\x92\x93\x1c\xa3\x11\xb4\x30\x5e\x03\x1b\xde\xf0\x65\x7c\x55\xb4\x5f\xdd\x2a\x2c\x34\x88\xd8\xa0\xbb\xab\x5b\x2d\x9c\xe4\x84\x98\xe6\x35\x58\xbe\xd4\x92\xfe\x0d\x3a\xa7\x7b\x74\xbb\xd1\x66\xfb\xa1\x7e\xa0\x26\xaf\x93\x88\x2e\x48\x19\x15\x62\x67\xf3\x38\x92\x8a\x4c\x6e\xdf\xb9\x50\x64\x5d\x18\xf6\xc6\xc4\x45\xa0\xf6\x9d\xb8\x87\x0a\x37\xd6\x4b\xdb\x9d\xe5\x9b\x56\x40\xbb\x40\x44\xbd\x42\x2d\xd9\xb4\x50\xe2\x60\x51\x10\xeb\x1b\x8f\x99\xda\xa1\x6a\x2e\x62\xf2\xdd\x48\xb2\x22\xbc\x80\xac\x40\xd4\x7a\x5c\x72\xbe\x5e\x1c\x52\xf1\xbd\xa1\xf9\x3d\xb5\x28\x4c\xcd\x6f\xb5\x1d\xce\x6e\xc8\x8f\xa7\x45\x29\xa6\x0d\x8b\x92\x47\x21\x63\x4d\xd2\x85\x60\xf3\x16\x5b\xb3\x1c\xcb\xf0\x33\xbf\x2a\xbb\x18\x4d\xc6\x63\x2c\x15\x23\x7d\x62\xa7\x2f\xfa\x76\x20\xc4\xb6\xd5\xa9\xee\x27\x54\xc9\x0b\x9a\x31\x7e\xce\x30\x20\xad\xc9\x1f\x4b\x7e\x18\x25\x61\x5a\x32\xfe\x71\x53\x96\xc0\x3e\x47\x55\x3f\x42\x36\x08\xd9\x68\x16\x25\x79\x86\xfb\x09\x96\x19\x2a\x89\x94\x58\x68\x3a\x54\x3d\x73\xba\x38\x71\x67\x4b\x9a\xfb\x56\x3d\xed\x6b\x6f\x1e\xef\x6a\x6e\x4d\x61\xde\x43\x36\x5e\x71\xd3\x6e\xa4\x6a\xe2\xfb\xda\xc7\x37\xbc\x29\x13\x72\xab\x17\xe7\x69\x2e\xbc\x40\xf7\x03\x56\x9d\xdd\x48\xfe\x39\x19\xef\x59\x63\x93\xa4\xd9\xc1\xbf\x6b\x58\x74\x77\xb9\x20\x65\x9c\xb7\x62\xac\x26\xa4\x5b\xdd\xd4\x51\xde\xa2\x79\x6b\x58\xdf\x02\x9d\x61\x6c\x2b\x8c\xbe\xe8\x4c\xc8\xf1\xff\x71\x08\xbd\x1a\x97\x46\xf8\xfc\x80\xbc\x7f\xb7\x4f\xad\x72\x1f\x5a\x76\x2f\x57\x6f\xa5\xd7\xeb\x6f\x7b\xd7\x66\x59\x6a\x79\x07\xac\x01\xa9\x32\x47\x50\x8b\x3a\x18\x4b\x66\x59\x74\x53\xd5\xb9\x6e\xa8\x21\xd1\x45\xa2\x44\x9a\x70\xe4\x05\x4a\x66\xd6\x62\x97\x75\x5b\xe9\x41\xd5\x22\x3f\x26\x0b\x64\x49\x81\x59\xc9\x97\xad\x95\xac\xb6\x69\xd3\xb7\x1b\x42\x8f\xe6\x24\xa1\x7b\xd7\xc4\x24\x3f\xc0\x88\x65\xe7\x9a\x48\x30\x37\x82\x26\x3c\x31\x8a\xc3\x02\xae\xc9\x50\xd1\x30\xee\xb9\x4f\x0a\xb7\x10\xb0\x6f\xf8\x1a\xe3\x28\x6a\x9e\x15\x3b\x20\x93\x8f\x09\x09\xdc\x15\xb9\x2c\xb4\xa0\x1c\x79\x20\x02\xd2\x00\x49\xa6\x4d\x98\xbf\xde\x2d\x7d\x5a\x6d\xe9\x09\x45\xac\x3f\x69\x7b\x8c\x52\xaa\x3e\xcf\xe6\x4d\x53\x7d\x43\x99\x99\xa7\x59\xa4\x2d\x14\x68\xe2\x8f\x3c\xa3\x7e\xe8\x91\x57\xea\x52\x36\xc2\x88\xd7\x41\x1c\x65\x52\xcb\xbe\x78\xbb\xe6\x6f\xf3\xd1\x58\x09\xc2\xf7\x6b\x0e\x57\xcb\xcb\xc8\x69\x51\x4c\x1e\xf8\xa3\x30\x0e\x96\x83\xad\x8a\xcb\xd7\x96\x8a\x15\x83\x06\xf0\xb4\xf9\x4a\x31\xda\x27\x45\x97\x5c\xf7\x3a\x22\x65\xec\xe7\x5a\xb1\x09\x72\x51\xe0\x70\x52\x47\xb1\x10\x4b\xf1\x2f\x55\xc3\x37\xda\xe9\xca\xed\xe5\x1b\x71\xf1\x7f\x90\xaf\xe5\x05\x61\x05\x49\xf4\xd0\xf6\xb1\x38\x1e\xc4\xf1\x28\x8b\x59\x36\x1d\xa5\xdb\x4c\xce\x38\x5e\x54\xc8\x08\xb2\x19\xd3\xb1\xab\x3b\x3e\x4b\x2e\x94\x20\xdd\xea\x50\xfb\x8c\x50\xde\xa0\x4f\x7d\x3d\xf2\x35\xe3\x25\x98\xb5\x0e\x0e\x89\x50\xbb\x9e\x2c\x77\xbd\xfd\x7a\xab\x55\x34\x3d\xa8\xa6\x76\x82\x55\xe9\x34\x50\x05\xe0\xdc\x55\x53\x61\x4c\x2a\xf8\x30\x28\x20\x2f\x5d\xd6\x0f\xf5\xea\xc8\x95\x7a\x72\x5e\xec\xd6\xe0\x6b\xa3\x0c\xfe\x12\x36\xdf\xeb\x77\xd4\xbf\xa1\xea\x36\x51\x1d\xbf\xd7\xa7\xba\xfd\xe7\x28\x69\x0f\xb8\x37\xf6\x83\x3f\xaa\xa7\x35\xc9\xf7\xbf\xac\x92\x09\xea\xf4\x69\xb7\xa5\xda\xb7\x3d\xa2\xaa\x8e\xd3\x54\x0e\x70\xc0\x0d\x61\xe9\xde\x1e\x56\x64\x54\x33\x94\x9a\x7d\x18\x88\xe2\xb3\x02\x59\x59\xc9\xd1\x29\x7c\x6f\xd1\x88\xa2\x10\x4c\x9e\x86\x1a\x04\x30\x3c\xef\xe2\x1f\x31\xee\xe8\x4b\xb6\x0b\x37\x92\xad\xe1\x63\xd4\x15\x69\xa1\x91\x52\x11\x06\x6f\x4d\x55\xc3\x8f\xdb\xf4\x47\xf2\x5d\x69\x94\x24\x2c\xc8\x39\xf6\x19\x03\x0c\xc8\x6b\xd5\xbf\x48\x8d\xde\x31\x41\xa8\xc4\xcb\x02\xce\x31\xdf\xe3\x99\x24\x91\xe6\xc9\x4c\x63\x65\xa7\x24\xc7\x00\xdb\x37\x38\x62\xda\xe4\x96\x0d\x42\x34\x2f\xd1\xaf\xd4\xd1\xd1\x5a\xa7\x46\xb5\x4c\xe6\xb9\x12\xec\x4f\xf4\xa5\x99\x36\x38\xe8\x15\x5d\x8d\x31\xf0\x45\x6a\x8c\x81\x2f\x0b\xf7\xa0\x20\x96\x37\x0d\xbc\x4b\xa4\xee\x77\x46\x65\x58\xcd\xd5\x2e\x75\x5d\xd4\xbe\x68\x46\x8b\x80\xaa\xf0\x57\x8a\x56\xec\x6f\x7d\x4a\x45\xa6\x8a\x2a\x0e\x65\x32\x3b\x26\x70\x5d\xa8\x21\x78\xdd\xb5\xf5\xdd\xc0\x3e\xb7\x22\x27\x15\xad\xcc\xa4\x22\xb0\x78\x34\x19\x78\x79\x26\xd3\xd9\x48\x29\x5a\x22\x8d\xab\x4b\xd5\x47\x9e\x2e\xeb\x77\x4f\xf1\xdd\x77\xe5\xc7\xe2\x33\xdc\xd9\xda\x15\x8c\xca\x21\x7d\x59\x54\x59\xac\x04\x55\x5f\xa9\x53\x7c\x49\x78\x1d\x51\xc3\x2a\x9b\x6b\x60\xab\x16\x3f\xf2\x74\xc8\xc7\x2f\xcb\xfa\x81\xd6\xfa\xd5\xae\x5b\x2f\x97\xc4\x2c\x11\x4d\xef\x57\x45\x19\xa4\xa4\xe3\x8d\xae\xa5\x0e\xf3\xa9\xa3\x8a\x66\x79\x23\xee\xa7\xa8\xe3\x7e\x0a\x9d\x27\xf1\xb8\x30\xa9\x36\x2f\x83\xd5\x7e\xea\x07\x16\x20\x30\x02\x85\x67\x3b\xa6\xef\x32\x58\xf9\xe9\x22\xa9\xe6\xef\x18\xe7\xef\xcd\xee\x37\xf2\xf9\x46\xf9\x57\x88\xde\x69\xe0\x75\xbf\x4b\x38\x0f\x28\x28\x4d\xe9\xe3\x0e\x13\x5f\x0b\xad\xe7\x79\x57\x83\x0d\x27\xbb\xf7\x3d\xcf\x4b\x87\xa7\x0f\x85\xfb\x8f\x20\x29\xdc\xe6\x01\xcc\x3f\xe0\x73\xe1\xfe\x0e\x6f\x0b\x77\x72\x0f\x3e\xf5\x7c\x51\xbd\x59\x78\x8a\xb4\xd2\x78\xc4\x72\x99\x76\xc9\x35\x3b\xed\x80\x37\x61\xc8\x2b\xf2\xb1\x80\x5b\x63\x48\x68\x4d\x02\xef\x23\x63\x56\xdf\xc9\xd4\xb5\x10\xd0\xac\x65\xd2\xaa\xc5\xfa\x3f\xff\xdb\x6a\xd0\x12\x1c\x69\x5e\x91\xcd\x58\xac\x78\xc5\x0b\xcd\x01\xfc\x28\x53\xbb\xb8\x62\x01\x5f\x34\x0b\x88\xd4\xef\x24\xc6\xdf\x1a\x1b\x87\x82\x88\xbb\x06\xea\x9a\x24\x70\x6b\x4c\xd7\x20\xe3\x5f\x1b\xf5\x27\x95\x51\x3f\x88\x3b\x98\x8b\x6e\xc9\x38\xbc\xe6\x9d\xcd\xad\x88\x8c\xc1\xb0\x3e\x4d\x69\x22\x2e\x29\x2e\x88\xb5\x3d\x2f\xee\x36\x1c\x9c\xe9\xa0\xb1\xb7\x3a\xde\x7a\x06\xb9\xfb\x14\xa5\x4c\xe6\xe2\xe0\x5d\x49\xf8\x1c\x19\xd0\xad\x02\x9d\xc0\x30\xa5\x88\xe7\xbe\x42\x7d\x22\x72\x0f\x49\x8e\xa4\x9b\xea\xd3\x74\xb9\x67\x59\x4e\x6e\x0f\xf7\xac\x29\xcb\xca\x89\x70\xf0\x22\xcb\x3d\x2f\xc8\x32\xab\x4b\xf2\x10\xe9\x62\x90\xa4\xa3\x8b\x5c\xca\x40\x64\x3d\x12\xf0\xb1\xb6\x63\x7e\x2a\x40\x6c\x51\x9b\xa2\x46\xeb\x76\x5a\x0a\x09\xb3\x28\x19\x2d\x22\x5f\x4e\x2d\xb0\xee\x8e\xc7\xf3\x65\x17\x85\xe2\x78\x69\x1a\xdd\x64\x8a\x5f\x8a\xee\x8c\x42\xc8\x1e\xc3\x54\x54\xac\x0a\x09\x42\x8d\xd7\xb3\xb6\xe6\x6b\x10\xea\xdf\x16\x8d\xd8\xdc\xce\xb1\x2c\xb1\xec\x3f\x17\xb4\x86\xbc\x97\xe5\x04\x5d\x93\x00\xbc\x46\xa8\x14\xfb\xf9\x53\xd8\xdc\x1e\xee\x7d\x8e\x9c\x72\x7d\xa8\x1b\xac\x0a\xfc\x7c\x8e\x35\x97\x57\x9f\xa3\x35\x85\x37\x45\xd7\x76\x6e\x1a\xdd\x53\x2f\x4c\xa8\x83\x25\xf3\x98\xbc\x2f\x3a\xd8\x73\x63\xa4\x46\x5c\x26\xbb\xd6\xf1\x5c\x44\x33\x6d\xe6\x7e\x51\x90\x88\x02\xeb\x90\x98\xf4\xfa\x3d\xaa\xa5\x6f\x35\xa0\x4a\xa2\x6c\x89\x95\xf5\x8b\xfb\xb8\x3b\x0c\xcc\x2c\xc0\x20\xb0\x2f\x6c\xab\x9b\x05\xe0\xd1\x94\x31\xc4\x6b\x2a\xe2\x2c\x0b\xf0\xec\x08\xd9\xc1\xfb\x82\x7c\x28\x1a\xac\xe0\x43\x51\xf7\x09\xd3\xe0\x80\xd7\xb5\xc2\x1a\xe7\x3e\x51\xdf\x8a\xde\x3c\x86\x49\xb7\x0b\x6a\x55\xa6\x34\x96\x51\xba\x57\x21\x53\x59\x8d\x65\x51\x7f\x95\x2f\xd2\xb9\xda\x6e\xb4\x3a\x89\x06\x51\x5c\x95\x51\x8c\x13\x4f\x37\xcd\x8a\x14\xc2\x1e\xfe\xa0\x76\xa2\x59\x9a\x67\x01\xda\x08\xea\xb3\x41\xfe\xab\xf2\x71\xc0\x8a\xa0\x2e\x9f\xf5\x8c\x4e\x79\x6a\x56\xc4\xee\xef\x10\xc7\xee\xfd\x31\xf8\xb1\xda\x48\x86\xb1\x7b\xef\x77\x98\x6e\x8f\x45\x77\x06\xae\x3a\x3d\x9a\x28\xd3\x5a\x60\x92\x91\x6a\x19\x9d\x48\x22\x69\x33\x11\xd7\x6c\xc7\x7c\xb4\xf6\xcc\x8b\x9e\xae\x97\x8e\xeb\xf3\x9e\xe7\xe5\x9e\xb9\xea\x79\x5e\xee\xb9\x8b\x1d\x43\xc9\xe3\xbc\x31\xe8\xcb\x78\xeb\xe8\x50\x3b\x60\x20\x0f\xd6\x59\x49\xd9\x39\x06\xee\xb2\x77\xb5\xe4\x8e\xfc\x39\xd5\x40\xfe\xaf\x0a\x9d\x9e\xe4\x60\x97\xb5\x23\x2e\xad\x1d\x1f\x25\x02\xc1\x33\xf4\xae\x90\x7b\x8b\xd4\x29\x69\x28\xa0\xc0\x75\x8d\x27\xf2\x8f\xd4\x98\xeb\x93\x86\x0e\x56\xfe\x0b\xae\xba\x99\x7c\xaa\x87\xa3\x06\x7d\x1c\x35\x8e\x6b\x8e\x1a\x13\x5e\xf1\xcf\x61\xeb\x7e\x5a\xdd\xf7\xeb\xfb\x72\x0f\x3f\x74\x91\x9a\xac\x9a\x31\xf2\x60\x86\xf6\xe3\x72\x34\xca\xd7\x8a\xb8\xc1\x8e\x83\x9a\x1d\xbf\x2a\x88\x47\x1b\x98\xeb\x42\x23\xc1\x28\x8d\x1b\x47\x75\xa6\x57\xa6\x76\xa8\x36\x65\xe6\x71\x93\x25\x2f\xd2\x9d\x2c\xb9\x88\xe9\x9e\x7a\x61\x42\x1d\x2c\x99\xc7\x24\x8b\x29\x10\xe1\x5e\xe8\xfe\x6a\x82\xd2\x59\xf7\x14\x45\x21\xc6\xe5\x22\x26\x17\xf8\xd2\x5f\xc8\xbc\x35\xb3\x09\xbb\x54\x5e\xcd\x6b\x2e\x7b\x08\xfe\xbf\x55\x46\xd4\x03\xde\x94\xee\x92\x3f\x28\x1f\xaa\x1a\x76\xcb\x87\x4f\x3a\x64\xa7\x1a\xdd\x50\xaf\xd9\x48\xaf\xd2\xd4\xbd\xb5\x22\xc3\x1c\x3c\x48\x6c\xcf\xc3\x8c\x9f\xd3\x14\x11\x10\x21\x74\x9f\x05\xc4\xc3\x83\xca\xf4\xdf\x28\x1e\x5d\xc6\xaa\xb1\x4e\xf1\x28\xbc\x81\x78\xb4\x8c\x21\x85\x04\x7d\x99\x94\xac\x32\x4d\xa1\x61\x65\xd5\x50\x2a\x37\xdf\xb8\x5f\x2a\xed\x7b\x70\x19\xac\x06\x61\x2a\xb4\xa5\x23\x4a\x2e\x06\xa5\x57\xa6\x3e\xba\xf9\x8b\xaa\xfb\x2f\x89\x05\x59\xdc\x36\x26\xd7\x6d\x36\xee\x1a\x11\xa1\x4c\xa8\x22\x14\x73\x46\x60\xab\x73\xc8\xdd\x5b\xc2\x66\xcf\xfe\xfe\x77\xf5\xcf\xa3\x9f\x3f\x75\x4a\x3f\xcb\x72\xac\x6c\x9a\x2e\x2c\x68\x39\x0e\xe5\x32\xf5\xd2\xd9\x3c\x0e\x64\x30\x9a\x05\x49\x3e\xb0\x6e\xe7\x6a\xe7\x26\x1e\xae\x70\x0a\x5c\xff\x6c\x1c\x50\xbd\xdb\x16\x09\xd4\x9b\xb5\x41\x28\x45\x21\xd4\x24\x6b\xa8\x64\x99\xfd\xd8\x55\x7b\xf3\x1a\xce\x7e\xb1\xb7\x1d\xfe\x42\xe8\x39\xff\xc5\xde\xf9\xbd\xe7\x79\x19\x40\x73\x7a\x03\x59\xa8\x53\xe6\xa9\x4f\x06\x9d\xae\xe7\xbb\x3c\x87\x3e\x67\xe4\x2c\x26\xc2\xf6\x70\x69\xb7\x96\x95\x2c\xa5\x26\xdb\x9b\x1a\x66\x76\x12\x1b\x5c\xc4\x83\x9e\xae\xa2\x53\xff\x95\x84\x44\xe7\x62\xfe\xb0\x33\x39\xce\x74\x0d\xdf\xe5\x2f\x32\x0f\x25\xb6\x97\xac\x2b\x13\x80\x08\x4c\x9e\x01\x4a\xe9\xd6\x41\x44\xd3\xf6\x33\x98\x95\xfc\x14\x88\x74\x27\xb0\x22\x73\x01\x96\x64\xfc\x24\xf1\x83\x25\xe2\x5f\x4b\x9d\xf5\x71\xe3\xf0\x42\x04\x31\xd3\x83\xd9\xe3\x54\xd5\x26\xb6\xcf\x19\x39\x89\xf5\xf6\xac\x4d\x4b\x62\x74\x7f\xc7\x70\xd7\x2b\xe6\xcc\x64\xc5\x71\x06\xd6\x6d\x1d\x38\x89\x19\x6c\x82\xc6\xce\xf1\xb2\x57\x2b\x16\x36\xbf\x50\xdb\x29\x7b\xb4\x47\x10\x5b\x58\x50\xc5\x5d\x99\x2b\x6d\x1e\x80\x57\x09\x3f\x98\x6c\xe0\xfc\x0f\x49\x40\x81\x91\x80\xa2\x4a\xde\x09\x6e\xfe\x7e\xa0\xdf\xdd\x35\x21\x38\x42\x83\xed\xd5\x8d\x1c\x00\xd7\xf7\x61\xbd\xbe\x0f\xf5\xfa\xfe\x2f\xcc\x52\x2d\x52\x6d\xa6\x21\x52\xf2\x53\x8e\x32\xc1\x7e\x8c\x02\xc4\xf7\x78\x4b\x9a\x6a\x48\x1c\x71\x4c\xf7\xce\x63\x12\x51\xc7\xc8\x51\xea\xca\xd3\x57\x7e\x4c\xf7\xce\x62\x6d\x07\xc8\xa1\x0f\x04\x52\x53\x32\x46\x9d\xbc\x4f\xd7\x86\x66\x9a\xe4\x62\x42\x9f\x2d\x25\x08\xa7\xde\x65\x75\xbf\xdc\x83\x26\xe3\xf1\xff\xa8\xcd\x82\x3d\xcc\x6e\xd0\xba\xd2\xee\x62\x35\x03\x3c\x8d\x09\xab\x18\xa0\xb3\x22\x07\x31\x24\x4a\x0e\x7b\x48\xcb\x8c\x83\xa5\x3f\xf2\x9a\xc2\xbb\x3e\x76\x94\xd8\x2c\xd6\x52\xf8\x4b\x2d\x85\x1f\x68\x29\xfc\x81\x96\xc2\x13\x2d\x85\x47\x8f\xbb\x4f\x5e\xca\xcd\x96\x09\x5f\xc9\x32\x0f\xba\x44\x1e\xf5\x70\x34\x0d\x98\x5f\x2f\x9a\xa6\xc5\x3f\x61\xc5\x40\x11\x96\x64\x3c\x1b\x34\xca\xe2\x8d\xea\x1c\x90\xbc\xcd\x60\x0c\x9e\x66\x1e\x9f\x32\x4c\x0d\x63\x56\x9f\x3e\xb6\xd0\x0e\x1d\x58\x6e\xd2\x5d\xee\xa8\x14\xd0\x11\xb9\xa3\x68\x65\x99\x59\x91\x97\xb1\x1a\x3b\x0f\x74\x66\xa2\xd7\x05\xd4\x07\x60\xea\x41\x00\x2f\xb2\xf2\xc1\x49\x79\x5e\x8d\x4f\x7c\x38\xca\x6a\x15\x7f\xe3\xb3\xcd\xe4\xeb\x8f\xf0\xf6\xea\x76\x4d\xb2\x9c\x27\x4a\xee\x57\x93\x57\xde\x37\x59\x79\x98\xa2\xe7\xb2\xd6\x6d\x7f\x70\xb9\x1d\xeb\xbc\x24\xdf\x0b\x88\x10\x98\x14\x41\x0f\x8d\xbb\x41\xdb\x0b\xe1\x75\xb6\x79\xc6\xff\x46\xbb\x0f\xaf\xd7\xc4\x30\xaa\xeb\x18\x2d\x83\xd3\x89\x45\xe1\x5b\xdc\x76\x7f\x8e\x6b\xf7\xe7\x24\x95\xf5\x79\x04\xf6\xf2\xb5\x7e\x31\x93\x22\x4d\x2e\x2c\x0a\x57\xf1\x2f\x40\xe1\x98\xfd\xa1\x8c\x87\xf2\x1a\xa0\x18\x1d\xc2\xa0\x39\x25\x56\x7f\x46\x5e\x1a\xe7\x33\x0d\x58\x65\x04\xe9\x86\x28\x39\x68\x9e\x75\x9e\x54\x0e\x41\xaf\xeb\x8e\x8b\x7a\xaa\x12\x75\x2b\x89\x09\xd3\x30\x3f\xa8\x81\x2d\x90\x8f\x6c\x2a\x68\x83\xe6\x45\x25\xb6\xea\xd5\xfb\x75\x2b\xb8\xfc\xe6\x3d\xff\xf7\xf4\xb6\xd1\xb1\x26\x3c\x4a\xe4\x7a\xcd\x03\xe5\x3f\x32\xba\xe6\x88\xf9\xbf\x63\x70\x4b\x45\x65\x9b\x33\xb6\x8a\x85\x41\xe0\x73\xe6\x35\xdd\xcc\xa2\x72\xb3\x5d\x53\x78\xda\x23\x9c\x95\x9e\xd0\xc7\xbf\xb0\xe9\x3c\xeb\x79\x5e\x46\x2a\xbe\x41\xd1\xe9\xd1\x1a\x5e\xc5\x26\x99\xdf\xc7\x6d\xfe\xba\x9d\x93\xbb\xcf\x1b\xb8\xe9\x3e\xdb\x3a\x3f\x2d\x15\xc4\xce\xf3\x66\xa5\x31\xec\x3a\x6c\x6e\x3f\xef\x3c\x69\xd6\x45\xda\x26\xb5\xda\x63\xb3\xcb\x3e\xf7\xc7\xba\xfd\x39\x23\xb2\xe3\x38\xbd\x53\xd7\x11\xb5\xb0\xf4\x7c\x97\x40\xda\xed\xd7\xab\x23\x53\x4b\x08\x72\xf4\xc8\xfd\x6a\x8e\x5a\xe5\x2f\xbc\x68\x04\xba\x6d\x20\xaa\x13\xdf\x36\xf0\xec\xf6\x88\xf9\x73\xfe\x2e\x0d\xef\x16\x61\xbc\x5b\x84\xf1\x6e\xb9\x28\x10\x28\xb4\xe1\xb5\x22\x6c\xfe\xcd\xf8\x5e\xb4\x3d\x0e\x6f\xe8\x7b\x21\x7a\x7d\x2f\x3e\xc6\xe8\xac\x58\x9d\xa7\xbf\xdf\x71\x72\x53\x7f\xcd\x9c\x8d\x07\xb5\xaf\x24\x56\xf4\x3c\x26\x09\x35\x09\x8e\x3e\xe8\x6d\x60\xae\x66\x7f\xbb\xbe\x0e\xac\x8e\x6d\x67\x97\x94\x48\xf5\x7d\x1b\x03\x58\x8f\xec\x87\xb8\x83\xf7\xe0\x39\x79\x89\x33\xd3\x50\xb7\xf5\xff\xce\x1f\xae\xee\x49\xbb\x2e\x47\x7b\xff\xe9\x44\xc2\x35\x9b\x7b\x1f\xe3\xe9\xfe\xf6\x26\xa0\x87\x7b\xc3\xe9\xaf\xb1\xfd\x6e\x41\x44\xdf\x3c\xd0\x26\x28\xb9\xdc\xdb\x5f\xa8\xa8\x9f\xe2\x7e\x0c\x87\x0e\xb4\x94\x66\x97\x1b\x9b\xd9\x93\x02\xde\xc6\xb0\x22\x9f\xf5\xa7\x6e\xa2\x36\xbc\xc9\x34\x10\xf3\x86\x5c\xf1\x3a\x53\x3d\x3c\x8a\x5d\xa5\x4a\x3d\xb0\xe0\x45\x57\x5f\xb6\xf9\x4b\xb2\xc1\x33\x36\xfd\x95\xee\x0d\xac\xdb\xa2\xda\xdf\xd6\x14\xbe\xc4\x06\x5f\x3e\xf1\x77\xe6\x0e\xa9\xeb\x79\x38\xf0\x23\x3e\x98\xf1\xbb\x83\x99\xe8\x74\x40\xd3\x4e\x85\xbf\x70\x1a\x78\x89\x4b\xf7\x5b\xa1\xfb\xba\x61\x7f\x9c\xc7\xb5\x55\x4f\x8d\x2a\x66\xb5\xa8\xb8\x9b\xf0\x77\x98\xef\x5b\xe7\x29\x72\x57\xc9\xfb\xcd\x92\xc1\xae\x92\x77\x9b\x25\xf3\xae\x71\x6a\x44\x2f\xba\xd2\xf6\xa6\x10\x29\xed\x53\x40\xaa\x74\xce\x37\x8f\x9b\xb4\xf0\x2c\x86\x0d\x3b\x5d\xa7\xcc\x9f\xc6\xb5\x32\x50\x90\xab\x18\x4e\x0b\x83\xe6\x2e\x7c\x13\x38\x28\xf0\x24\x78\x02\xcc\x61\x08\xf2\xb5\x25\x40\xf7\xd7\x11\xe8\x3a\x72\x53\xc7\x3d\x60\x4e\xbe\xa6\x10\x75\xd6\x71\x83\x49\x5e\x90\xc4\x07\xcb\x24\x83\x49\x41\xfa\x98\x81\x2b\xd9\x5b\x90\x17\x31\x74\xb9\x36\x19\x83\x04\x58\x21\x1b\x49\x81\x2e\x7d\x16\x90\xc0\xf4\x07\x98\x13\xac\x2b\x9e\x5b\xda\xa6\x28\x30\xdf\x80\x74\x78\xbe\xbb\xcb\x5a\x5b\x49\x98\xe8\xa5\xc5\x1b\x94\xf4\x46\x04\x45\x14\x2c\x0c\x90\x96\x56\x66\xa2\x9d\x94\x5f\x8f\x85\xda\x9e\x06\xd6\xed\xa3\xb8\x54\x47\x7c\xd5\xe3\x04\x72\x37\xb0\x87\x7b\x16\xc6\x84\x06\x96\x63\xbd\xc7\xbc\x27\x56\xcb\xaa\x38\x53\xc3\xb8\x6d\x33\xff\x9c\x11\xe6\xd7\xdd\xcb\xb5\xb5\xb0\xf7\xc5\xa6\x15\x5a\xb6\xec\x27\x59\x20\xcb\x81\x7a\x6c\x88\x71\x4d\x21\xf5\x77\x33\xb8\xb0\xe7\x79\x69\xe3\xe3\x3d\xcf\xcb\xf3\xab\xcc\x37\x40\xe6\xc5\x0d\x87\x50\xa4\x8b\xe6\x08\x56\x44\x79\x8e\x26\x69\x30\x24\xab\x45\x0d\xee\xc3\xb3\x98\xc2\xb3\x98\x64\x3e\x85\x84\x42\x55\xfa\xc0\xa0\xee\x9a\x17\xee\x9a\x17\xd2\xd6\x0b\xb2\xf1\xc2\x21\x46\x15\x36\x2b\x0f\x5b\x65\xcb\xa3\xd0\xd8\xd7\xee\xc5\xc1\x52\x32\x11\x30\x8b\x82\xef\x77\xba\x51\x1a\x17\x39\x37\xb0\xd9\x31\xc2\x8d\x7b\x39\x26\xd7\x67\x31\x20\xe0\xf5\x14\x42\x57\x63\x6e\x58\xa7\xc1\xa2\x84\x6b\x53\x6d\x1f\xa5\x88\x9e\x8e\x7e\xda\x87\x7e\x24\xeb\x67\x9f\x52\x8d\x51\xa0\x31\xed\xba\xec\x05\x0d\xfd\x31\x44\x57\x6d\xa5\x50\x17\x3e\x30\xdb\x5b\x01\x43\xe0\x5e\x7b\x85\xcb\x9a\xe9\x94\x66\xd5\xc0\x57\x23\xde\xac\xae\x53\x05\xb1\x5e\x99\xb4\x3b\x83\x52\xd3\xaf\xd9\x72\x93\x25\xeb\x05\x54\x4b\x0c\xa5\xd3\xa3\xf1\x9a\xb5\xad\x2e\x95\xbe\xc5\xec\xea\x2d\xa5\xc5\xa8\x50\x14\x29\x8d\xe7\xb0\xb3\xd8\x07\xed\x50\xd3\xf4\x10\x30\xc2\xd9\xbe\x07\xb9\x4f\x26\x4a\x30\xcc\x29\x3a\x4d\x40\x0f\x2b\xd2\x2c\x68\x1e\xe7\x99\xa5\xa8\xe1\x4b\x6c\x2c\xf6\x15\xed\x54\xa1\xde\x47\xb1\xb1\x30\xc4\x25\xe9\xbc\x8a\x29\x68\x24\x47\x2c\x1d\xfb\x60\xed\x97\x99\x91\xca\xd2\x4f\xab\xd2\x6f\x74\xe9\x82\x76\x4e\xcc\x82\x7c\x8a\xc1\x1c\xfb\x2c\x48\xe4\x43\x02\x0c\x78\xbd\xe9\x0d\x35\x69\x4e\x1f\x58\x14\xa6\xed\x65\xd9\xa5\x27\x35\x65\x6f\x2f\x8e\xe6\x68\x26\xf4\x24\x19\x03\xfe\x47\xad\x0e\x3b\x62\x18\x2d\x6b\x85\xa2\xc5\xf8\x52\x9f\xc5\x03\xa5\xab\x74\xe9\x95\xf8\x74\xa4\x94\x49\x5f\xa4\xf3\x66\xb1\x2a\x49\x9d\x86\x8b\xfa\xa4\xfd\x86\x6c\x7e\x00\x06\x40\xea\x48\x5b\xcc\x6c\xef\x70\xb7\x79\xac\xee\x40\x69\x1a\xed\x31\x12\xf6\xf4\x7d\xe4\x47\x2c\x4e\x2f\x06\xcd\x0b\xb3\x83\xed\xf8\x62\x54\x96\x31\x04\xb9\xaf\xc0\xa6\x51\x6e\xe8\xb7\x9f\x9b\x90\xd8\x36\x7f\x6f\xb1\x77\x2f\x4e\x33\x73\xa0\x24\x3a\x4f\x13\xbb\x86\x3a\xf5\x57\x65\xa5\xb2\xbb\x48\x98\xa6\x8d\xdd\x39\x68\xfa\xab\xfc\x6a\xee\xcc\x08\x57\x22\x22\xcc\x76\x89\x46\x2d\x6f\x89\xde\x82\xfc\x00\xb7\xf2\x27\x22\x18\xac\xd2\x7c\x90\xe5\xe6\xc7\x82\x25\x72\x20\xd3\x81\xce\xc3\xd6\x62\x20\x7b\x16\x05\x76\xd4\x19\xa6\xd5\xda\x3e\x97\x8c\xac\xc8\xcc\xd7\xa9\x2b\x9a\x0e\x40\x69\x12\x46\x62\xa6\xb9\x08\xfb\xe4\x2c\x19\xf9\xc4\x29\x78\x87\x8e\x75\xa8\x5b\x2b\x19\xaf\xea\xfa\xbc\xaf\xeb\x83\x6e\xb5\x7b\xd0\x1d\x43\xd3\xf4\x3c\xc5\xf8\x45\x0c\xa1\x31\x2b\x78\xb5\x63\x1c\x5b\x52\xeb\x62\xbb\x60\x95\xde\xf8\x52\xe7\x92\x69\xc6\x15\x2a\x9d\xa3\x32\x6b\x32\x9b\x7f\xdf\x0c\x9d\xea\x54\xa5\x7e\x7d\xd8\xbd\x11\x01\x87\x03\xbd\xda\x1e\x68\x3d\x9a\x56\xcb\x5c\xf6\x57\xb7\x71\x10\xc4\x81\x34\x11\x6c\x6b\x0a\x4b\xbf\x33\x7b\x73\xb7\x61\xe3\x9a\x54\x19\xd5\x34\x7c\xe2\x19\x85\x36\x10\x57\x0b\x52\xb0\xc4\xed\xc4\x64\xa1\x60\x05\x7e\x24\x6b\x7c\xae\x3f\x12\xd2\xd2\x94\xcf\xd4\x46\xaf\x29\x31\xd7\x93\x58\xc6\x44\xd9\xc3\xbd\xc0\xc9\x71\xd6\xf6\x02\xe7\x4f\x05\xcd\xb4\x47\xea\x2c\xd0\x99\xf8\x4c\xb4\xdf\x65\xd7\x48\x2d\x19\x09\xb2\x8d\xb0\x7e\x6f\x0a\xec\x33\xe6\x10\xd8\xbb\x5b\x85\xf7\x8b\x75\xfb\x60\x31\xd6\xe7\xae\xf0\x29\xd4\x4e\x49\x4f\x76\xac\x9a\xff\xcc\x70\xa8\xc6\x49\x80\x46\xa0\x17\x66\x49\x25\x7d\x4b\x2a\x69\x2e\xa9\xc6\xea\x99\xfb\x28\x56\x66\x78\x84\x71\xbd\xa9\xd4\xeb\xe7\x28\xd5\x62\x09\x6f\xd5\xb1\x38\xb0\x0a\x93\x81\x52\xd7\x82\xb8\x33\x3b\x83\x88\x55\xcf\x7a\x63\x88\x6f\x48\x37\xed\xd8\xa6\xe6\xb6\xf3\x21\x0a\x16\x26\x5c\x09\xad\x64\xb0\xf4\x75\x9a\xd6\x85\x0f\x42\xa7\x11\x6b\xef\x1f\xb5\x09\xeb\xd2\x57\x9f\x70\x46\x95\x74\x42\x92\xbd\xef\x92\xac\xc8\x85\x79\x8b\x3a\xa7\xd2\x30\xc1\xfd\x2e\x8d\x62\x90\x09\xb2\x12\x48\x53\x26\x7a\xe9\xac\xa5\x4f\xe8\x08\x90\xae\xb3\x9b\x2a\x89\x7c\xb5\xa2\xf4\x49\xed\x70\xc7\xc1\x23\x0b\xd7\xfa\x3c\x7e\xe7\x41\x3b\x4f\xd6\xe6\x80\x1d\x02\x0d\x75\x88\x31\x25\x26\xa0\xa4\x1c\xbf\xf2\x08\xc7\x59\x91\xfd\x6a\xef\xaf\x89\xb8\x1e\x9e\x4e\xc6\xd4\xe6\x35\x2b\xf2\xc4\xc7\xf8\x30\x7d\x89\x2b\x2c\xef\x32\x17\xc9\x6e\x73\x11\xea\x24\x6b\x0a\x87\x7e\x13\x94\xf6\xbc\x3d\xe0\x1b\xe1\xb5\x25\x41\x97\x4e\xa5\xed\xc6\xaa\x54\xa7\x1b\xad\x55\x79\x53\xd7\x6b\xf8\xde\xa3\x22\x96\x6e\x20\xa7\x3b\x34\x43\x3c\x6c\x94\x90\x18\x8f\x06\x1f\x96\xac\x75\x58\x17\x85\x44\x54\x0b\xb5\x9c\xe1\x0a\x2c\xe7\xdc\x2f\xbd\x16\x1a\x87\x02\xcc\xbf\x08\x06\xf8\x77\x34\x8f\xe2\x38\x5d\x98\x0b\xf3\x01\x86\x33\xe0\x46\x2e\xd3\xf9\x60\xd6\x36\x34\x61\xdc\xb3\x96\x93\xd6\x3d\xcd\x7d\xa5\x98\x61\x90\xc2\x49\x8b\xf9\x09\xd0\xab\xf5\x9e\x11\xc4\x7f\x74\x1c\x02\xf4\x1c\xd9\xb6\xc3\xb4\x3a\x11\x34\x4e\x7d\x4c\xf8\xc3\x5f\xaa\x3f\x09\x5d\x83\xa4\x55\x07\x6f\x58\xef\x4a\x57\x32\x56\xf4\x81\xfd\x3f\xf0\x31\x28\x61\x2a\x67\xf1\x33\x4c\xaa\xf2\xd2\x77\x7d\x01\xef\x7c\x77\x28\xe0\xfa\x3f\x59\x94\xbb\x64\xfa\x4c\xa2\xb9\x78\xcc\xd9\x93\x5c\xd3\x6e\x19\xaf\x4a\xa5\xf3\x6d\x87\x14\xf6\xa0\x29\x85\xbd\xfe\x8f\x94\xc2\x2e\xd5\x18\x7d\xfb\xf7\x4a\x61\x7d\x6d\x6c\x48\x61\x57\x5a\x23\xe5\x16\x85\xa7\x3b\x04\x81\x8d\x03\x48\x7d\x28\xba\xc3\x10\x70\x17\xdd\x3f\xb1\x6c\x2b\x80\x72\x45\xae\xfc\xca\x4a\x91\x74\x3a\x0c\xa4\xf1\x68\x32\xfe\xb5\xb1\x52\x54\x4a\xf5\xf1\x0e\xeb\x8e\xdb\x17\x29\x7d\xc9\x48\x65\x02\xc3\x48\x69\x34\xec\x0b\xba\x19\xdc\xb8\x75\xe4\x5f\x85\x28\xb7\x58\xd6\x2c\xae\x03\x3c\x97\xbe\x46\x58\x79\xed\x83\x34\xdb\xad\xfe\xc8\xa7\x3e\x58\x27\x07\x16\x7c\xcb\xaa\x4d\x43\x9a\x6c\xf6\xfa\xa1\x16\x35\x06\x4c\x62\x99\x45\x81\x09\x64\xea\xc7\x4a\x52\x69\x3d\x64\xd7\xf5\x43\x6d\xaf\xf4\xcb\xe7\x65\x03\x3a\x02\x13\x63\x8f\xe7\xb4\x2e\xad\xcd\x9c\xfe\x80\xaf\xb0\xb4\xd4\x79\xec\xcd\xb3\xd2\xfa\xa1\x1f\x14\xcd\xee\xc9\x60\xbb\xf6\x1d\xdb\xef\xf7\x35\x9c\xfb\x54\x35\x7e\xd9\x68\xfc\x55\x95\x13\xba\x79\x0e\xa7\x7d\x55\x42\x73\x1e\x47\x4d\x3a\x19\x0a\xb9\x92\x45\x02\x2d\x8b\x5c\xe3\x90\x8e\x9b\xb2\xc8\xb3\x4e\x59\x04\x45\xd7\x2d\x0b\x44\x8b\x0a\x3b\xcc\x61\xa7\x6c\x16\x38\xc6\x64\x86\x58\x2f\xda\x4b\x70\x5b\x58\xda\x51\xc7\x13\x8d\xd8\xdc\xaa\x86\x5d\x56\x2e\xc5\x6f\x8c\x05\xe8\xae\x45\xe1\x55\x87\x5c\x8f\xd6\x95\x32\xd3\xe9\xa5\xb6\xac\x7c\x6b\xe1\x3f\x98\xaf\x7a\x53\xaf\x23\x6b\x5f\x03\x18\x0f\xce\x35\x12\xf1\x56\x9f\xfb\xd6\x6c\xfd\x05\x6a\xd5\x65\xb3\xf6\x79\x0d\x8e\xc6\x76\x65\xa6\xe8\x64\xdc\x28\x2b\xbb\x56\xf2\x9f\x6b\x55\x7f\xc3\x4d\xda\x2d\xd7\x1f\x11\x26\xc9\x34\x0a\x09\x96\xa2\x0f\x28\xaf\xaa\x43\x04\xb0\x44\xc0\xfc\x95\xf6\xea\xaf\x1f\x97\xe7\x8a\x60\x65\x81\x54\xdc\xf4\x42\x97\xf8\x8a\xba\x8d\xd6\x2f\x07\x26\x43\x77\xe4\x69\xbf\xce\xe7\x91\x76\xd6\xdc\x38\x8b\xfc\xcb\x46\xe0\x4d\x10\x88\x7a\x00\x0e\x8b\xee\x01\xc0\x2e\x3d\xf3\x21\xaf\xdd\xd5\x3f\x6a\xda\xf2\x52\x5f\xb1\xa7\xe7\xfa\x6a\xae\x36\x14\x78\xdf\xb3\x4a\x7a\x78\xdc\x5f\x4a\x47\xef\x11\x12\xfc\x86\x94\x94\x72\x92\xd8\xfc\xaa\x1a\xce\x57\xbe\x5a\x3f\x12\x7d\x5e\x13\x9b\x4b\xe8\x5b\x03\x06\x41\x7c\x70\x92\xe8\x2c\x7e\x26\x84\xf8\xaf\xf8\x80\xa7\x08\x31\x7e\xd3\xa5\x60\xb3\xf4\xaf\xa3\x85\xa7\x25\x0a\xfa\xcd\x5b\x9f\xff\xc5\xad\xbf\xcf\x02\x71\xf3\xd6\xaf\xfe\xba\xd6\x8f\x4a\x54\xf8\x9b\xb7\xfe\xe2\xaf\x6b\xfd\xcc\xc0\xc8\xdf\xb8\x71\xce\xfe\xba\xc6\xff\xe8\x87\xf3\xac\xe6\x40\x3a\x4e\xc1\x66\x0b\x9b\x7d\x81\xe6\x0a\x6f\xed\x18\x1a\x95\xdf\x54\xff\xbc\xea\xcc\xbc\xe1\xbc\xdb\x02\xf3\xfc\x5b\xf8\x5b\xf8\x5b\xf8\xa8\x05\xe4\x39\x0a\xd9\x2c\x8a\x57\x16\x58\xb3\x34\x49\xb3\x39\xf3\x1a\x6e\xca\x1f\xfd\x2d\x87\x38\x13\xa2\x50\x83\x0e\x7f\xe8\xdc\x00\x1b\xf1\x35\xde\xd5\xb6\x6f\x64\x05\xf6\xd4\x15\xd6\xcc\xe3\xc7\xfd\xae\x1d\xef\x7d\xed\xa4\xd1\x84\x10\xee\xf2\x4a\x69\xfb\x74\xac\xd7\x8a\x23\x5d\x6e\xa6\xfe\xeb\x6c\x7d\x0a\x4d\x57\xe2\xa9\x36\x14\x86\x5d\x5d\xd2\xe9\x5a\x1a\x9e\x2f\x4b\x72\xec\x43\x00\x12\x18\xdc\xba\x95\xff\xa9\x4e\x7a\x8b\x0e\x27\xcc\x58\xe9\x56\x4b\xf0\xaa\x0f\xaf\xc0\xb4\xa4\x8b\x84\xe2\x15\xd4\x66\x07\x1a\xe6\x29\x01\x84\xe6\x0b\x35\x32\x5f\x08\x3d\x07\x39\x2d\x13\x5e\x03\x89\x42\xbb\xbb\x1d\xf8\xdd\x31\xd4\x5f\x3b\x7d\x95\x6b\xa7\xdf\x20\x43\xd3\x01\x8b\x0d\xee\x1c\x2c\xc8\x4b\x1f\x4e\x7c\x4c\xbf\x03\x4b\xf2\xce\x87\x33\x1f\x18\x5e\x7e\xdd\xca\xac\x82\xf5\x2c\x18\x2c\x89\xef\xc3\xa9\x54\x1f\xac\xbe\xfc\x14\x12\xdb\xdb\xf6\xd7\x69\x95\xfe\x2e\x89\x1a\x1e\x18\x6a\x4d\xb4\x2e\xfe\x5b\xff\xb8\x7f\x8b\xd7\x6b\xf8\xec\xbb\x3f\x9e\x3a\x35\xdc\x3c\xa8\x5d\xc2\x38\x25\xac\xe1\x6d\xf9\xb4\xb6\x4b\xab\xe7\xe7\xe5\xd5\x1a\x3e\x55\x25\x4c\x96\x0e\x7c\xae\x7f\xaf\xe1\x08\x4d\x40\x9f\x7d\x78\xeb\xc3\x27\x1f\x54\xc9\x12\x82\x72\x2e\xd2\x59\x20\xa7\x41\x9e\xd9\x51\x7a\xc7\x4f\xbd\x4c\x77\x21\x4a\x2e\xf4\x8f\x19\x4b\xd8\x45\x20\xee\xe8\x2a\x8f\x83\x78\x6e\xad\xbf\x52\x78\xa1\x1b\xd4\x77\xad\x35\x7c\xe9\x55\xf9\x0e\x3b\xf1\xdc\xb6\x53\xde\x7c\xf6\x37\x94\xe1\x17\x7e\x39\xd4\x66\x7e\x0c\xd1\xb5\x57\xcf\x5b\x7f\x03\xb9\xed\x93\xbf\x39\xc2\x2f\x7c\x45\xd4\x14\x04\xdd\xb3\x06\x75\xb8\xf4\x9a\x42\x32\xfc\x95\xc5\xba\x19\xa6\x61\xdd\x5e\x91\x2f\x46\x0f\x2e\x69\xd6\x6b\x1a\x5b\x4a\x2c\xe1\xb4\x20\xc2\x7e\x8a\x20\x40\x26\x3e\x08\xda\xd1\x42\xc6\x71\x69\xa8\x25\x78\x73\x6a\x08\x52\x5f\x27\xac\xb0\x28\x04\xc3\x6e\x39\x4b\x0c\x1b\x0d\x72\x26\x06\xfa\x9f\x91\x4c\x2f\x2e\xe2\x80\xf1\x38\x18\xcd\xfc\xf2\x66\x1c\x5d\x4c\x65\xed\x58\x3a\xe3\xa3\x07\x83\xb9\x1c\xdd\x1b\xcc\x11\x46\xa8\x8d\x87\xc4\x53\x29\xd3\x99\x05\xd6\x64\xbe\x1c\x64\x69\x1c\xf9\x03\x71\xc1\x19\x19\xc3\x40\xff\x6f\x4f\xee\x3e\xa0\xf5\x72\x95\xc3\x7a\x2b\x49\x24\x8b\x92\xe6\xd1\x67\x6b\x5c\x54\x57\xb8\x60\x89\x5f\x1a\x9c\xb7\x3c\x07\x0c\x95\x6d\x8b\xaa\xe6\x6d\x1c\x93\xaf\x26\x70\x0e\x05\xd6\x64\x48\x04\x85\x23\x9f\x76\x3a\xf4\x37\x73\x6b\x75\x7a\xe5\x6d\x19\x45\x36\x36\xda\x28\x89\xa3\x24\xa8\x23\xa5\xb6\xbf\xab\x27\xa4\x74\xc3\xa0\x9e\x04\x8b\x96\x26\xd4\xf0\xfe\xa8\xfc\xab\x49\xd3\x53\x47\xac\x21\xdf\x41\x95\x9b\x5c\xd4\x9c\xa8\x30\xdf\xd7\xca\xc7\x7d\x0c\xc5\x2c\x63\xac\x0c\xc2\x95\xd8\x76\x0c\x86\x60\xa8\xf8\xfc\xd5\xa6\x4c\x60\x26\x52\x11\x48\xc5\x99\x3f\xf8\xa4\xe1\x6e\xc7\xba\x08\xf3\xc7\xd0\x99\xfc\x66\x4c\xbc\x5e\x5f\x81\xd2\x5b\x3c\xea\x24\x6d\x5e\x19\xfd\x21\x1d\xba\x73\x41\x2c\x81\xb8\x4b\x61\xef\x68\x2c\x48\x34\x04\x0b\xd7\x1c\x68\xc8\xd4\x84\x42\x3a\x24\x56\x26\x57\x71\x90\x4d\x83\x40\xfb\x6b\x7f\xc8\xc0\x8a\x53\xe6\xeb\x60\x67\x12\x46\x1a\xa1\xd8\x3c\x09\x84\x48\x85\x79\x94\x46\xc4\x7a\xc6\xa2\x38\xf0\x07\x32\x1d\xa8\x77\x06\xfb\xe7\xe7\x83\x50\xa4\x33\x07\x9d\x0e\xa9\x09\x8f\x5e\x53\xe0\x8d\xaf\xe8\x9a\x21\x92\xb8\xc2\xf6\x78\x6b\xe7\x0b\x87\x90\xdc\xb6\xe2\x88\xdf\xe1\x69\x2a\x33\x29\xd8\x7c\x74\xdf\x1e\xdb\xe3\x11\x8b\xe7\x53\x66\x3f\x1c\xf9\x51\x26\xef\x78\x59\x56\x17\xb0\x67\x51\x62\x7b\x4a\xf1\x64\xe8\x69\x51\xd7\x81\x92\x13\x5b\x04\x59\x3a\x0b\x46\xf7\xed\xdf\xec\x31\xbe\xd9\xbc\x5d\xbf\xec\x0d\xb5\x48\xb7\x75\xe4\x75\x4d\x84\xcd\x0f\x41\xd8\xfc\x0b\x7d\x5c\x03\x0f\x8b\xf2\x57\xe3\xe0\xab\x16\x3a\xaa\x9b\x7c\x5b\x38\xaa\x3f\x38\x18\x2a\x8e\x77\x53\x1a\x2b\x85\xbb\x92\xeb\x73\x11\xb0\xcb\x41\x52\x2d\x55\x7d\x2d\xd6\x9b\xfb\x6f\x3e\xd4\xe9\xef\x9b\xc7\x20\x51\x48\xee\xa2\xe9\x5d\xf5\xaf\xac\xa8\xac\xa0\xc5\x09\xd6\x9b\xf5\x20\x14\x0a\xa9\xd6\x63\xb2\x86\xac\x3d\xd3\xe5\x49\xa1\xf7\x1d\x3c\xf5\xcf\x25\xc8\x66\x8a\x09\x69\x33\x92\x90\x23\x41\x28\xa5\xeb\x52\x26\xfb\x2c\xc8\x8f\x57\x4e\x55\xaa\xca\x87\x35\x90\x36\x73\x19\x24\xd2\x66\xbe\x7f\x58\x04\x89\x7c\x19\x65\x32\x48\x02\xa5\x6f\xa7\xf3\x4c\xdb\xc9\x24\x55\x25\x12\x56\x44\x17\x4c\xa6\xc2\xce\xb3\x40\x3c\xb9\x08\x12\x69\x47\x89\x1f\x2c\x5f\x87\xc4\x7a\x27\x22\x1f\x7d\x53\xfe\x39\xfe\xf9\xb3\xb3\xba\x29\xcb\xa6\x25\x74\x98\xdc\x06\xad\x8e\x42\x72\x4b\xcd\x96\x14\xf1\x8b\x60\xf5\xf3\xa7\xb0\x67\x81\x64\xe6\x67\x36\x8d\x42\x89\xbf\x27\xff\x54\xf2\x1c\x26\x22\xf8\xf9\x33\xb1\x35\xc4\x90\xfa\xe5\xa7\x8b\x44\x2d\x18\x4a\x7f\x08\x7b\x2e\x02\xd5\xb8\x49\xd4\x4e\xea\x18\x88\xa9\x08\x42\x08\x5c\x35\x3a\x90\xbb\x61\x4a\x24\xb5\xd9\x63\x46\x3c\x92\xff\xfd\xef\x81\xcd\xee\xbb\xae\x9b\xdb\xec\x3e\x5e\x9c\xea\x8b\x53\xbc\x18\xdb\x4c\x5f\x8e\x6d\xb6\x67\x5c\x24\xf2\xb5\x63\x9c\x4e\xe4\x1a\x8d\xd0\x6b\xe0\xf7\x9d\xce\x23\x13\x61\xf3\xfb\x90\x00\x36\x2c\xe9\x1a\xbc\xe7\x8e\xb0\xbd\xe7\xe0\x1d\xab\x7f\x8f\xc1\x7b\xa2\xfe\x7d\xa2\xaa\x28\x86\xee\x97\x84\x0c\x29\xc4\xbd\x9c\xc7\xf8\x57\xed\x09\x07\xb1\x8f\x11\x26\x57\xe7\xbf\xf3\x87\xfd\xe7\x5b\x26\x0f\xc5\x9e\x74\x8e\x89\x84\x63\x82\xd1\x85\xda\x9b\x6b\xe8\x66\x43\xf2\x83\xdf\x77\x5e\x66\xe0\x7d\x77\x56\x0c\xbc\x4b\x67\x4b\x31\x78\x5c\xd9\x43\x87\x7b\xa5\x9f\x6e\x62\xb3\xb5\xa3\xf5\x34\x28\x9d\x93\x17\xc4\x1f\x82\xf5\x37\x3c\x45\x3e\x01\x7d\xb5\x87\xe7\xce\x33\x8c\xf1\x8f\x87\xea\xc9\x18\x8e\x95\xc4\x7f\x7f\xaf\xc6\x23\x77\x6a\x90\x72\x61\xb3\x53\x0c\xe6\x60\x0c\x9d\x6d\xd7\x6a\x88\xce\x03\x52\x0c\xa9\x1a\xb4\xb3\x4c\x0d\x61\x07\x9f\xe7\x07\xce\x05\xf9\x17\x1f\x6a\x6c\x62\xef\xd0\x69\x6f\xf0\xeb\xf5\x9a\x3e\x7e\x12\xb9\x3f\x5e\xb1\x28\x71\x7e\x44\x49\x24\x9d\xe1\x90\xbc\x0b\x29\x19\xd3\xf5\x1a\x12\xfb\x30\x9e\xed\x95\xf5\x0e\x10\x86\x50\x23\xbd\xe0\xd9\xee\x20\x4a\x06\x92\xe2\x3f\x62\x0f\x81\x1d\x2d\xd7\x0d\xf6\xce\xc8\x43\xea\x24\x44\xfc\x2b\xf8\x0a\xf2\x5f\xc1\x57\xea\xa8\x9f\xae\xfa\xa9\xd4\x99\xc3\x78\x06\x4f\x22\xea\xe0\x2f\xf7\x49\xb4\x26\x72\x1a\x65\xf4\xf1\xff\x0d\x00\x00\xff\xff\xd6\x6a\xef\xb7\x75\x71\x01\x00"), }, "/templates": &vfsgen۰DirInfo{ name: "templates", diff --git a/test/with_api_v2/acceptance.go b/test/with_api_v2/acceptance.go index e6b977aa..786db77e 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 50d2c492..bacb8b05 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 c944e4fe..235b2109 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 6f585fc7..00000000 --- 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 3b9e3090..00000000 --- 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 2fae2aee..db0c79e6 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 fd2b08b0..e0773d7b 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 6b49b302..96b21e39 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 bd6f3450..ae9babba 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_silences_parameters.go b/test/with_api_v2/api_v2_client/client/silence/get_silences_parameters.go index f26119be..a7c2ceda 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/post_silences_parameters.go b/test/with_api_v2/api_v2_client/client/silence/post_silences_parameters.go index f0dd9a2c..767a224b 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" 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 4a399eed..0755b385 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 00000000..673deaab --- /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 00000000..6b41f1bc --- /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 d205a60a..5c6c785d 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 - Name *string `json:"name"` + Cluster *ClusterStatus `json:"cluster"` - // peers + // config // Required: true - // Minimum: 0 - Peers []*PeerStatus `json:"peers"` + Config *AlertmanagerConfig `json:"config"` - // status in cluster + // uptime // Required: true - StatusInCluster *string `json:"statusInCluster"` + // Format: date-time + Uptime *strfmt.DateTime `json:"uptime"` + + // version info + // Required: true + 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 } - return nil -} - -func (m *AlertmanagerStatus) 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 + 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) validateStatusInCluster(formats strfmt.Registry) error { +func (m *AlertmanagerStatus) validateConfig(formats strfmt.Registry) error { - if err := validate.Required("statusInCluster", "body", m.StatusInCluster); err != nil { + if err := validate.Required("config", "body", m.Config); err != nil { 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) validateVersionInfo(formats strfmt.Registry) error { + + 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 00000000..2ce826ec --- /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/matcher.go b/test/with_api_v2/api_v2_client/models/matcher.go index f626e306..78bc8194 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 ddfd58b1..9d9c34f4 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/receiver.go b/test/with_api_v2/api_v2_client/models/receiver.go index e7ceccef..61c2748a 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 747edcfa..651aa4bf 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,14 +18,17 @@ 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"` + EndsAt *strfmt.DateTime `json:"endsAt"` // id ID string `json:"id,omitempty"` @@ -37,21 +38,30 @@ type Silence struct { Matchers Matchers `json:"matchers"` // starts at + // Required: true // Format: date-time - StartsAt strfmt.DateTime `json:"startsAt,omitempty"` + StartsAt *strfmt.DateTime `json:"startsAt"` // status Status *SilenceStatus `json:"status,omitempty"` // updated at // Format: date-time - UpdatedAt strfmt.DateTime `json:"updatedAt,omitempty"` + UpdatedAt *strfmt.DateTime `json:"updatedAt,omitempty"` } // Validate validates this silence func (m *Silence) Validate(formats strfmt.Registry) error { var res []error + if err := m.validateComment(formats); err != nil { + res = append(res, err) + } + + if err := m.validateCreatedBy(formats); err != nil { + res = append(res, err) + } + if err := m.validateEndsAt(formats); err != nil { res = append(res, err) } @@ -78,10 +88,28 @@ func (m *Silence) Validate(formats strfmt.Registry) error { return nil } +func (m *Silence) validateComment(formats strfmt.Registry) error { + + if err := validate.Required("comment", "body", m.Comment); err != nil { + return err + } + + return nil +} + +func (m *Silence) validateCreatedBy(formats strfmt.Registry) error { + + if err := validate.Required("createdBy", "body", m.CreatedBy); err != nil { + return err + } + + return nil +} + func (m *Silence) validateEndsAt(formats strfmt.Registry) error { - if swag.IsZero(m.EndsAt) { // not required - return nil + if err := validate.Required("endsAt", "body", m.EndsAt); err != nil { + return err } if err := validate.FormatOf("endsAt", "body", "date-time", m.EndsAt.String(), formats); err != nil { @@ -109,8 +137,8 @@ func (m *Silence) validateMatchers(formats strfmt.Registry) error { func (m *Silence) validateStartsAt(formats strfmt.Registry) error { - if swag.IsZero(m.StartsAt) { // not required - return nil + if err := validate.Required("startsAt", "body", m.StartsAt); err != nil { + return err } if err := validate.FormatOf("startsAt", "body", "date-time", m.StartsAt.String(), formats); err != nil { @@ -168,90 +196,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 00000000..82c9b435 --- /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 00000000..5cdbc2bd --- /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 944ae412..6915b77d 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 56d9dff9..17cd5864 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,26 @@ 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 + 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 77031fb3..6a6fc20a 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/Data/Alert.elm b/ui/app/src/Data/Alert.elm new file mode 100644 index 00000000..5bf450dc --- /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 00000000..f70a123e --- /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 00000000..c3a939b9 --- /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 00000000..16a058d6 --- /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 00000000..8d1d93f3 --- /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 00000000..984fc10c --- /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/InlineResponse200.elm b/ui/app/src/Data/InlineResponse200.elm new file mode 100644 index 00000000..3299743d --- /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 00000000..8fc72a9a --- /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 00000000..34985938 --- /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 00000000..a5327350 --- /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/Receiver.elm b/ui/app/src/Data/Receiver.elm new file mode 100644 index 00000000..3836d5ad --- /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 00000000..94aded15 --- /dev/null +++ b/ui/app/src/Data/Silence.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.Silence exposing (Silence, 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 Silence = + { id : Maybe String + , matchers : Matchers + , startsAt : DateTime + , endsAt : DateTime + , updatedAt : Maybe DateTime + , createdBy : String + , comment : String + , status : Maybe SilenceStatus + } + + +decoder : Decoder Silence +decoder = + Decode.succeed Silence + |> optional "id" (Decode.nullable Decode.string) Nothing + |> required "matchers" Matchers.decoder + |> required "startsAt" DateTime.decoder + |> required "endsAt" DateTime.decoder + |> optional "updatedAt" (Decode.nullable DateTime.decoder) Nothing + |> required "createdBy" Decode.string + |> required "comment" Decode.string + |> optional "status" (Decode.nullable SilenceStatus.decoder) Nothing + + +encoder : Silence -> Encode.Value +encoder model = + Encode.object + [ ( "id", Maybe.withDefault Encode.null (Maybe.map Encode.string model.id) ) + , ( "matchers", Matchers.encoder model.matchers ) + , ( "startsAt", DateTime.encoder model.startsAt ) + , ( "endsAt", DateTime.encoder model.endsAt ) + , ( "updatedAt", Maybe.withDefault Encode.null (Maybe.map DateTime.encoder model.updatedAt) ) + , ( "createdBy", Encode.string model.createdBy ) + , ( "comment", Encode.string model.comment ) + , ( "status", Maybe.withDefault Encode.null (Maybe.map SilenceStatus.encoder model.status) ) + ] diff --git a/ui/app/src/Data/SilenceStatus.elm b/ui/app/src/Data/SilenceStatus.elm new file mode 100644 index 00000000..63ecff18 --- /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/Silences.elm b/ui/app/src/Data/Silences.elm new file mode 100644 index 00000000..0e87db59 --- /dev/null +++ b/ui/app/src/Data/Silences.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.Silences exposing (Silences, decoder, encoder) + +import Data.Silence as Silence exposing (Silence) +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 Silences = + List Silence + + +decoder : Decoder Silences +decoder = + Decode.list Silence.decoder + + +encoder : Silences -> Encode.Value +encoder items = + Encode.list Silence.encoder items diff --git a/ui/app/src/Data/VersionInfo.elm b/ui/app/src/Data/VersionInfo.elm new file mode 100644 index 00000000..68f4e20b --- /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 00000000..a560b458 --- /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 120fa09f..20de9f1e 100644 --- a/ui/app/src/Silences/Api.elm +++ b/ui/app/src/Silences/Api.elm @@ -1,9 +1,9 @@ module Silences.Api exposing (create, destroy, getSilence, getSilences) +import Data.Silence exposing (Silence) +import Data.Silences 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(..)) @@ -15,7 +15,7 @@ getSilences apiUrl filter msg = url = String.join "/" [ apiUrl, "silences" ++ generateQueryString filter ] in - Utils.Api.send (Utils.Api.get url list) + Utils.Api.send (Utils.Api.get url Data.Silences.decoder) |> Cmd.map msg @@ -25,7 +25,7 @@ getSilence apiUrl uuid msg = url = String.join "/" [ apiUrl, "silence", uuid ] in - Utils.Api.send (Utils.Api.get url show) + Utils.Api.send (Utils.Api.get url Data.Silence.decoder) |> Cmd.map msg @@ -36,7 +36,7 @@ create apiUrl silence = String.join "/" [ apiUrl, "silences" ] body = - Http.jsonBody <| Silences.Encoders.silence silence + Http.jsonBody <| Data.Silence.encoder silence in -- TODO: This should return the silence, not just the ID, so that we can -- redirect to the silence show page. @@ -50,7 +50,9 @@ destroy apiUrl silence msg = -- be matching on /silences and ignoring the :sid, should be getting a 404. let url = - String.join "/" [ apiUrl, "silence", silence.id ] + -- TODO: Maybe.withDefault is not perfect. Silences should always + -- have an id, what should we do? + String.join "/" [ apiUrl, "silence", Maybe.withDefault "" silence.id ] responseDecoder = -- Silences.Encoders.silence silence diff --git a/ui/app/src/Silences/Decoders.elm b/ui/app/src/Silences/Decoders.elm index 6399be5a..dc89485b 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 98b04e5c..00000000 --- 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 1cbc1df7..035b76f1 100644 --- a/ui/app/src/Silences/Types.elm +++ b/ui/app/src/Silences/Types.elm @@ -1,63 +1,44 @@ 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.Silence exposing (Silence) +import Data.SilenceStatus exposing (SilenceStatus, State(..)) import Time exposing (Posix) -import Utils.Types exposing (Matcher) nullSilence : Silence nullSilence = - { id = "" + { id = Nothing , createdBy = "" , comment = "" , startsAt = Time.millisToPosix 0 , endsAt = Time.millisToPosix 0 - , updatedAt = Time.millisToPosix 0 - , matchers = [ nullMatcher ] - , status = nullSilenceStatus + , updatedAt = Nothing + , matchers = nullMatchers + , status = Nothing } -nullSilenceStatus : Status +nullSilenceStatus : SilenceStatus nullSilenceStatus = { state = Expired } +nullMatchers : Matchers +nullMatchers = + [ nullMatcher ] + + 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 - } - - -type State - = Active - | Pending - | Expired + Matcher "" "" False stateToString : State -> String @@ -71,7 +52,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 0708c5fd..6155828e 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/Utils/List.elm b/ui/app/src/Utils/List.elm index 4c45bfca..b3e4d527 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 1b08e652..173a55c3 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/SilenceForm/Parsing.elm b/ui/app/src/Views/SilenceForm/Parsing.elm index 44436590..5c71b0da 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 f4fd1d61..69c98fdb 100644 --- a/ui/app/src/Views/SilenceForm/Types.elm +++ b/ui/app/src/Views/SilenceForm/Types.elm @@ -15,7 +15,9 @@ module Views.SilenceForm.Types exposing import Alerts.Types exposing (Alert) import Browser.Navigation exposing (Key) -import Silences.Types exposing (Silence, SilenceId, nullSilence) +import Data.Matcher exposing (Matcher) +import Data.Silence exposing (Silence) +import Silences.Types exposing (nullSilence) import Time exposing (Posix) import Utils.Date exposing (addDuration, durationFormat, parseDuration, timeDifference, timeFromString, timeToString) import Utils.Filter @@ -27,7 +29,7 @@ import Utils.FormValidation , stringNotEmpty , validate ) -import Utils.Types exposing (ApiData(..), Duration, Matcher) +import Utils.Types exposing (ApiData(..), Duration) type alias Model = @@ -40,7 +42,7 @@ type alias Model = type alias SilenceForm = - { id : String + { id : Maybe String , createdBy : ValidatedField , comment : ValidatedField , startsAt : ValidatedField @@ -67,7 +69,7 @@ type SilenceFormMsg | NewSilenceFromMatchers String (List Utils.Filter.Matcher) | NewSilenceFromMatchersAndTime String (List Utils.Filter.Matcher) Posix | SilenceFetch (ApiData Silence) - | SilenceCreate (ApiData SilenceId) + | SilenceCreate (ApiData String) type SilenceFormFieldMsg @@ -167,7 +169,7 @@ validateMatcherForm { name, value, isRegex } = empty : SilenceForm empty = - { id = "" + { id = Nothing , createdBy = initialField "" , comment = initialField "" , startsAt = initialField "" @@ -211,12 +213,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/Views.elm b/ui/app/src/Views/SilenceForm/Views.elm index b33dadff..53814517 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 59ac27e2..7622eee2 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.Matcher exposing (Matcher) +import Data.Matchers exposing (Matchers) +import Data.Silence exposing (Silence) +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 @@ -26,15 +29,20 @@ view showConfirmationDialog silence = , class "align-items-start list-group-item border-0 p-0 mb-4" ] [ div [ class "w-100 mb-2 d-flex align-items-start" ] - [ case silence.status.state of - Active -> - dateView "Ends" silence.endsAt + [ case silence.status of + Just status -> + case status.state of + Active -> + dateView "Ends" silence.endsAt - Pending -> - dateView "Starts" silence.startsAt + Pending -> + dateView "Starts" silence.startsAt - Expired -> - dateView "Expired" silence.endsAt + Expired -> + dateView "Expired" silence.endsAt + + Nothing -> + text "" , detailsButton silence.id , editButton silence , deleteButton silence False @@ -100,53 +108,73 @@ editButton silence = let matchers = List.map (\s -> ( s.name, s.value )) silence.matchers - in - case silence.status.state of - -- If the silence is expired, do not edit it, but instead create a new - -- one with the old matchers - Expired -> - a - [ class "btn btn-outline-info border-0" - , href (newSilenceFromAlertLabels matchers) - ] - [ text "Recreate" - ] - _ -> - let - editUrl = - String.join "/" [ "#/silences", silence.id, "edit" ] - in + editUrl = + -- TODO: silence.id should always be set. Can this be done nicer? + String.join "/" [ "#/silences", Maybe.withDefault "" silence.id, "edit" ] + + default = a [ class "btn btn-outline-info border-0", href editUrl ] [ text "Edit" ] + in + case silence.status of + Just status -> + case status.state of + -- If the silence is expired, do not edit it, but instead create a new + -- one with the old matchers + Expired -> + a + [ class "btn btn-outline-info border-0" + , href (newSilenceFromAlertLabels <| Dict.fromList matchers) + ] + [ text "Recreate" + ] + + _ -> + default + + Nothing -> + default deleteButton : Silence -> Bool -> Html Msg deleteButton silence refresh = - case silence.status.state of - Expired -> + -- TODO: status should always be set, how to solve this better? + case silence.status of + Just status -> + case status.state of + Expired -> + text "" + + Active -> + button + [ class "btn btn-outline-danger border-0" + , onClick (MsgForSilenceList (ConfirmDestroySilence silence refresh)) + ] + [ text "Expire" + ] + + Pending -> + button + [ class "btn btn-outline-danger border-0" + , onClick (MsgForSilenceList (ConfirmDestroySilence silence refresh)) + ] + [ text "Delete" + ] + + Nothing -> text "" - Active -> - button - [ class "btn btn-outline-danger border-0" - , onClick (MsgForSilenceList (ConfirmDestroySilence silence refresh)) - ] - [ text "Expire" + +detailsButton : Maybe String -> Html Msg +detailsButton maybeSilenceId = + -- TODO: Again, silence.id should not be Nothing here, how can this be done better? + case maybeSilenceId of + Just id -> + a [ class "btn btn-outline-info border-0", href ("#/silences/" ++ id) ] + [ text "View" ] - Pending -> - button - [ class "btn btn-outline-danger border-0" - , onClick (MsgForSilenceList (ConfirmDestroySilence silence refresh)) - ] - [ text "Delete" - ] - - -detailsButton : String -> Html Msg -detailsButton silenceId = - a [ class "btn btn-outline-info border-0", href ("#/silences/" ++ silenceId) ] - [ text "View" - ] + Nothing -> + text "" diff --git a/ui/app/src/Views/SilenceList/Types.elm b/ui/app/src/Views/SilenceList/Types.elm index 51a9bca8..38df39d3 100644 --- a/ui/app/src/Views/SilenceList/Types.elm +++ b/ui/app/src/Views/SilenceList/Types.elm @@ -1,7 +1,9 @@ module Views.SilenceList.Types exposing (Model, SilenceListMsg(..), SilenceTab, initSilenceList) import Browser.Navigation exposing (Key) -import Silences.Types exposing (Silence, SilenceId, State(..)) +import Data.Silence exposing (Silence) +import Data.SilenceStatus exposing (State(..)) +import Data.Silences exposing (Silences) import Utils.Types exposing (ApiData(..)) import Views.FilterBar.Types as FilterBar @@ -16,7 +18,7 @@ type SilenceListMsg type alias SilenceTab = - { silences : List Silence + { silences : Silences , 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 78670639..c058c725 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.Silence exposing (Silence) +import Data.SilenceStatus exposing (State(..)) +import Data.Silences exposing (Silences) 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) @@ -33,7 +35,7 @@ update msg model filter basePath apiUrl = ) ConfirmDestroySilence silence refresh -> - ( { model | showConfirmationDialog = Just silence.id } + ( { model | showConfirmationDialog = silence.id } , Cmd.none ) @@ -79,9 +81,19 @@ states = [ Active, Pending, Expired ] -filterSilencesByState : State -> List Silence -> List Silence +filterSilencesByState : State -> Silences -> Silences filterSilencesByState state = - List.filter (.status >> .state >> (==) state) + List.filter (filterSilenceByState state) + + +filterSilenceByState : State -> Silence -> Bool +filterSilenceByState state silence = + case silence.status of + Just status -> + status.state == state + + Nothing -> + False urlUpdate : Maybe String -> ( SilenceListMsg, Filter ) diff --git a/ui/app/src/Views/SilenceList/Views.elm b/ui/app/src/Views/SilenceList/Views.elm index e14e7ca6..60c2d053 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.Silence exposing (Silence) +import Data.SilenceStatus exposing (State(..)) +import Data.Silences exposing (Silences) 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 -> @@ -70,9 +73,9 @@ silencesView showConfirmationDialog tab silencesTab = Html.Keyed.ul [ class "list-group" ] (List.map (\silence -> - ( silence.id + ( Maybe.withDefault "" silence.id , Views.SilenceList.SilenceView.view - (showConfirmationDialog == Just silence.id) + (showConfirmationDialog == silence.id) silence ) ) @@ -97,6 +100,23 @@ states = [ Active, Pending, Expired ] -filterSilencesByState : State -> List Silence -> List Silence +filterSilencesByState : State -> Silences -> Silences filterSilencesByState state = - List.filter (.status >> .state >> (==) state) + List.filter (filterSilenceByState state) + + +filterSilenceByState : State -> Silence -> Bool +filterSilenceByState state silence = + -- TODO: Can this be done cleaner? + Maybe.withDefault False <| Maybe.map (.state >> (==) state) <| .status silence + + + +{- + case silence.status of + Just status -> + status.state == state + + Nothing -> + False +-} diff --git a/ui/app/src/Views/SilenceView/Types.elm b/ui/app/src/Views/SilenceView/Types.elm index f186e362..f5a37738 100644 --- a/ui/app/src/Views/SilenceView/Types.elm +++ b/ui/app/src/Views/SilenceView/Types.elm @@ -2,7 +2,8 @@ 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.Silence exposing (Silence) +import Data.Silences exposing (Silences) import Utils.Types exposing (ApiData(..)) @@ -11,7 +12,7 @@ type SilenceViewMsg | SilenceFetched (ApiData Silence) | SetActiveAlert (Maybe String) | AlertGroupsPreview (ApiData (List Alert)) - | InitSilenceView SilenceId + | InitSilenceView String | ConfirmDestroySilence Silence Bool | Reload String diff --git a/ui/app/src/Views/SilenceView/Updates.elm b/ui/app/src/Views/SilenceView/Updates.elm index c36e66cc..88f5287a 100644 --- a/ui/app/src/Views/SilenceView/Updates.elm +++ b/ui/app/src/Views/SilenceView/Updates.elm @@ -45,6 +45,7 @@ update msg model apiUrl = ( { model | silence = silence, alerts = Initial }, Cmd.none ) InitSilenceView silenceId -> + -- TODO: silenceId should never be Nothing, can this be done cleaner? ( { model | showConfirmationDialog = False }, getSilence apiUrl silenceId SilenceFetched ) Reload silenceId -> diff --git a/ui/app/src/Views/SilenceView/Views.elm b/ui/app/src/Views/SilenceView/Views.elm index eaf0f2d5..9e635454 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.Silence exposing (Silence) +import Data.SilenceStatus +import Data.Silences exposing (Silences) 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 @@ -54,13 +57,13 @@ viewSilence activeAlertId alerts silence showPromptDialog = , expireButton silence False ] ] - , formGroup "ID" <| text silence.id + , formGroup "ID" <| text <| Maybe.withDefault "" silence.id , 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 "Updated at" <| text <| Maybe.withDefault "" <| Maybe.map dateTimeFormat silence.updatedAt + , formGroup "Created by" <| text <| silence.createdBy , formGroup "Comment" <| text silence.comment - , formGroup "State" <| text <| stateToString silence.status.state + , formGroup "State" <| text <| Maybe.withDefault "" <| Maybe.map (.state >> stateToString) silence.status , formGroup "Matchers" <| div [] <| List.map (Utils.List.mstring >> Utils.Views.labelButton Nothing) silence.matchers @@ -77,7 +80,8 @@ viewSilence activeAlertId alerts silence showPromptDialog = confirmSilenceDeleteView : Silence -> Bool -> Dialog.Config Msg confirmSilenceDeleteView silence refresh = - { onClose = MsgForSilenceView (SilenceViewTypes.Reload silence.id) + -- TODO: silence.id should never be Nothing in this context. How to better handle this? + { onClose = MsgForSilenceView (SilenceViewTypes.Reload <| Maybe.withDefault "" silence.id) , title = "Expire Silence" , body = text "Are you sure you want to expire this silence?" , footer = @@ -101,22 +105,28 @@ formGroup key content = expireButton : Silence -> Bool -> Html Msg expireButton silence refresh = - case silence.status.state of - Silences.Types.Expired -> + -- TODO: .status should never be nothing, how can we handle this better? + case silence.status of + Just { state } -> + case state of + Data.SilenceStatus.Expired -> + text "" + + Data.SilenceStatus.Active -> + button + [ class "btn btn-outline-danger border-0" + , onClick (MsgForSilenceView (SilenceViewTypes.ConfirmDestroySilence silence refresh)) + ] + [ text "Expire" + ] + + Data.SilenceStatus.Pending -> + button + [ class "btn btn-outline-danger border-0" + , onClick (MsgForSilenceView (SilenceViewTypes.ConfirmDestroySilence silence refresh)) + ] + [ text "Delete" + ] + + Nothing -> text "" - - Silences.Types.Active -> - button - [ class "btn btn-outline-danger border-0" - , onClick (MsgForSilenceView (SilenceViewTypes.ConfirmDestroySilence silence refresh)) - ] - [ text "Expire" - ] - - Silences.Types.Pending -> - button - [ class "btn btn-outline-danger border-0" - , onClick (MsgForSilenceView (SilenceViewTypes.ConfirmDestroySilence silence refresh)) - ] - [ text "Delete" - ] diff --git a/ui/app/src/Views/Status/Types.elm b/ui/app/src/Views/Status/Types.elm index 4b393635..a7f0438d 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 66846a1e..4a3f52b0 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 44b5b88c..e14f9cbb 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 "" ]